Union, Intersection and Difference

Python sets support four algebraic operations, and each has both an operator and a named method.

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)          # union - everything in either set
print(a & b)          # intersection - shared elements
print(a - b)          # difference - in a but not in b
print(a ^ b)          # symmetric difference - in one but not both

print(a.union(b))                 # same as a | b
print(a.intersection(b))          # same as a & b
print(a.difference(b))            # same as a - b
print(a.symmetric_difference(b))  # same as a ^ b

# In-place versions modify the left operand
a |= {9}
print(a)              # {1, 2, 3, 9}

The union combines both sets, the intersection keeps only what is in both, the difference keeps what is in the left set but not the right, and the symmetric difference keeps what is in exactly one of them. That last one is the one people misremember — a ^ b is the union of the two differences, not the same as a - b.

The operators exist as shorthand for the methods, and they are the form to use because they read like the maths. The named methods have one extra capability: they accept any iterable, so set.union([1, 2]) works, while {1, 2} | [1, 2] raises a TypeError because a list has no union operation. The in-place operators such as |= and &= modify the left-hand set rather than creating a new one.

One more operation worth knowing is the comparison ones. Sets support <=, <, >, >=, == and !=, and these are subset and superset tests rather than ordering. The strict subset test, a < b, is True only when a is a proper subset of b. This is the idiom for asking whether one group of tags is entirely contained in another.

There are four fundamental operations. The union combines two sets, the intersection keeps only the elements in both, the difference keeps the elements of the left set that are not in the right, and the symmetric difference keeps the elements that are in exactly one of them. Every one of them has an operator — |, &, - and ^ — and a named method — union, intersection, difference and symmetric_difference.

The operator and the method are not quite equivalent. The operators require both operands to be sets, so a set | a list raises a TypeError. The methods accept any iterable, so set.union([1, 2]) works and returns a set. When you are combining two known sets, the operators are cleaner and faster, because they avoid the conversion the method has to do.

Each operation also has an in-place variant: |=, &= and -=, and the difference of that for the symmetric difference, which is implemented with the method syntax a.symmetric_difference_update(b). The in-place versions modify the set on the left and return it, so they can be chained, and they avoid allocating a new set — which matters in a loop processing many sets.

The comparison operators complete the picture and are easy to overlook. Sets support the subset and superset tests: the strict subset test a < b, the non-strict version a <= b, and the matching superset forms. These are containment questions — is this group of permissions entirely inside that one — and they are far more readable than checking set sizes and doing a difference.

The last detail worth knowing is that set operations all build a new set, so the result is always a set even if the inputs came from lists.