Python Set Methods Cheat Sheet

# Empty dict, NOT a set!
empty_dict = {}
type(empty_dict)  # <class 'dict'>

# Correct way to create an empty set
empty_set = set()
type(empty_set)   # <class 'set'>

s = set()
print(s)  # set()

set([1, 2, 2, 3])       # {1, 2, 3}
set(("a", "b", "a"))        # {'a', 'b'}
set("hello")               # {'h', 'e', 'l', 'o'}
set(range(5))              # {0, 1, 2, 3, 4}

{x**2 for x in range(10)}
# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

{x for x in "abracadabra" if x not in "abc"}
# {'r', 'd'}

fs = frozenset([1, 2, 3])
print(fs)  # frozenset({1, 2, 3})

# frozenset is hashable
d = {fs: "immutable key"}

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

s.add(2)  # Already exists, no error
print(s)  # {1, 2, 3, 4}

s = {1, 2}
s.update([3, 4, 4])
print(s)  # {1, 2, 3, 4}

# Operator equivalent
s |= {5, 6}
print(s)  # {1, 2, 3, 4, 5, 6}

s = {1, 2, 3}
s.remove(2)
print(s)  # {1, 3}

s.remove(99)  # KeyError: 99

s = {1, 2, 3}
s.discard(2)
print(s)  # {1, 3}

s.discard(99)  # No error, set unchanged

s = {1, 2, 3}
elem = s.pop()
print(elem)  # arbitrary: 1, 2, or 3
print(s)     # remaining 2 elements

set().pop()  # KeyError: 'pop from an empty set'

a = {1, 2, 3}
b = {3, 4, 5}

a.union(b)   # {1, 2, 3, 4, 5}
a | b          # {1, 2, 3, 4, 5}
a.union(b, {6})  # {1, 2, 3, 4, 5, 6}

a = {1, 2, 3}
b = {2, 3, 4}

a.intersection(b)  # {2, 3}
a & b               # {2, 3}

a = {1, 2, 3}
b = {2, 3, 4}

a.difference(b)  # {1}
a - b             # {1}

# Note: not commutative
b - a  # {4}

a = {1, 2, 3}
b = {2, 3, 4}

a.symmetric_difference(b)  # {1, 4}
a ^ b                       # {1, 4}

a = {1, 2}
b = {3, 4}
c = {2, 5}

a.isdisjoint(b)  # True
a.isdisjoint(c)  # False

s = {1, 2, 3, 4}
s.intersection_update({3, 4, 5})
print(s)  # {3, 4}

# Operator equivalent
s &= {3, 5}
print(s)  # {3}

s = {1, 2, 3, 4}
s.difference_update({3, 4, 5})
print(s)  # {1, 2}

# Operator equivalent
s -= {1}
print(s)  # {2}

s = {1, 2, 3}
s.symmetric_difference_update({2, 3, 4})
print(s)  # {1, 4}

# Operator equivalent
s ^= {1, 5}
print(s)  # {4, 5}

s = {1, 2}
s |= {2, 3, 4}
print(s)  # {1, 2, 3, 4}

# Also works with any iterable
s |= [5, 6]
print(s)  # {1, 2, 3, 4, 5, 6}

s = {1, 2, 3, 3}
len(s)  # 3 (duplicates removed)

empty = set()
len(empty)  # 0

s = {"apple", "banana", "cherry"}

"apple" in s       # True
"grape" not in s  # True
42 in s          # False

{1, 2}.issubset({1, 2, 3})  # True
{1, 2} <= {1, 2, 3}             # True

# Every set is a subset of itself
{1, 2} <= {1, 2}  # True

{1, 2, 3}.issuperset({1, 2})  # True
{1, 2, 3} >= {1, 2}             # True

# Every set is a superset of itself
{1, 2} >= {1, 2}  # True

{1, 2, 3} > {1, 2}   # True (proper superset)
{1, 2} < {1, 2, 3}   # True (proper subset)

# Not proper if equal
{1, 2} > {1, 2}   # False
{1, 2} < {1, 2}   # False

s = {1, 2, 3}
c = s.copy()
c.add(4)

print(s)  # {1, 2, 3} — original unchanged
print(c)  # {1, 2, 3, 4}

s = {1, 2, 3}
s.clear()
print(s)  # set()
print(len(s))  # 0

import copy

s = {(1, 2), (3, 4)}
shallow = copy.copy(s)
deep = copy.deepcopy(s)

# For flat sets of immutable items, all three are equivalent

squares = {x**2 for x in range(10)}
print(squares)
# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

chars = {c.upper() for c in "hello"}
# {'H', 'E', 'L', 'O'}

items = [-2, -1, 0, 1, 2, 3]
positives = {x for x in items if x > 0}
print(positives)  # {1, 2, 3}

evens = {x for x in range(20) if x % 2 == 0}
# {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

matrix = [[1, 2], [3, 4], [2, 5]]
flat = {x for sublist in matrix for x in sublist}
print(flat)  # {1, 2, 3, 4, 5}

# Equivalent nested loop
result = set()
for sublist in matrix:
    for x in sublist:
        result.add(x)

fs = frozenset([1, 2, 3])

fs.union({3, 4})               # frozenset({1, 2, 3, 4})
fs.intersection({2, 3})        # frozenset({2, 3})
fs.issubset({1, 2, 3, 4})       # True
fs.isdisjoint({4, 5})           # True
len(fs)                          # 3
2 in fs                          # True

fs = frozenset([1, 2])

# All of these raise AttributeError:
# fs.add(3)
# fs.remove(1)
# fs.update({3})
# fs.pop()
# fs.clear()
# fs |= {3}
# fs &= {1}
# fs -= {1}
# fs ^= {1}

# A set of sets is impossible with mutable sets
# But works with frozenset:

set_of_sets = {
    frozenset([1, 2]),
    frozenset([2, 3]),
}

# As dictionary keys
cache = {
    frozenset(["a", "b"]): 42
}

items = [1, 2, 2, 3, 3, 3]
unique = list(set(items))
print(unique)  # [1, 2, 3] (order may vary)

items = [3, 1, 2, 1, 3, 2]
ordered = list(dict.fromkeys(items))
print(ordered)  # [3, 1, 2]

a = [1, 2, 3, 4]
b = [3, 4, 5, 6]

# In a but not in b
list(set(a) - set(b))  # [1, 2]

# In b but not in a
list(set(b) - set(a))  # [5, 6]

words = ["apple", "banana", "apple", "cherry", "banana"]
count = len(set(words))
print(count)  # 3

# Unique characters in a string
len(set("abracadabra"))  # 5

items = [1, 2, 1, 3, 2, 4, 1]
seen = set()
result = []

for x in items:
    if x not in seen:
        seen.add(x)
        result.append(x)

print(result)  # [1, 2, 3, 4]