Sets in Python

Try it on GfG Practice

A Set in Python is used to store a collection of items with the following properties.

• No duplicate elements. If try to insert the same item again, it overwrites previous one.
• An unordered collection. When we access all items, they are accessed without any specific order and we cannot access items using indexes as we do in lists.
• Internally use hashing that makes set efficient for search, insert and delete operations. It gives a major advantage over a list for problems with these operations.
• Mutable, meaning we can add or remove elements after their creation, the individual elements within the set cannot be changed directly.

Example of Python Sets

s = {10, 50, 20}
print(s)
print(type(s))

{10, 50, 20}
<class 'set'>

Note: There is no specific order for set elements to be printed

Type Casting with Python Set method

The Python set() method is used for type casting.

# typecasting list to set
s = set(["a", "b", "c"])
print(s)

# Adding element to the set
s.add("d")
print(s)

{'c', 'b', 'a'}
{'d', 'c', 'b', 'a'}

Check unique and  Immutable with Python Set

Python sets cannot have duplicate values. While you cannot modify the individual elements directly, you can still add or remove elements from the set.

# a set cannot have duplicate values
s = {"Geeks", "for", "Geeks"}
print(s)

# values of a set cannot be changed
s[1] = "Hello"
print(s)

Output

{'Geeks', 'for'}
TypeError: 'set' object does not support item assignment

Explanation:

• The first code explains that the set cannot have a duplicate value. Every item in it is a unique value. 
• The second code generates an error because we cannot assign or change a value once the set is created. We can only add or delete items in the set.

Heterogeneous Element with Python Set

Python sets can store heterogeneous elements in it, i.e., a set can store a mixture of string, integer, boolean, etc datatypes.

s = {"Geeks", "for", 10, 52.7, True}
print(s)

{True, 52.7, 'Geeks', 10, 'for'}

Python Frozen Sets

Frozen sets in Python are immutable objects that only support methods and operators that produce a result without affecting the frozen set or sets to which they are applied. It can be done with frozenset() method in Python.

While elements of a set can be modified at any time, elements of the frozen set remain the same after creation. If no parameters are passed, it returns an empty frozenset.

# Same as {"a", "b","c"}
s = set(["a", "b","c"])

print("Normal Set")
print(s)

# A frozen set
fs = frozenset(["e", "f", "g"])

print("\nFrozen Set")
print(fs)

# Uncommenting below line would cause error as
# we are trying to add element to a frozen set
# fs.add("h")

Normal Set
set(['a', 'c', 'b'])

Frozen Set
frozenset(['e', 'g', 'f'])

Internal working of Set

This is based on a data structure known as a hash table.  If Multiple values are present at the same index position, then the value is appended to that index position, to form a Linked List.

In, Python Sets are implemented using a dictionary with dummy variables, where key beings the members set with greater optimizations to the time complexity.

The diagram shows how Python internally manages collisions in sets using linked lists for efficient element storage and retrieval.

• Each index in the hash table represents a possible hash value where elements are stored based on their computed hash key.
• When two elements map to the same index, they are linked together using a linked list, forming a chain at that position.
• This chaining mechanism helps efficiently handle collisions, allowing multiple elements to exist at the same hash index without overwriting each other.

Sets with Numerous operations on a single HashTable:

The hash table stores elements based on their computed index values for example, values 20 and 30 are placed at index 5, while 40 goes to index 6, and 50 to index 8. When multiple values share the same index, they are linked together, forming a chain (as seen at index 5).

During traversal, insertion, or deletion, the algorithm moves through these linked elements at each index to access or modify data efficiently.

Methods for Sets

1. Adding elements to Sets

Insertion in the set is done through the set.add() function, where an appropriate record value is created to store in the hash table. Same as checking for an item, i.e., O(1) on average. However, in worst case it can become O(n).

# Creating a Set
people = {"Jay", "Idrish", "Archi"}

print("People:", end = " ")
print(people)

# This will add Daxit in the set
people.add("Daxit")

# Adding elements to the set using iterator
for i in range(1, 6):
    people.add(i)

print("\nSet after adding element:", end = " ")
print(people)

People: {'Jay', 'Idrish', 'Archi'}

Set after adding element: {1, 2, 3, 'Daxit', 'Jay', 'Idrish', 4, 5, 'Archi'}

2. Union operation on Python Sets

Two sets can be merged using union() function or | operator. Both Hash Table values are accessed and traversed with merge operation perform on them to combine the elements, at the same time duplicates are removed. The Time Complexity of this is O(len(s1) + len(s2)) where s1 and s2 are two sets whose union needs to be done.

people = {"Jay", "Idrish", "Archil"}
vampires = {"Karan", "Arjun"}
dracula = {"Deepanshu", "Raju"}

# Union using union() function
population = people.union(vampires)

print("Union using union() function")
print(population)

# Union using "|" operator
population = people|dracula
print("\nUnion using '|' operator")
print(population)

Union using union() function
{'Archil', 'Jay', 'Karan', 'Idrish', 'Arjun'}

Union using '|' operator
{'Archil', 'Deepanshu', 'Raju', 'Jay', 'Idrish'}

3. Intersection operation on Python Sets

This can be done through intersection() or & operator. Common Elements are selected. They are similar to iteration over the Hash lists and combining the same values on both the Table. Time Complexity of this is O(min(len(s1), len(s2)) where s1 and s2 are two sets whose union needs to be done.

set1 = set()
set2 = set()

for i in range(5):
    set1.add(i)

for i in range(3,9):
    set2.add(i)

# Intersection using intersection() function
set3 = set1.intersection(set2)

print("Intersection using intersection() function")
print(set3)

# Intersection using "&" operator
set3 = set1 & set2
print("\nIntersection using '&' operator")
print(set3)

Intersection using intersection() function
{3, 4}

Intersection using '&' operator
{3, 4}

4. Finding Differences of Sets in Python

To find differences between sets. Similar to finding differences in the linked list. This is done through difference() or – operator. Time complexity of finding difference s1 – s2 is O(len(s1))

set1 = set()
set2 = set()

for i in range(5):
    set1.add(i)

for i in range(3,9):
    set2.add(i)

# Difference of two sets using difference() function
set3 = set1.difference(set2)
print(" Difference of two sets using difference() function")
print(set3)

# Difference of two sets using '-' operator
set3 = set1 - set2
print("\nDifference of two sets using '-' operator")
print(set3)

 Difference of two sets using difference() function
{0, 1, 2}

Difference of two sets using '-' operator
{0, 1, 2}

5. Clearing Python Sets

Set Clear() method empties the whole set inplace.

set1 = {1,2,3,4,5,6}
print("Initial set")
print(set1)

# This method will remove all the elements of the set
set1.clear()
print("\nSet after using clear() function")
print(set1)

Initial set
{1, 2, 3, 4, 5, 6}

Set after using clear() function
set()

However, there are two major pitfalls in Python sets: 

1. The set doesn’t maintain elements in any particular order.
2. Only instances of immutable types can be added to a Python set.

Operators for Sets

Sets and frozen sets support the following operators:

Problems based on Set

• Python Set Exercise
• Distinct Elements in an Array
• Union of Two Arrays
• Intersection of Two Arrays
• Distinct Elements in an Array
• Union of Two Arrays
• Intersection of Two Arrays
• Repeating Elements
• Check if an Array is Subset of other
• Check Pair with Target Sum
• Check for Disjoint Arrays or Sets
• Duplicate within K Distance
• Longest Consecutive Sequence
• Check for Disjoint Arrays or Sets
• Duplicate within K Distance in an Array
• 2 Sum - Check for Pair with target sum
• Longest Consecutive Sequence
• Only Repeating Element From 1 To n-1

Set in Python

Visit Course