Python Sets — The Complete Guide to Methods

The Story That Explains Sets

A Python set is an unordered collection of unique, hashable elements. It borrows from mathematics — union, intersection, difference — and pairs those operations with near-constant-time membership tests. Every duplicate you throw at it is silently discarded. Every membership question is answered in one hop.

The Three Laws of Every Set

Before touching syntax, internalise the three properties that define every set. Every method, every operation, every edge case flows from these rules.

Creating a Set — Four Ways

# 1) Literal — the cleanest and most common
colours = {"red", "green", "blue"}

# 2) From an iterable using the set() constructor
letters = set("hello")          # {'h', 'e', 'l', 'o'}  — 'l' deduped
nums    = set([1, 2, 2, 3, 3])   # {1, 2, 3}

# 3) Set comprehension — filter + transform in one step
squares = {n ** 2 for n in range(6)}

# 4) Empty set — the ONE case where the {} literal fails
empty = set()      # CORRECT — empty set
oops  = {}         # WRONG — this is an empty DICT, not a set!

print(colours)
print(letters)
print(type(oops).__name__)  # dict, not set

Adding & Removing — The Mutation Methods

fruits = {"apple", "banana"}

fruits.add("cherry")          # {'apple', 'banana', 'cherry'}
fruits.add("apple")           # no change — silent duplicate

fruits.update(["kiwi", "mango"]) # adds both from a list
fruits.update("AB")              # adds 'A' AND 'B' — strings are iterable!

fruits.discard("kiwi")          # removes safely, silent if absent
fruits.discard("grape")         # NOT there — but no error

try:
    fruits.remove("grape")      # NOT there — raises KeyError
except KeyError as e:
    print(f"KeyError: {e}")

random_fruit = fruits.pop()      # removes one arbitrary element
print(f"Popped: {random_fruit}")

fruits.clear()                   # now empty
print(f"After clear: {fruits}")

Membership Testing — The Superpower

This is why sets exist. Checking whether an element is inside a collection is the single most common operation in data work, and sets do it in constant time — regardless of size.

allowed_users = {"alice", "bob", "charlie", "diana"}

# The 'in' operator — O(1) on average, regardless of set size
print("alice" in allowed_users)     # True
print("eve" not in allowed_users)   # True

# Same test on a 1-million-element set — still O(1)
big_set = set(range(1_000_000))
print(999_999 in big_set)          # True — instant

Set Operations — Visual Reference

This is where sets show off. Four operations you'd otherwise write nested loops for become a single symbol. Below is the complete visual reference — each Venn diagram shows the highlighted region as the result.

Union — A | B — Everything from Both

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

# Operator form — clean and Pythonic
print(a | b)              # {1, 2, 3, 4, 5, 6}

# Method form — accepts ANY iterable, not just sets
print(a.union(b, [7, 8])) # {1, 2, 3, 4, 5, 6, 7, 8}

# In-place version — modifies a
a |= b
print(a)                  # {1, 2, 3, 4, 5, 6}

Intersection — A & B — Common Elements Only

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

# Operator form
print(a & b)                       # {3, 4}

# Method form
print(a.intersection(b))            # {3, 4}

# Real use: users who are BOTH admins AND active
admins = {"alice", "bob", "charlie"}
active = {"bob", "charlie", "diana", "eve"}
active_admins = admins & active
print(f"Active admins: {active_admins}")

Difference — A - B — Everything in A but Not in B

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

print(a - b)                       # {1, 2}  — in a, not in b
print(b - a)                       # {5, 6}  — in b, not in a
print(a.difference(b))              # {1, 2}

# Real use: which requested features are NOT yet built?
requested = {"dark_mode", "exports", "api_v2", "webhooks"}
built     = {"dark_mode", "exports"}
pending   = requested - built
print(f"Still to build: {pending}")

Symmetric Difference — A ^ B — In One But Not Both

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

print(a ^ b)                              # {1, 2, 5, 6}
print(a.symmetric_difference(b))          # {1, 2, 5, 6}

# Real use: what changed between two snapshots?
yesterday = {"file_a.csv", "file_b.csv", "file_c.csv"}
today     = {"file_b.csv", "file_c.csv", "file_d.csv"}
changes = yesterday ^ today
print(f"Changed files: {changes}")   # deleted + new

Set Relationships — Subset, Superset, Disjoint

Beyond the four operations, sets can also be compared as wholes. Is one set entirely contained in another? Do two sets share nothing at all? These relationships have one-shot method calls too.

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

# Subset — is every element of b also in a?
print(b.issubset(a))          # True
print(b <= a)                  # True  (operator form)
print(b < a)                   # True  (STRICT subset — b != a)

# Superset — the mirror question
print(a.issuperset(b))        # True
print(a >= b)                  # True

# Disjoint — do they share ZERO elements?
print(a.isdisjoint(c))        # True — nothing in common
print(a.isdisjoint(b))        # False — they overlap

Frozenset — The Immutable Cousin

A regular set is mutable — you can add and remove things. Sometimes you need a hashable, unchangeable version: an element of another set, a dictionary key, or a value guaranteed not to change. That's frozenset.

# Create a frozenset from any iterable
permissions = frozenset(["read", "write", "delete"])

# All non-mutating operations still work
print("read" in permissions)               # True
print(permissions | {"admin"})            # returns NEW frozenset

# But mutation is forbidden
try:
    permissions.add("admin")
except AttributeError as e:
    print(f"Blocked: {e}")

# Because it's hashable, a frozenset can be:
# 1) an element of another set
role_bundles = {
    frozenset({"read"}),
    frozenset({"read", "write"}),
    frozenset({"read", "write", "admin"})
}
print(len(role_bundles))                    # 3

# 2) a dictionary key
cache = {
    frozenset(["a", "b"]): "result_ab",
    frozenset(["c", "d"]): "result_cd",
}
print(cache[frozenset(["b", "a"])])       # order doesn't matter

Practical Real-World Examples

Example 1 — Instant Deduplication of a List

emails = ["alice@ex.com", "bob@ex.com", "alice@ex.com",
          "eve@ex.com", "bob@ex.com"]

# One line — order NOT preserved
unique_emails = list(set(emails))
print(unique_emails)

# If order matters, preserve first occurrence via dict.fromkeys()
unique_ordered = list(dict.fromkeys(emails))
print(unique_ordered)

Example 2 — Permission Checking

required_perms  = {"read", "write"}
user_perms      = {"read", "write", "delete", "share"}

# Does the user have EVERY required permission?
if required_perms <= user_perms:
    print("Access granted")
else:
    missing = required_perms - user_perms
    print(f"Missing: {missing}")

Example 3 — Tag-Based Recommendations

user_tags    = {"python", "data-science", "ml", "stats"}
article_tags = {"python", "ml", "deep-learning"}

# Match score = size of intersection
overlap = user_tags & article_tags
score = len(overlap) / len(user_tags | article_tags)

print(f"Common interests: {overlap}")
print(f"Jaccard similarity: {score:.2%}")

Example 4 — Finding What Changed

old_snapshot = {"config.yaml", "main.py", "utils.py", "data.csv"}
new_snapshot = {"config.yaml", "main.py", "helpers.py", "data.csv"}

added   = new_snapshot - old_snapshot
removed = old_snapshot - new_snapshot
unchanged = old_snapshot & new_snapshot

print(f"Added:     {added}")
print(f"Removed:   {removed}")
print(f"Unchanged: {unchanged}")

Example 5 — Fast Filtering Against a Blocklist

# A million user IDs coming through
incoming_ids = range(1_000_000)

# 50,000 banned IDs — as a SET for O(1) lookup
banned = set(range(0, 1_000_000, 20))

# Filter — near-instant thanks to set lookup
allowed = [uid for uid in incoming_ids if uid not in banned]

print(f"Allowed: {len(allowed):,}")
print(f"Blocked: {len(banned):,}")

Performance — List vs Set for Membership

import timeit

# Same 100,000 items — stored as list vs set
data_list = list(range(100_000))
data_set  = set(data_list)

# Worst case: search for last item
target = 99_999

t_list = timeit.timeit(
    lambda: target in data_list, number=10_000
)
t_set  = timeit.timeit(
    lambda: target in data_set,  number=10_000
)

print(f"List lookup: {t_list:.4f}s")
print(f"Set lookup:  {t_set:.4f}s")
print(f"Set is {t_list / t_set:.0f}x faster")

When NOT to Use a Set

# These all fail with TypeError: unhashable type
try:
    bad = {[1, 2], [3, 4]}         # lists inside a set
except TypeError as e:
    print(f"Nope: {e}")

# FIX — convert inner lists to tuples (immutable, hashable)
good = {(1, 2), (3, 4)}
print(good)                            # works!

Complete Method Reference

Golden Rules