In this tutorial, I am going to discuss about Set datatype in python, different operations which can be performed on sets and built-in functions available in python for sets.
Sets in Python
Set in python is an unordered collection of elements. It is similar to lists in python but unlike lists every set element must be unique and immutable object. Although set itself is a mutable object i.e. we can add or remove any element from a set.
Creating a Set
A set is a collection of immutable python objects separated by commas and enclosed within curly braces { }. Set datatype in python is same as sets we use in mathematics, we can also perform set operations like union, intersection etc. on python sets.
Following is an example of a set in python :
set1 = { 'a', 1, 'b', 2 }
| Expression | Description |
|---|---|
| S1 = set() | Empty set |
| S2 = {0, 1, 2, 3} or {'a','b','c','d'} | Simple declaration of a set with 4 values |
| S3 = set('Learn Python Coding') | set of an iterable item |
| S4 = set(range(3,7)) | Set of successive integers from -5 to 6 |
The first declaration is an empty set. As set and dictionary both use curly braces in python so if we use empty curly braces python takes it as an empty dictionary instead of an empty set.
So instead of empty curly braces empty set() constructor is used to declare an empty set.
The second declaration is a simple set declaration with all elements of same datatypes.
The third and fourth declaration shows how to create a set using an iterable python object. Since a set cannot contain a mutable object, it is not possible to create a nested set i.e. set within a set.
Let's see some examples on creating a sets.
set1 = {1,2,3,4,5}
print("Simple set : ", set1)
set2 = set("Coding is Fun")
print("Set using an iterable : ",set2)
set3 = set(range(1,8))
print("Set from range() function ", set3)Simple set : {1, 2, 3, 4, 5}
Set using an iterable : {'d', 'F', 'g', 'u', 'n', 'i', 'o', 'C', ' ', 's'}
Set from range() function {1, 2, 3, 4, 5, 6, 7}setl = {1,2,[3,4]}
print(setl)---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
< ipython-input-40-8bb123d918ff > in < module >
----> 1 setl = {1,2,[3,4]}
2 print(setl)
TypeError: unhashable type: 'list'As we can see in the above example, if we try to add a mutable object (list, dictionary or set) as an element to a set then python throws a TypeError.
Accessing a Set in Python
A set in python is an unordered collection which means we cannot know the order of elements of a set. That is why set is also unindexed which means we cannot use indexing operator to access individual element from a set. Hence we have to access a complete set at a time.
Let's see how to access a set in python :
a = {1,3,2}
b = {5,9,2,2,5,1,0}
print("Accessing set 'a' : ", a)
print("Accessing set 'b' : ", b)
print(b[3])Accessing set 'a' : {1, 2, 3}
Accessing set 'b' : {0, 1, 2, 5, 9}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
< ipython-input-39-e6813b12f5b6 > in < module >
3 print("Accessing set 'a' : ", a)
4 print("Accessing set 'b' : ", b)
----> 5 print(b[3])
TypeError: 'set' object is not subscriptableIn the above example,set reorders the elements in ascending order, also in the set b the duplicate elements are removed and then reordered in ascending order.
If we try to access an individual element from a set using indexing then we will face TypeError.
Traversing through a Set
We know that traversing means accessing and processing each element of the sequence which can be done by using loops in python.
Even though we cannot access individual elements of set using indexing we can still use loops to traverse through a list if we want to access and process each element of a set.
For Example the below shown example prints each element of a set in python.
set1 = {1,2,3,4,5}
for val in set1 :
print(val)1
2
3
4
5So, we can access and process each element of a set using loops.
Python Set Operations
Just like mathematical sets we can also perform set operations like union, intersection, difference and other. We can use operators or methods to perform these operations on sets. Let's see operations that can be performed on sets in python.
Set Union
Union is a set operation in which all elements of two sets are combined to from a new set.
If both sets have some common elements then the new set will contain only one instance of the element
A union is performed using | operator and we can also perform this using union() method.
Let's see some examples :
A = {'a','b','c','d','e'}
B = {'d','e','f','g','h'}
print("set A = ",A)
print("set B = ",B)
print("Using | operator - ",A | B)
print("Using union() method - ", A.union(B))set A = {'e', 'b', 'a', 'd', 'c'}
set B = {'f', 'h', 'e', 'd', 'g'}
Using | operator - {'e', 'b', 'f', 'h', 'd', 'a', 'g', 'c'}
Using union() method - {'e', 'b', 'f', 'h', 'd', 'a', 'g', 'c'}Set Intersection
Intersection is a set operation in which all the common elements from two sets are combined to create a new set.
Intersection is performed using & operator and we can also perform this using intersection() method.
Let's see some examples of set intersection in python :
print("set A = ",A)
print("set B = ",B)
print("Using & operator - ",A & B)
print("Using intersection() method - ", A.intersection(B))
set A = {'e', 'b', 'a', 'd', 'c'}
set B = {'f', 'h', 'e', 'd', 'g'}
Using & operator - {'d', 'e'}
Using intersection() method - {'d', 'e'}Set Difference
Set difference is set operation in which the elements from the first set which are not present in second set form the new set.
Difference from set B from set A (A - B) has all the elements of set A which are not present in set B. Set Difference is performed using - operator and it can also be performed using difference() method.
Let's see some examples of set difference in python:
print("set A = ",A)
print("set B = ",B)
print("Using - operator : A - B = ",A - B)
print("Using difference() method : A - B = ", A.difference(B))
print("Using - operator : B - A = ",B - A)set A = {'e', 'b', 'a', 'd', 'c'}
set B = {'f', 'h', 'e', 'd', 'g'}
Using - operator : A - B = {'b', 'c', 'a'}
Using difference() method : A - B = {'b', 'c', 'a'}
Using - operator : B - A = {'h', 'g', 'f'}Set Symmetric Difference
Set symmetric difference is set operation in which the elements which are in first set but not in second set and are in second set but not in first set are combined to form a new set.
Symmetric difference between two sets A and B means elements of set A which are not in set B and elements of set B which are not in set A.
Set symmetric difference can be performed using ^ operator and it can also bee performed using symmetric_difference() method.
print("set A = ",A)
print("set B = ",B)
print("Using ^ operator : A ^ B = ",A ^ B)
print("Using symmetric_difference() method : A ^ B = ", A.symmetric_difference(B))
print("Using ^ operator : B ^ A = ",B ^ A)set A = {'e', 'b', 'a', 'd', 'c'}
set B = {'f', 'h', 'e', 'd', 'g'}
Using ^ operator : A ^ B = {'g', 'b', 'f', 'h', 'c', 'a'}
Using symmetric_difference() method : A ^ B = {'g', 'b', 'f', 'h', 'c', 'a'}
Using ^ operator : B ^ A = {'g', 'f', 'b', 'c', 'a', 'h'}Membership Operation
Just like strings, lists, tuples and dictionaries support membership operators in and not in the sets also support membership operators.
These operators are used to check if given element is present in the set.
Let's see use of these operators with set in python.
print( 'a' in {'a','b','c'})Trueprint( 7 not in {1,3,5,7,9})FalseSet Methods in Python
Python also provides methods for set manipulation and set operations. These built-in methods help us process and manipulate sets more easily.
Following is a list of methods provided in python for set manipulation along with small description about each of them.
| Method() | Description |
|---|---|
add() |
Add an element to the end of set |
clear() |
Removes all items from the set |
copy() |
Returns a true copy of the set |
difference() |
Returns the difference of two or more sets as a new set |
difference_update() |
Removes all elements of a set from the given set |
discard() |
Removes an element from a set if it is a member of the set |
intersection() |
Returns the intersection of two sets as a new set |
intersection_update() |
Updates a set with intersection between the set and another set |
isdisjoint() |
Returns true if two sets have no common elements |
issubset() |
Returns true if another set contains all elements of a set |
issuperset() |
Returns true if a set contains all the elements of another set |
pop() |
Returns and removes an arbitrary element from a set |
remove() |
Removes an element given as argument from the set |
symmetric_difference() |
Returns symmetric difference between two sets as a new set |
symmetric_difference_update() |
Updates a set with symmetric difference between the set and another set |
union() |
Returns union of two sets as a new set |
update() |
Updates a set with union of the set and set given as argument |
Some examples of Python set methods :
set_ex = { 1,2,3,4,5 }
set_ex.add(6)
print("add() method : ",set_ex)
print("issuperset() method : set_ex.issuperset({1,2}) = ",set_ex.issuperset({1,2}))
print("isdisjoint() method : set_ex.isdisjoint({9,8}) = ",set_ex.isdisjoint({9,8}))
print("pop() method : ",set_ex.pop(),", set = ",set_ex)add() method : {1, 2, 3, 4, 5, 6}
issuperset() method : set_ex.issuperset({1,2}) = True
isdisjoint() method : set_ex.isdisjoint({9,8}) = True
pop() method : 1 , set = {2, 3, 4, 5, 6}We will learn about these functions as we learn in further articles with more examples.
Set Manipulation
So till now, we have seen creating and accessing set, operations on sets and built-in methods for set in python.
Before we go ahead, you should note that sets in python are mutable objects which means that we can add elements to a set and remove elements from a set.
Now, we will discuss other set manipulations which are append elements to a set and delete operation on a set.
Let's learn about set manipulation in python.
Appending Elements to a Set
There are two built-in methods provided by python add() and update().
The add() method takes an immutable python object as argument and appends it to the set.
The update() method takes an iterable python object as argument and appends all the elements of the iterable to the set.
Let's see some examples :
set_ex1 = {1,2}
print("Original set : ", set_ex1)
set_ex1.update({3,4})
print("Using update() method : ",set_ex1)
set_ex1.add(9)
set_ex1.add('a')
print("Using add() method : ",set_ex1)Original set : {1, 2}
Using update() method : {1, 2, 3, 4}
Using add() method : {1, 2, 3, 4, 9, 'a'}Deleting Elements from a Set
As sets are mutable, we are able to delete elements from a set or we can also delete a set completely.
This can be done using built-in set methods pop(), discard() and remove().
The discard() and remove() methods are pretty much the same, they both take an immutable python object which might be a set element as argument and then updates the set by removing that element.
The main difference between discard() and remove() is that discard() method does not give any error if the argument is not present in the set and remove() method throws KeyError.
The pop() method does not take any argument, it removes and returns an element of the set from starting of the set and raises KeyError if the set is empty.
set_ex2 = {1,2,3,4}
print("Original set", set_ex2)
set_ex2.remove(1)
print("Set after remove() : ",set_ex2)
set_ex2.discard(2)
print("Set after discard() : ", set_ex2)
print("pop() method :",set_ex2.pop())
print("Set after pop() : ",set_ex2)Original set {1, 2, 3, 4}
Set after remove() : {2, 3, 4}
Set after discard() : {3, 4}
pop() method : 3
Set after pop() : {4}Frozen Set
We know that in python everything is an object, and thus each object has its class. Just like set objects, python also have frozenset objects from frozenset class.
In simple words, frozen set is an immutable set, just like a tuple is an immutable list. We can perform various set operations on frozenset except appending elements and deleting elements. Frozensets can be created using frozenset() method.
As we discussed frozenset objects support operations like union(), intersection(), difference(), copy(), isdisjoint(), issuperset(), issubset() and symmetric_difference(). Slice these are immutable sets they do not support methods like add or remove which update the set itself.
Let's see some examples involving frozensets in python :
A = frozenset(['a','b','c',1,2,3])
B = frozenset(['c','d','e',3,4,5])
print("Set A = ",A)
print("Set B = ",B)
print("A - B = ",A.difference(B))
print("A union B = ",A.union(B))Set A = frozenset({1, 2, 'c', 3, 'a', 'b'})
Set B = frozenset({3, 4, 'c', 'e', 5, 'd'})
A - B = frozenset({1, 2, 'b', 'a'})
A union B = frozenset({1, 2, 'c', 3, 4, 'e', 5, 'd', 'a', 'b'})Conclusion
In this tutorial, we have discussed about set datatypes in python, accessing and traversing set, different operations on sets and methods for sets provided by python.
If you have any questions please comment below also share your views and suggestions in the comment box.
