Key Properties of Sets

• No duplicates: Each element appears only once in a set
• Unordered: Elements have no defined order
• Unindexed: Elements cannot be accessed by index
• Immutable elements: All elements must be hashable (immutable)
• Special boolean handling: False and 0 are treated as duplicates, as are True and 1

Creating a Set

Sets can be created using curly braces {} or the set() constructor:

1
# Using curly braces
2
numbers = {1, 2, 3, 4, 5}
3
empty_set = set()

When creating a set, duplicate values are automatically removed:

1
# Using set() constructor with an iterable
2
chars = set("hello")  # {'h', 'e', 'l', 'o'} (duplicates removed)
3
numbers = set([1, 2, 3, 1, 2, 3])  # {1, 2, 3}

False and 0 are treated as the same value, as are True and 1:

1
S = {"A", "B", "A", 1, False, True, 0}
2
print(S)  # {'A', 'B', False, True} or {'A', 'B', 0, 1}
3
# Note: The set contains either False or 0 (not both), and either True or 1 (not both)

Warning

An empty set must be created using set(), not {}. The empty curly braces {} create an empty dictionary, not a set.

Note

Since sets are unordered, the order of elements when printing may vary. The important thing is that all unique elements are present.

Checking Membership

Elements can be checked for existence in a set using the in and not in operators:

1
numbers = {1, 2, 3, 4, 5}
2

3
print(3 in numbers)  # True
4
print(10 in numbers)  # False
5
print(2 not in numbers)  # False

Looping Over a Set

Sets can be iterated over using a for loop:

1
S = {1, 2, 3, 4, 5}
2

3
for element in S:
4
    print(element)

Tip

Since sets are unordered, the iteration order is not guaranteed and may vary between runs.

Adding Elements to a Set

There are several ways to add elements to a set:

• add(element): Adds a single element to the set.
• update(iterable1, iterable2, ...): Adds all elements from one or more iterables to the set $X = X \cup S \cup T \cup \ldots$.
• intersection_update(iterable1, iterable2, ...): Keeps only elements that are common to the set and all given iterables $X = X \cap S \cap T \cap \ldots$.
• symmetric_difference_update(iterable): Keeps only elements that are in the set or in the iterable, but not in both $X = X \triangle S$.

1
numbers = {1, 2, 3}
2
numbers.add(4)
3
print(numbers)  # {1, 2, 3, 4}
4

5
numbers.add(2)  # Adding duplicate has no effect
6
print(numbers)  # {1, 2, 3, 4}
7

8
numbers = {1, 2, 3}
9
numbers.update([4, 5, 6], {7, 8})
10
print(numbers)  # {1, 2, 3, 4, 5, 6, 7, 8}
11

12
numbers = {1, 2, 3, 4, 5}
13
numbers.intersection_update({2, 3, 4}, {3, 4, 5})
14
print(numbers)  # {3, 4}
15

16
numbers = {1, 2, 3, 4}
17
numbers.symmetric_difference_update({3, 4, 5, 6})
18
print(numbers)  # {1, 2, 5, 6}

Removing Elements from a Set

There are several ways to remove elements from a set:

• remove(element): Removes the specified element from the set. If the element doesn’t exist, it raises a KeyError.
• discard(element): Removes the specified element from the set. If the element doesn’t exist, it does nothing (no error is raised).
• difference_update(iterable1, iterable2, ...): Removes all elements that are present in any of the given iterables $X = X - S - T - ...$.
• pop(): Removes and returns an arbitrary (random) element from the set. If the set is empty, it raises a KeyError.
• clear(): Removes all elements from the set.

1
numbers = {1, 2, 3, 4, 5}
2
numbers.remove(3)
3
print(numbers)  # {1, 2, 4, 5}
4

5
numbers.remove(10)  # KeyError: 10
6

7
numbers = {1, 2, 3, 4, 5}
8
numbers.discard(3)
9
print(numbers)  # {1, 2, 4, 5}
10

11
numbers.discard(10)  # No error, set remains unchanged
12
print(numbers)  # {1, 2, 4, 5}
13

14
numbers = {1, 2, 3, 4, 5}
15
numbers.difference_update({2, 3}, {4})
16
print(numbers)  # {1, 5}
17

18
numbers = {1, 2, 3, 4, 5}
19
element = numbers.pop()
20
print(element)  # Could be any element (e.g., 1, 2, 3, 4, or 5)
21
print(numbers)  # Remaining elements
22

23
empty = set()
24
empty.pop()  # KeyError: 'pop from an empty set'
25

26
numbers = {1, 2, 3, 4, 5}
27
numbers.clear()
28
print(numbers)  # set()

Set Operations and Methods

Sets support various mathematical set operations that return new sets:

• union(iterable1, iterable2, ...): Returns a new set containing all elements from the set and all given iterables $X \cup S \cup T \cup \ldots$.
• intersection(iterable1, iterable2, ...): Returns a new set containing only elements that are common to the set and all given iterables $X \cap S \cap T \cap \ldots$.
• difference(iterable1, iterable2, ...): Returns a new set containing elements that are in the set but not in any of the given iterables $X - S - T - ...$.
• symmetric_difference(iterable): Returns a new set containing elements that are in either the set or the iterable, but not in both $X \triangle S$.
• issubset(iterable): Returns True if all elements of the set are in the given iterable.
• issuperset(iterable): Returns True if all elements of the given iterable are in the set.
• isdisjoint(iterable): Returns True if the set and the given iterable have no elements in common (their intersection is empty).

1
set1 = {1, 2, 3}
2
set2 = {3, 4, 5}
3
result = set1.union(set2)
4
print(result)  # {1, 2, 3, 4, 5}
5

6
# Can also use the | operator
7
result = set1 | set2  # {1, 2, 3, 4, 5}

1
set1 = {1, 2, 3, 4}
2
set2 = {3, 4, 5, 6}
3
result = set1.intersection(set2)
4
print(result)  # {3, 4}
5

6
# Can also use the & operator
7
result = set1 & set2  # {3, 4}

1
set1 = {1, 2, 3, 4, 5}
2
set2 = {3, 4}
3
result = set1.difference(set2)
4
print(result)  # {1, 2, 5}
5

6
# Can also use the - operator
7
result = set1 - set2  # {1, 2, 5}

1
set1 = {1, 2, 3, 4}
2
set2 = {3, 4, 5, 6}
3
result = set1.symmetric_difference(set2)
4
print(result)  # {1, 2, 5, 6}
5

6
# Can also use the ^ operator
7
result = set1 ^ set2  # {1, 2, 5, 6}

1
set1 = {1, 2, 3}
2
set2 = {1, 2, 3, 4, 5}
3
print(set1.issubset(set2))  # True
4

5
# Can also use the <= operator
6
print(set1 <= set2)  # True

1
set1 = {1, 2, 3, 4, 5}
2
set2 = {1, 2, 3}
3
print(set1.issuperset(set2))  # True
4

5
# Can also use the >= operator
6
print(set1 >= set2)  # True

1
set1 = {1, 2, 3}
2
set2 = {4, 5, 6}
3
print(set1.isdisjoint(set2))  # True
4

5
set3 = {3, 4, 5}
6
print(set1.isdisjoint(set3))  # False (they share element 3)

Built-in Functions with Sets

Several built-in functions can be used with sets:

• len(set): Returns the number of elements in the set
• max(set): Returns the maximum element
• min(set): Returns the minimum element
• sum(set): Returns the sum of all elements (if they are numeric)
• all(set): Returns True if all elements are truthy
• any(set): Returns True if any element is truthy

1
numbers = {1, 2, 3, 4, 5}
2

3
print(len(numbers))  # 5
4
print(max(numbers))  # 5
5
print(min(numbers))  # 1
6
print(sum(numbers))  # 15
7
print(all(numbers))  # True
8
print(any(numbers))  # True

Exercises

1
text = input()
2
seen = set()
3
for char in text:
4
    if char not in seen:
5
        seen.add(char)
6
        print(char)

1
text = input()
2
seen_once = set()
3
seen_multiple = set()
4

5
for char in text:
6
    if char in seen_multiple:
7
        continue
8
    elif char in seen_once:
9
        seen_once.remove(char)
10
        seen_multiple.add(char)
11
    else:
12
        seen_once.add(char)
13

14
for char in text:
15
    if char in seen_once:
16
        print(char)
17
        seen_once.remove(char)

1
n1 = int(input())
2
set1 = set()
3
for i in range(n1):
4
    element = input()
5
    set1.add(element)
6

7
n2 = int(input())
8
set2 = set()
9
for i in range(n2):
10
    element = input()
11
    set2.add(element)
12

13
common = set1.intersection(set2)
14
print(common)

1
n1 = int(input())
2
set1 = set()
3
for i in range(n1):
4
    element = input()
5
    set1.add(element)
6

7
n2 = int(input())
8
set2 = set()
9
for i in range(n2):
10
    element = input()
11
    set2.add(element)
12

13
difference = set1.difference(set2)
14
print(difference)

1
n1 = int(input())
2
set1 = set()
3
for i in range(n1):
4
    element = input()
5
    set1.add(element)
6

7
n2 = int(input())
8
set2 = set()
9
for i in range(n2):
10
    element = input()
11
    set2.add(element)
12

13
union = set1.union(set2)
14
print(union)

1
n = int(input())
2
original = []
3
for i in range(n):
4
    original.append(input())
5

6
seen = set()
7
result = []
8
for item in original:
9
    if item not in seen:
10
        seen.add(item)
11
        result.append(item)
12

13
print(result)

1
n = int(input())
2
elements = []
3
for i in range(n):
4
    elements.append(input())
5

6
unique = set(elements)
7
print(len(unique))