Sets in Python

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 subscriptable

In 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
5

So, 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'})
True
print( 7 not in {1,3,5,7,9})
False

Set 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.

Pooja is a programmer by profession and love to write articles on Python. She is highly interested in Python, Data Science and Machine Learning. Pooja holds B.E. Computer Engineering degree. She loves teaching and learning new thing.

Leave a Comment