Python Sets — Language Specification¶

object.__contains__(self, item) -> bool   # x in s; O(1) average
object.__iter__(self)           -> iterator  # for x in s
object.__len__(self)            -> int    # len(s)

# These accept ANY iterable for methods, but operators require set/frozenset:
object.__or__(self, other)     -> set   # s | other
object.__and__(self, other)    -> set   # s & other
object.__sub__(self, other)    -> set   # s - other
object.__xor__(self, other)    -> set   # s ^ other
object.__ior__(self, other)    -> self  # s |= other  (in-place union, set only)
object.__iand__(self, other)   -> self  # s &= other  (in-place intersection)
object.__isub__(self, other)   -> self  # s -= other  (in-place difference)
object.__ixor__(self, other)   -> self  # s ^= other  (in-place sym diff)
# Reflected operators:
object.__ror__, __rand__, __rsub__, __rxor__

object.__eq__(self, other)     -> bool  # s1 == s2  (same elements)
object.__ne__(self, other)     -> bool  # s1 != s2
object.__le__(self, other)     -> bool  # s1 <= s2  (subset)
object.__lt__(self, other)     -> bool  # s1 < s2   (proper subset)
object.__ge__(self, other)     -> bool  # s1 >= s2  (superset)
object.__gt__(self, other)     -> bool  # s1 > s2   (proper superset)

frozenset.__hash__(self) -> int
# set.__hash__ is explicitly set to None (unhashable).

x = {}
print(type(x))    # <class 'dict'>  — NOT a set!

y = set()
print(type(y))    # <class 'set'>

try:
    s = {[1, 2], 3}   # list is unhashable
except TypeError as e:
    print(e)   # unhashable type: 'list'

try:
    s = {1, 2}
    s.add([3, 4])
except TypeError as e:
    print(e)   # unhashable type: 'list'

s = {1, 2, 3}
s.remove(2)    # OK
try:
    s.remove(99)   # raises KeyError
except KeyError:
    print("not found")

s.discard(99)  # no exception — silent no-op
print(s)       # {1, 3}

s = {1, 2, 3}
# Operator requires set:
try:
    result = s | [4, 5]   # TypeError!
except TypeError as e:
    print(e)

# Method accepts iterable:
result = s.union([4, 5])
print(result)   # {1, 2, 3, 4, 5}

fs = frozenset([1, 2, 3])
d = {fs: "value"}
print(d[frozenset([1, 2, 3])])   # "value"

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

# Set comprehension:
s = {x**2 for x in range(5)}
print(type(s))   # <class 'set'>
print(s)         # {0, 1, 4, 9, 16}

# Dict comprehension:
d = {x: x**2 for x in range(5)}
print(type(d))   # <class 'dict'>

# True == 1 and False == 0 with same hash values
s = {True, 1, False, 0}
print(s)    # {False, True}  — deduplicated since True==1 and False==0
print(len(s))  # 2

# This can be surprising:
s = {1, True}
print(len(s))   # 1  — only one element!

# ----------------------------------------------------------------
# 1. Set creation
# ----------------------------------------------------------------
s1 = {1, 2, 3, 4, 5}
s2 = set([3, 4, 5, 6, 7])
s3 = set("hello")              # {'h', 'e', 'l', 'o'}  — deduplicated
empty = set()
frozen = frozenset([1, 2, 3])

print(type({}))    # <class 'dict'>  — NOT a set!
print(type(set()))  # <class 'set'>
print(s3)           # {'h', 'e', 'l', 'o'} (or any order)


# ----------------------------------------------------------------
# 2. Membership test O(1) vs list O(n)
# ----------------------------------------------------------------
large_set  = set(range(1_000_000))
large_list = list(range(1_000_000))

print(999_999 in large_set)    # True  — O(1) hash lookup
print(999_999 in large_list)   # True  — O(n) linear scan


# ----------------------------------------------------------------
# 3. Set operations
# ----------------------------------------------------------------
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

print(a | b)   # union:               {1, 2, 3, 4, 5, 6, 7}
print(a & b)   # intersection:        {3, 4, 5}
print(a - b)   # difference (a-b):    {1, 2}
print(b - a)   # difference (b-a):    {6, 7}
print(a ^ b)   # symmetric difference:{1, 2, 6, 7}


# ----------------------------------------------------------------
# 4. Method vs operator (iterable vs set)
# ----------------------------------------------------------------
s = {1, 2, 3}
print(s.union([4, 5, 6]))              # {1, 2, 3, 4, 5, 6}
print(s.intersection(range(2, 5)))     # {2, 3}
print(s.difference(range(1, 3)))       # {3}

# Operators require set type:
try:
    print(s | [4, 5])
except TypeError as e:
    print(e)   # unsupported operand type(s) for |: 'set' and 'list'


# ----------------------------------------------------------------
# 5. Mutation methods
# ----------------------------------------------------------------
s = {1, 2, 3}
s.add(4)         # {1, 2, 3, 4}
s.discard(10)    # no-op (10 not in s)
s.remove(2)      # {1, 3, 4}
try:
    s.remove(99)
except KeyError:
    print("KeyError: 99 not in set")

s.update([5, 6, 7])   # {1, 3, 4, 5, 6, 7}
print(s)


# ----------------------------------------------------------------
# 6. In-place operators
# ----------------------------------------------------------------
s = {1, 2, 3}
s |= {4, 5}     # s = s | {4, 5}
s &= {2, 3, 4} # s = s & {2, 3, 4}
print(s)   # {2, 3, 4}


# ----------------------------------------------------------------
# 7. Subset / superset relations
# ----------------------------------------------------------------
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
print(a <= b)            # True  (a is subset of b)
print(a < b)             # True  (a is proper subset)
print(b >= a)            # True  (b is superset)
print(a.issubset(b))     # True
print(b.issuperset(a))   # True
print(a.isdisjoint({6, 7, 8}))  # True


# ----------------------------------------------------------------
# 8. Set comprehension
# ----------------------------------------------------------------
evens   = {x for x in range(20) if x % 2 == 0}
squares = {x**2 for x in range(-5, 6)}
print(evens)    # {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}
print(squares)  # {0, 1, 4, 9, 16, 25}


# ----------------------------------------------------------------
# 9. frozenset as dict key
# ----------------------------------------------------------------
# Use case: represent a pair of items regardless of order
graph_edges = {
    frozenset({"A", "B"}): 5,
    frozenset({"B", "C"}): 3,
    frozenset({"A", "C"}): 7,
}
print(graph_edges[frozenset({"B", "A"})])   # 5 (same as frozenset({"A","B"}))


# ----------------------------------------------------------------
# 10. True/False deduplication
# ----------------------------------------------------------------
s = {0, False, 1, True, 2}
print(s)      # {0, 1, 2}  — True==1, False==0
print(len(s)) # 3


# ----------------------------------------------------------------
# 11. * unpacking in set literals (PEP 448)
# ----------------------------------------------------------------
s1 = {1, 2, 3}
s2 = {4, 5, 6}
combined = {*s1, *s2, 7}
print(combined)   # {1, 2, 3, 4, 5, 6, 7}


# ----------------------------------------------------------------
# 12. Practical: deduplication preserving some structure
# ----------------------------------------------------------------
words = ["apple", "banana", "apple", "cherry", "banana", "date"]
unique = set(words)
print(unique)   # {'apple', 'banana', 'cherry', 'date'} (unordered)

# If order matters (Python 3.7+ dict preserves insertion order):
seen = set()
unique_ordered = [w for w in words if not (w in seen or seen.add(w))]
print(unique_ordered)   # ['apple', 'banana', 'cherry', 'date'] (ordered)