Python - Copy Sets – Complete Guide for Beginners

When working with sets in Python, there are many situations where you need to create a duplicate of an existing set. For example, you may want to preserve the original data while making changes to a new set.

Python provides simple ways to copy sets, allowing you to create an exact duplicate without affecting the original collection.

In this tutorial, you will learn:

• Why copying sets is important
• How to use the copy() method
• How to use the set() constructor
• The difference between assignment and copying
• Shallow copy behavior
• Real-world examples
• Common mistakes and best practices

By the end of this guide, you'll understand how to safely duplicate sets in Python.

---

Why Copy a Set?

Consider a set containing user permissions:

permissions = {
    "read",
    "write",
    "delete"
}

If you want to experiment with changes while keeping the original data intact, creating a copy is the safest approach.

Without copying, modifications can affect the original set.

---

Using the copy() Method

The easiest way to copy a set is with the copy() method.

Syntax

new_set = original_set.copy()

---

Example

fruits = {
    "apple",
    "banana",
    "orange"
}

fruits_copy = fruits.copy()

print(fruits_copy)

Output

{'apple', 'banana', 'orange'}

The new set contains all items from the original set.

---

Verify the Copy

numbers = {
    1,
    2,
    3
}

numbers_copy = numbers.copy()

print(numbers)
print(numbers_copy)

Output

{1, 2, 3}
{1, 2, 3}

Both sets contain the same values.

---

Modifying the Copy

After creating a copy, changes to the new set do not affect the original.

fruits = {
    "apple",
    "banana"
}

fruits_copy = fruits.copy()

fruits_copy.add("orange")

print("Original:", fruits)
print("Copy:", fruits_copy)

Output

Original: {'apple', 'banana'}
Copy: {'apple', 'banana', 'orange'}

The original set remains unchanged.

---

Using the set() Constructor

Another way to copy a set is by using the set() constructor.

Syntax

new_set = set(existing_set)

---

Example

colors = {
    "red",
    "green",
    "blue"
}

colors_copy = set(colors)

print(colors_copy)

Output

{'red', 'green', 'blue'}

---

copy() vs set()

Both methods produce the same result.

Using copy():

set2 = set1.copy()

Using set():

set2 = set(set1)

Result

Both create a separate set containing the same elements.

---

Assignment Is Not Copying

Many beginners make this mistake.

set1 = {
    1,
    2,
    3
}

set2 = set1

At first glance, it looks like a copy was created.

However, both variables refer to the same set object.

---

Example of Assignment Problem

set1 = {
    1,
    2,
    3
}

set2 = set1

set2.add(4)

print(set1)
print(set2)

Output

{1, 2, 3, 4}
{1, 2, 3, 4}

Both sets changed because they point to the same object.

---

Proper Copy Example

set1 = {
    1,
    2,
    3
}

set2 = set1.copy()

set2.add(4)

print(set1)
print(set2)

Output

{1, 2, 3}
{1, 2, 3, 4}

Now the sets are independent.

---

Checking Memory Addresses

You can verify that copied sets are different objects.

set1 = {
    1,
    2,
    3
}

set2 = set1.copy()

print(id(set1))
print(id(set2))

Output

140503224108640
140503224108864

The memory addresses are different.

---

Copying an Empty Set

set1 = set()

set2 = set1.copy()

print(set2)

Output

set()

---

Copying Mixed Data Types

Sets can contain multiple data types.

data = {
    "Python",
    100,
    3.14,
    True
}

data_copy = data.copy()

print(data_copy)

Output

{'Python', 100, 3.14, True}

---

Real-World Example: User Roles

default_roles = {
    "read",
    "write"
}

new_user_roles = default_roles.copy()

new_user_roles.add("delete")

print(default_roles)
print(new_user_roles)

Output

{'read', 'write'}
{'read', 'write', 'delete'}

This allows role customization without modifying defaults.

---

Real-World Example: Backup Configuration

system_settings = {
    "dark_mode",
    "notifications",
    "auto_save"
}

backup_settings = system_settings.copy()

print(backup_settings)

Output

{
 'dark_mode',
 'notifications',
 'auto_save'
}

Creating backups is a common use case for copying sets.

---

Shallow Copy Behavior

The copy() method creates a shallow copy.

For normal sets containing immutable values such as strings, integers, and booleans, this works perfectly.

Example:

numbers = {
    1,
    2,
    3
}

numbers_copy = numbers.copy()

Since sets cannot directly contain mutable sets, shallow copy concerns are minimal when working with standard sets.

---

Common Mistakes

Mistake 1: Using Assignment Instead of Copy

Incorrect:

set2 = set1

Correct:

set2 = set1.copy()

---

Mistake 2: Assuming Original Will Stay Unchanged

set1 = {
    "apple",
    "banana"
}

set2 = set1

set2.remove("banana")

Result:

set1

Output:

{'apple'}

The original was modified.

---

Mistake 3: Forgetting Parentheses

Incorrect:

set2 = set1.copy

Correct:

set2 = set1.copy()

---

Performance Considerations

Copying sets is generally very fast.

large_set = set(range(10000))

copy_set = large_set.copy()

Python efficiently duplicates the elements into a new set object.

---

Best Practices

Use copy() for Readability

new_set = old_set.copy()

Use Copies Before Making Major Changes

backup = original.copy()

Avoid Assignment When Independent Data Is Needed

duplicate = original.copy()

Preserve Original Data

working_data = source.copy()

---

Quick Summary

Operation	Example
Copy a set	set2 = set1.copy()
Copy using constructor	set2 = set(set1)
Assignment	set2 = set1
Independent copy	Yes
Same object reference	No
Modifies original	No

---

copy() vs Assignment

Feature	copy()	Assignment (=)
Creates new object	Yes	No
Independent data	Yes	No
Safe to modify	Yes	No
Original unchanged	Yes	No

---

Conclusion

Copying sets is an essential skill when working with Python collections. The copy() method provides a simple and reliable way to create an independent duplicate of a set, allowing you to modify data without affecting the original collection.

Remember:

• Use copy() when you need a separate set.
• Avoid simple assignment if independent data is required.
• Use copied sets for backups, testing, filtering, and temporary processing.
• Preserve original data whenever possible.

Mastering set copying techniques will help you write safer, cleaner, and more professional Python programs.