Introduction
The symmetric difference of sets is an operation that extracts all elements that appear in only one set. If we have two sets A and B, their symmetric difference will include all elements in A that are not in B, together with all elements in B that are not in A. Symmetric difference of Python sets, can be achieved using the symmetric_difference() instance method, the symmetric_difference() class method, and the symmetric difference operator, ^, i.e. the caret character. Each of those options provides a slightly different capability and convenience. They work in a similar way to the options provided for the set union, intersection, and difference, and familiarity with those makes learning about symmetric difference rather easy.
Using the symmetric_difference() Instance Method
The symmetric_difference() instance method of a set object is used to extract elements that are unique to the set and one other iterable, excluding common elements. This creates a new set containing those values that are present in only one of the objects.
Note that unlike other set operation methods such as union(), symmetric_difference() will only accept one other argument to perform its operation and no more.
The example below creates the symmetric difference of a set object and a list.
Example:
my_set = {1, 2, 3}
my_list = [1, 4, 5]
symmetric_difference_set = my_set.symmetric_difference(my_list)
print(symmetric_difference_set)Output:
{2, 3, 4, 5}In this example, the symmetric_difference() method is used to find elements unique to either my_set or my_list. Since the element 1 is common, it is excluded. The rest of the elements appear in either my_set or my_list, but not both, resulting in the set {2, 3, 4, 5}.
Using the Symmetric Difference Operator ^
The symmetric difference operator, ^, is an alternative way to creating a symmetric difference. Unlike the symmetric_difference() method, it can only be used with proper set objects and not any other iterable type. Using ^ with iterable objects that are not sets results in an error. Also unlike the symmetric_difference() method, the ^ operator can be used with two or more sets to extract all elements that are in only one of those sets.
Example:
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set3 = {2, 4, 6}
symmetric_difference_set = set1 ^ set2 ^ set3
print(symmetric_difference_set)Output:
{3, 5, 6}In this example, the symmetric difference of set1, set2 and set3 is generated using the ^ operator. The elements 1, 2, and 4 appear in more than one set. This leaves the symmetric difference to be {3, 5, 6}, a set that contains the elements that are in only one.
Using the symmetric_difference() Class Method
Similar to the symmetric_difference() instance method, the symmetric_difference() class method allows you to find the symmetric difference between a set and one other iterable object.
It is a class method of the set class, and you call it with a set. prefix.
The difference between the symmetric_difference() instance method and symmetric_difference() class method is that the instance method is called on a specific set, whereas the class method includes the set as its first parameter. Following the first argument, which must be a set, the second argument can be an object of any iterable type.
Example:
my_set = {1, 2, 3}
my_lst = [1, 4, 5]
symmetric_difference_set = set.symmetric_difference(my_set, my_lst)
print(symmetric_difference_set)Output:
{2, 3, 4, 5}The above example finds the symmetric difference of the set, my_set, and the list, my_list using the symmetric_difference() class method.
Symmetric Difference with Mutable Sets
Similar to other set operations, symmetric difference operations do not modify the original sets. Instead, they create a new set containing the symmetric difference. If you want to modify one of the original sets to contain the symmetric difference, you should do it explicitly by assigning the result back to it.
Example:
my_set = {1, 2, 3}
another_set = {3, 4, 5}
my_set = my_set.symmetric_difference(another_set)
print(my_set)Output:
{1, 2, 4, 5}After this operation, the original set, my_set, contains the resulting symmetric difference, {1, 2, 4, 5}.
Summary & Reference for Reference to Symmetric Difference of Python Sets
Set symmetric difference is a fundamental set operation in Python for extracting elements that are in only one of the sets.
The symmetric_difference() instance method extracts elements unique to a set object and one other iterable, creating a new set.
my_set = {1, 2, 3}
my_lst = [1, 4, 5]
symmetric_difference_set = set.symmetric_difference(my_set, my_lst)
# symmetric_difference_set --> {2, 3, 4, 5}The symmetric difference operator, ^, allows you to find elements unique to only one set among two or more proper sets. It creates a new set containing only those unique values.
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set3 = {2, 4, 6}
symmetric_difference_set = set1 ^ set2 ^ set3
# symmetric_difference_set --> {3, 5, 6}The symmetric_difference() class method of the set class lets you find the symmetric difference between a set object, given as the first argument, and another iterable object, given as the second argument.
my_set = {1, 2, 3}
my_lst = [1, 4, 5]
symmetric_difference_set = set.symmetric_difference(my_set, my_lst)
# symmetric_difference_set --> {2, 3, 4, 5}Set symmetric difference operations don’t modify the original sets but create new sets. If you want to modify one of the original set variables with the symmetric difference result, you should assign the result back explicitly.
my_set = {1, 2, 3}
another_set = {3, 4, 5}
my_set = my_set.symmetric_difference(another_set)
# symmetric_difference_set --> {1, 2, 4, 5}