Python Set copy() Method

The copy() method returns a shallow copy of a set. The new set is a separate object, so adding or removing elements from one set does not affect the other. However, the elements themselves are shared by reference (relevant only for sets containing mutable objects nested inside tuples).

Syntax

set.copy()

Parameters

The copy() method takes no parameters.

Return Value

A new set containing the same elements as the original.

---

Example 1: Basic Copy

original = {1, 2, 3}
copied = original.copy()

original.add(4)
print(original)  # {1, 2, 3, 4}
print(copied)    # {1, 2, 3}

Adding to the original does not affect the copy — they are independent objects.

---

Example 2: copy() vs Assignment

# Assignment — both names point to the SAME set
a = {1, 2, 3}
b = a
b.add(4)
print(a)  # {1, 2, 3, 4} — original changed!

# copy() — independent set
c = {1, 2, 3}
d = c.copy()
d.add(4)
print(c)  # {1, 2, 3} — original safe

---

Example 3: Copying a Set of Tuples

numbers = {(1, 2), (3, 4)}
numbers_copy = numbers.copy()
print(numbers_copy)  # {(1, 2), (3, 4)}

---

Example 4: Shallow Copy Behaviour

A shallow copy shares references to nested mutable objects:

nested = {1, 2, (3, [4, 5])}
nested_copy = nested.copy()

# Modify the nested list (reached through one of the sets)
for item in nested:
    if isinstance(item, tuple):
        item[1][0] = 6

print(nested)       # {1, 2, (3, [6, 5])}
print(nested_copy)  # {1, 2, (3, [6, 5])} — also changed

For full independence of nested objects, use copy.deepcopy().

---

Example 5: Empty Set Copy

empty = set()
empty_copy = empty.copy()
print(empty_copy)  # set()

---

copy() vs set() Constructor

Both create a shallow copy:

a = {1, 2, 3}
b = a.copy()
c = set(a)
print(b == c)  # True

copy() is slightly more readable when copying an existing set.

---

Real-World Use Cases

1. Preserving the original while filtering:

all_tags = {"python", "tutorial", "beginner"}
working = all_tags.copy()
working.discard("beginner")
print(all_tags)  # original intact
print(working)   # filtered copy

2. Snapshotting state before modification:

current_state = {"feature_a", "feature_b"}
backup = current_state.copy()
current_state.add("feature_c")
# backup still has the original two features

3. Creating per-user permission sets from a template:

default_perms = {"read", "write"}
user_perms = default_perms.copy()
user_perms.add("admin")

---

Common Mistakes

• Using = instead of copy() — assignment creates an alias, not a copy.
• Expecting deep copy — nested mutable objects are shared. Use copy.deepcopy() for full independence.

---

FAQ

Q: What is a shallow copy? A new set object whose elements are the same references as the original. The set is independent, but nested mutable objects are shared.

Q: When should I use deepcopy? When the set contains nested mutable objects (inside tuples) and you need them fully independent.

Q: Is s.copy() the same as set(s)? Yes — both produce a shallow copy. copy() is more explicit.

---

Performance and Time Complexity

copy() creates a shallow copy in O(n) time, iterating once over the original set’s elements. It is faster than copy.deepcopy() because it does not recurse into nested objects. For the vast majority of sets — which contain immutable elements like numbers, strings, and tuples — a shallow copy is fully independent and exactly what you want.

Related Methods

• set(existing_set) — the constructor form, which also produces a shallow copy.
• copy.deepcopy() — needed only when elements contain nested mutable objects.
• update() — to copy elements into an existing set rather than a new one.

Best Practices

1. Use copy() before destructive operations so the original survives.
2. Remember that = creates an alias, not a copy.
3. Reach for deepcopy() only when a tuple element wraps a mutable object.

Key Takeaways

copy() returns an independent shallow copy of a set, lets you modify one without affecting the other, and is the idiomatic, efficient way to snapshot a set’s contents before mutating it.

A Mental Model for copy()

Picture taking a photograph of your set: the photo is a separate object you can scribble on without altering the original scene. That is what copy() provides — an independent snapshot you can mutate freely while the source remains pristine. This safety net is essential whenever you pass a set into code you do not fully control, or when you want to experiment with destructive operations and still be able to fall back to the original contents.

Conclusion

The copy() method is a small but powerful part of Python’s set toolkit. In short, it produces an independent shallow snapshot you can mutate without touching the original. Sets are one of Python’s most underrated data structures: they offer average constant-time membership tests, automatic de-duplication, and a rich family of mathematical operations that map directly onto everyday programming problems such as filtering, matching, grouping, and change detection. Mastering methods like copy() lets you replace verbose loops and manual bookkeeping with a single, expressive call that communicates intent clearly to anyone reading your code. Whenever you are juggling collections of unique items and find yourself writing nested conditionals to compare them, pause and ask whether a set operation would express the same logic more concisely. More often than not, the answer is yes — and copy() may be exactly the tool you need.