Python Sets - Deduplication Lost Order, Corrupted Report

Every program eventually needs to answer questions like 'which users signed up twice?' or 'which items do these two shopping carts have in common?' Without the right tool, answering those questions means writing loops inside loops, tracking flags, and hoping you didn't miss an edge case. Sets exist to make that kind of work trivially easy — and they're built right into Python, no imports needed.

The core problem sets solve is uniqueness plus fast membership testing. If you store a million email addresses in a list and need to check whether one specific address is in there, Python has to scan every single item — that's slow. A set can answer the same question almost instantly, no matter how large it is. On top of that, sets give you mathematical operations — union, intersection, difference — with a single operator instead of complex logic.

By the end of this article you'll know how to create a set, add and remove items, use set operations to compare collections, and — crucially — recognise exactly when a set is the right tool for the job. You'll also know the two most common mistakes beginners make so you can skip straight past them.

Why Python Sets Lose Order and How That Corrupts Reports

A Python set is an unordered collection of unique hashable objects. Its core mechanic is hashing: each element is stored at a bucket determined by hash(element) % table_size. This gives O(1) average-case membership tests and insertions, but the iteration order depends on the hash values and the internal collision resolution, which can change between runs due to hash randomization (PYTHONHASHSEED). In practice, this means two identical sets can yield different iteration orders across interpreter sessions. This is not a bug — it's a deliberate security feature against hash collision DoS attacks. But it breaks any code that assumes stable ordering, such as CSV exports, log aggregators, or diff-based validators. Use sets when you need uniqueness and fast membership checks, but never when order matters. For ordered unique collections, use dict.fromkeys() (Python 3.7+) or OrderedSet.

Creating a Set and Understanding Why Duplicates Vanish

There are two ways to create a set in Python. The first is the curly-brace literal syntax — you put your items inside {}, separated by commas. The second is the set() constructor, which converts any iterable (like a list or string) into a set.

The moment you create a set, Python silently discards any duplicate values. This isn't an error — it's the point. If you pass in [1, 2, 2, 3], the set keeps {1, 2, 3}. The original list is untouched; the set is a new, deduplicated collection.

One thing that surprises beginners: the order you see when you print a set is NOT guaranteed to match the order you put items in. Sets are unordered by design, which is part of what makes them so fast. If order matters to you, a set is the wrong tool — use a list. If uniqueness matters and order doesn't, a set is perfect.

Also important: every item in a set must be hashable. That means strings, numbers, and tuples are fine. Lists and dictionaries are NOT allowed as set members because they can change — Python can't safely hash something that might mutate.

# ── Way 1: curly-brace literal ──────────────────────────────────────────
favourite_fruits = {"apple", "mango", "banana", "apple", "mango"}
# Notice: "apple" and "mango" appear twice above — watch what Python keeps
print("Favourite fruits:", favourite_fruits)

# ── Way 2: set() constructor converts a list into a set ──────────────────
raw_signups = ["alice@mail.com", "bob@mail.com", "alice@mail.com", "carol@mail.com"]
unique_signups = set(raw_signups)   # duplicates dropped automatically
print("Unique signups:", unique_signups)
print("Total unique:", len(unique_signups))   # 3, not 4

# ── set() on a string splits it into unique CHARACTERS ──────────────────
letters_in_word = set("mississippi")   # only unique letters survive
print("Unique letters in 'mississippi':", letters_in_word)

# ── An empty set MUST use set(), NOT {} ─────────────────────────────────
empty_set = set()         # correct — this is an empty set
empty_dict = {}           # WRONG for a set — this creates an empty dictionary!
print("Type of set():", type(empty_set))    # <class 'set'>
print("Type of {}:  ", type(empty_dict))    # <class 'dict'>  ← gotcha!

Adding, Removing and Checking Items — The Everyday Set Operations

Once you have a set, you'll want to add new items, remove old ones, and check whether something is already in there. These are the three most common day-to-day operations.

To add a single item, use .add(). If the item is already in the set, nothing happens — no error, no duplicate, just silence. To add multiple items at once, use .update() and pass it any iterable.

Removing is where you get a choice. .remove() deletes an item but raises a KeyError if the item doesn't exist — use this when you're sure the item is there. .discard() does the same thing but does NOTHING if the item is missing — use this when you're not sure. Think of .discard() as the polite version: it won't complain.

The in keyword checks membership, and this is where sets genuinely shine. Checking item in my_set is O(1) — constant time — regardless of how large the set is. The same check on a list is O(n) — it gets slower as the list grows. This speed difference is why sets exist at all for lookup-heavy tasks.

# Starting set of confirmed attendees at an event
attendees = {"Alice", "Bob", "Carol"}

# ── Adding items ──────────────────────────────────────────────────────────
attendees.add("David")          # add one person
attendees.add("Alice")          # Alice is already there — nothing changes
print("After adding Alice again:", attendees)   # still only one Alice

attendees.update(["Eve", "Frank", "Grace"])   # add several people at once
print("After batch add:", attendees)

# ── Removing items ────────────────────────────────────────────────────────
attendees.remove("Bob")          # Bob cancelled — we're sure he's in the set
print("After removing Bob:", attendees)

attendees.discard("Zara")        # Zara was never there — discard won't crash
print("After discarding Zara (who wasn't there):", attendees)

# attendees.remove("Zara")       # ← this WOULD raise KeyError — commented out

# ── Membership testing — the fastest way to check ─────────────────────────
print("Is Alice attending?", "Alice" in attendees)    # True
print("Is Bob attending? ", "Bob" in attendees)       # False — we removed him

# ── Practical example: deduplicating user IDs from two data sources ────────
app_logins   = [101, 102, 103, 102, 104, 101]   # raw log with repeats
unique_users = set(app_logins)                  # instant deduplication
print("Unique user IDs:", unique_users)
print("Count:", len(unique_users))              # 4 unique users

Set Math — Union, Intersection and Difference in Plain English

This is where sets go from 'nice to have' to genuinely powerful. Python sets support four mathematical operations that let you compare two collections in ways that would otherwise require several lines of loop logic.

Union (| or .union()) — give me EVERYTHING from both sets. Like combining two guest lists into one, no repeats.

Intersection (& or .intersection()) — give me only items that appear in BOTH sets. Like finding mutual friends between two people.

Difference (- or .difference()) — give me items in set A that are NOT in set B. Like finding which guests from list A didn't appear on list B.

Symmetric Difference (^ or .symmetric_difference()) — give me items that are in one set OR the other, but NOT both. Everything exclusive to each side.

These operations don't modify the original sets — they return a brand new set. If you want to modify the original in place, use the assignment versions: |=, &=, -=, ^=.

# Two streaming platforms and their exclusive shows
netflix_shows  = {"Stranger Things", "Ozark", "The Crown", "Dark", "Squid Game"}
disney_shows   = {"The Mandalorian", "WandaVision", "Squid Game", "The Crown", "Loki"}
# Note: "Squid Game" and "The Crown" are on both (hypothetically)

# ── UNION — everything available on either platform ───────────────────────
all_shows = netflix_shows | disney_shows
print("All shows across both platforms:")
print(all_shows)
print(f"Total unique titles: {len(all_shows)}\n")

# ── INTERSECTION — shows available on BOTH platforms ─────────────────────
shared_shows = netflix_shows & disney_shows
print("Shows on BOTH platforms (overlaps):")
print(shared_shows)   # {'Squid Game', 'The Crown'}
print()

# ── DIFFERENCE — shows ONLY on Netflix (not on Disney) ───────────────────
netflix_only = netflix_shows - disney_shows
print("Shows exclusive to Netflix:")
print(netflix_only)
print()

# ── SYMMETRIC DIFFERENCE — exclusives on each side ───────────────────────
exclusive_to_one_platform = netflix_shows ^ disney_shows
print("Shows exclusive to exactly one platform (not shared):")
print(exclusive_to_one_platform)
print()

# ── Real-world use case: which users are new today? ──────────────────────
users_yesterday = {"alice", "bob", "carol", "david"}
users_today     = {"alice", "carol", "eve", "frank"}

new_users     = users_today - users_yesterday    # signed up since yesterday
lost_users    = users_yesterday - users_today    # didn't return today
loyal_users   = users_today & users_yesterday    # came back both days

print("New users today:  ", new_users)
print("Users who left:   ", lost_users)
print("Loyal returning:  ", loyal_users)

Frozen Sets — When You Need an Immutable Set

Regular sets are mutable — you can add and remove items after creation. But sometimes you need a set that nobody can change, one you can use as a dictionary key or store inside another set. That's what frozenset is for.

A frozenset is exactly like a regular set — same uniqueness guarantee, same fast membership testing, same mathematical operations — except it's locked after creation. You can't call .add() or .remove() on it. In exchange, it's hashable, which means you can use it as a dictionary key or put it inside another set.

When would you actually use this? Imagine you're building a permissions system where a group of permissions is a unit — you want to use that group as a dictionary key to look up what role it maps to. A regular set can't be a key. A frozenset can.

For most beginner work you won't need frozensets often, but knowing they exist saves you from confusion when you hit the 'unhashable type: set' error — and it will definitely come up in interviews.

# Regular set — mutable, cannot be used as a dictionary key
read_write_permissions = {"read", "write", "delete"}

# Frozenset — immutable, CAN be used as a dictionary key
admin_permissions    = frozenset({"read", "write", "delete", "admin"})
viewer_permissions   = frozenset({"read"})
editor_permissions   = frozenset({"read", "write"})

# Using frozensets as dictionary KEYS — impossible with regular sets
permission_to_role = {
    admin_permissions  : "Administrator",
    editor_permissions : "Editor",
    viewer_permissions : "Viewer",
}

# Look up what role a set of permissions maps to
user_perms = frozenset({"read", "write"})
print("User role:", permission_to_role[user_perms])   # Editor

# Frozensets support all the same math as regular sets
common = admin_permissions & editor_permissions
print("Shared permissions (admin & editor):", common)

# Attempting to modify a frozenset raises AttributeError
try:
    viewer_permissions.add("write")    # this will fail
except AttributeError as error:
    print(f"Cannot modify frozenset: {error}")

# You CAN put a frozenset inside a regular set
all_roles = {admin_permissions, editor_permissions, viewer_permissions}
print("Number of distinct roles:", len(all_roles))   # 3

Set Comprehensions: Build Sets in One Line

Just like list comprehensions, Python has set comprehensions. Use curly braces with a for clause directly. The result is a set, so duplicates are automatically removed. This is ideal when you need to transform or filter an iterable and get unique results.

Syntax: {expression for item in iterable if condition}

The result is a set, so any duplicate values from the expression are collapsed into one. This is faster than manually building a set with a loop because the comprehension is executed in C under the hood.

Use set comprehensions when the input is large and you both need to transform and deduplicate items.

# ── Basic set comprehension ──────────────────────────────────────────────
# Get unique squares of numbers 0-9
squares = {x**2 for x in range(10)}
print("Unique squares:", squares)   # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# ── With condition ─────────────────────────────────────────────────────────
# Get unique lengths of words with length > 3
words = ["hello", "world", "hi", "python", "set", "comprehension"]
lengths = {len(w) for w in words if len(w) > 3}
print("Unique lengths > 3:", lengths)   # {5, 6, 13}

# ── Real-world: unique user domains from email list ───────────────────────
emails = ["alice@example.com", "bob@test.org", "carol@example.com", "dave@test.org"]
domains = {email.split('@')[1] for email in emails}
print("Unique domains:", domains)   # {'test.org', 'example.com'}

# ── set() with generator is similar but less readable ─────────────────────
same_domains = set(email.split('@')[1] for email in emails)
print("Same with generator:", same_domains)

Performance Considerations and Common Pitfalls

While sets are incredibly fast for membership testing and mathematical operations, they are not without trade-offs. The O(1) membership test relies on hashing; if your objects have poor hash distribution (e.g., all equal hash), performance degrades to O(n) due to hash collisions. Python's set implementation uses dynamic resizing and open addressing with pseudo-random probing to mitigate collisions, but extreme cases can still cause slowdown.

Another pitfall: sets consume more memory than lists for the same number of elements because of hash table overhead. For small collections (few hundred items) this is negligible, but for millions of items, memory usage can be 3-5x that of a list.

Also, sets cannot contain mutable objects. This is a common source of confusion when trying to use lists as set members. Convert to tuples or use frozenset if you need nested collections.

Finally, sets are not thread-safe for write operations. Concurrent modifications can corrupt internal state. Use locking or a thread-safe collection like multiprocessing.Manager() or just synchronize access.

# ── Hash collision can degrade performance ────────────────────────────────
class BadHash:
    def __hash__(self):
        return 42  # terrible idea — all objects collide
    def __eq__(self, other):
        return self is other

elements = [BadHash() for _ in range(1000)]
s = set(elements)
# Membership check is O(n) in the worst case — each call goes through full chain
import timeit
# (Example only — actual slowdown varies)

# ── Memory overhead comparison ─────────────────────────────────────────────
import sys
items_list = list(range(100_000))
items_set = set(items_list)
print(f"List size: {sys.getsizeof(items_list)} bytes")
print(f"Set size:  {sys.getsizeof(items_set)} bytes")   # set is ~4x larger

# ── Mutation after insertion — the silent bug ───────────────────────────
class MutableKey:
    def __init__(self, val):
        self.val = val
    def __hash__(self):
        return hash(self.val)
    def __eq__(self, other):
        return self.val == other.val

k = MutableKey(10)
s = set([k])
k.val = 20                  # mutation changes hash
print("10 in set:", MutableKey(10) in s)   # False — item is lost!
print("20 in set:", MutableKey(20) in s)   # False — hash changed
# Lesson: never mutate objects after adding them to a set

Set Cardinality: Why len() Lies to You in Production Pipelines

You've been burned by len() before — maybe on a generator that exhausted itself, or a numpy array that returned shape(), not count. Sets are no different, but the failure mode is subtle. The cardinal number of a set is simply the count of unique elements, returned by len(). Here's the trap: if you're building a set from a stream and checking its size before it's fully populated, you're reading a partial snapshot. Sets don't raise errors; they just return a smaller number than expected. That corrupts downstream logic — buffer sizes, batch counts, or even financial aggregations. Always ensure your set is fully materialized before relying on len(). Use a sentinel or flush marker. And never, ever rely on len() inside a loop that's mutating the same set. Python won't stop you; your PagerDuty will.

// io.thecodeforge — python tutorial

user_ids = set()
# Simulate streaming ingestion with a sleep
import time

def ingest_users(batch):
  for uid in batch:
    yield uid
    time.sleep(0.001)  # realistic I/O delay

stream = ingest_users(["alice", "bob", "alice", "charlie"])

# WRONG: reading len() mid-stream
for uid in stream:
  user_ids.add(uid)
  if len(user_ids) == 3:  # false trigger
    print("Expected 3 unique users, breaking early")
    break

# RIGHT: materialize fully
print(f"Final cardinality: {len(user_ids)}")  
print("Set contents:", sorted(user_ids))

Semantic vs. Roster Form: Why set() Literals Are Your Only Safe Bet

Mathematicians love their semantic set builders: {x | x ∈ ℕ, x > 5}. Beautiful. Useless in Python. You have exactly two real representations: roster form (curly-brace literals) and the set() constructor. Roster form wins — {1, 2, 3} is fast to parse, atomic, and cries 'set' at a glance. set() is for edge cases: building from generators, reading from files, or coercing other iterables. Here's where juniors get hosed: they write x = set('abc') expecting {'abc'}, but get {'a','b','c'}. Semantic confusion. That's a production bug, not a learning moment. Roster form eliminates that gap. Use set() only when the source is dynamic — a CSV column, an API response. Otherwise, type the braces. Your future self debugging at 2 AM will thank you.

// io.thecodeforge — python tutorial

# Roster form — preferred for static data
customer_tiers = {"standard", "premium", "enterprise"}
print("Roster set:", customer_tiers)

# set() constructor — explodes iterables into individual elements
user_input = "abc"
parsed = set(user_input)  # BEWARE: not {'abc'}
print("set('abc') yields:", parsed)

# Correct way to wrap a string as a single element
safe = {user_input}
print("Literal wrapper yields:", safe)

# set() from generator — legit use
active_orders = {oid for oid in range(10) if oid % 2 == 0}  # set comprehension
print("Comprehension:", active_orders)

Venn Diagrams Are Not Just Math Class — They Debug Your Set Logic

You drew Venn diagrams in fifth grade. Good news: they still matter because union, intersection, and difference are not just theoretical — they are the only tools you have to reason about overlapping data in production. When you have two sets of user IDs — one from a CRM dump, one from an event stream — and the intersection is empty but shouldn't be, you need a Venn diagram in your head. Python gives you the operators (|, &, -) but not the picture. So here's the debug trick: compute all three regions and print them. If your intersection is tiny, check for casing, whitespace, or data-type mismatches. If the difference is huge, your data pipeline has a drift. Visualize by sorting and printing. It's cheap, it's fast, and it catches the kind of bugs that slip through unit tests.

// io.thecodeforge — python tutorial

# Two sets from different sources (simulated)
crm_users = {"alice@co.com", "bob@co.com", "  charlie@co.com  "}  # note whitespace
stream_users = {"alice@co.com", "bob@co.com", "david@co.com"}

# Debug: compute all Venn regions
only_in_crm = crm_users - stream_users
only_in_stream = stream_users - crm_users
in_both = crm_users & stream_users

print("Only in CRM:", only_in_crm)
print("Only in stream:", only_in_stream)
print("Intersection:", in_both)

# Root cause: whitespace in CRM data
cleaned_crm = {u.strip() for u in crm_users}
print("\nAfter cleaning:")
print("Intersection:", cleaned_crm & stream_users)
print("Cleaned only in CRM:", cleaned_crm - stream_users)

Subsets and Supersets — The Set Relationship That Saves You Loops

Sets in Python let you test relationships between collections without writing a single loop. A set A is a subset of set B if every element of A also belongs to B. Python's issubset() method or the <= operator makes this explicit. Supersets reverse the relationship: A is a superset of B if it contains all elements of B. Use issuperset() or >=. These checks are critical for validation pipelines — for example, confirming that an incoming data set contains all required fields before processing. The check runs in O(len(smaller set)) time because Python short-circuits on the first missing element. Never loop manually for containment checks; use subset relations instead. They make your intent obvious and your code faster. The difference between subset and proper subset (<) matters: a proper subset means A is a subset of B but not equal to B. Use proper subsets when you need strict containment, like verifying that a user's permissions are strictly fewer than an admin's.

// io.thecodeforge — python tutorial

fields_required = {'email', 'name', 'age'}
user_provided = {'email', 'name'}

# Check if user provided all required fields
if user_provided.issuperset(fields_required):
    print('All fields present')
else:
    print('Missing fields:', fields_required - user_provided)

# Proper subset: strict containment
admin_perms = {'read', 'write', 'delete'}
editor_perms = {'read', 'write'}
print('Editor is proper subset?', editor_perms < admin_perms)  # True
print('Admin is subset of itself?', admin_perms <= admin_perms)  # True

Deleting Elements With .discard() — The Safe Silent Removal

// io.thecodeforge — python tutorial

processed = {101, 102, 103}

# Safe removal — no error for missing element
processed.discard(104)  # No crash, set unchanged
print(processed)  # {101, 102, 103}

# remove() would crash here
# processed.remove(104)  # KeyError

# Actual removal
processed.discard(102)
print(processed)  # {101, 103}

Shallow Copies of Sets With .copy() — Avoiding Mutation Mayhem

// io.thecodeforge — python tutorial

original = {1, 2, 3}
ref = original  # reference, not copy
copy_set = original.copy()

original.add(4)
print('Ref sees change:', ref)       # {1, 2, 3, 4}
print('Copy stays same:', copy_set)  # {1, 2, 3}

# Shallow copy with nested mutable won't protect inner objects
nested = {(1, 2), [3, 4]}  # fails — list unhashable
# Use frozenset for immutable containers
safe = {frozenset({1,2}), frozenset({3,4})}
safe_copy = safe.copy()
print('Same objects?', id(safe_copy.pop()) == id(safe.pop()))

Getting Started With Python’s set Data Type

A set is an unordered collection of unique, hashable elements. Think of it as a mathematical set without duplicates, built for fast membership testing. Use curly braces {1, 2, 3} for literal syntax, but avoid empty braces {} because Python interprets those as an empty dictionary. Instead, initialize an empty set with set(). Sets discard duplicate elements silently, so {1, 2, 2} becomes {1, 2}. Strings break into individual characters when passed to set(), which causes confusion for new learners. Use frozenset for immutable sets when you need hashability, like as dictionary keys. Sets require all elements to be hashable — lists and dictionaries fail, tuples succeed if their contents are hashable. Always prefer set() {elements} over set([elements]) because the latter creates a temporary list, wasting memory and time. This subtle performance trap surfaces in loops operating on millions of items.

// io.thecodeforge — python tutorial
// 25 lines max
fruits = {'apple', 'banana', 'apple', 'cherry'}
print(fruits)  # {'banana', 'apple', 'cherry'}

empty_set = set()
bad_set = {}  # dict, not set
print(type(empty_set), type(bad_set))

# Strings unpack into characters
letters = set('hello')
print(letters)  # {'h', 'e', 'l', 'o'}

# Only hashable elements allowed
# set([[1,2], [3,4]])  # TypeError: unhashable type: 'list'

# Frozen set for hashable use case
immutable = frozenset([1, 2, 3])
print(immutable)

Exploring Other Set Capabilities

Sets offer methods beyond union, intersection, and difference. Use .isdisjoint() to check if two sets share no elements — faster than intersection for early exits. The .symmetric_difference() method (^ operator) returns elements in either set but not both, perfect for detecting exclusive items. Use .update() to add multiple elements from any iterable, similar to list.extend() but with deduplication. The .intersection_update() and .difference_update() modify the set in-place, reducing memory churn when processing large pipelines. Sets support comparison operators: < and > test proper subsets and supersets, while <= and >= allow equality. Use the | union, & intersection, - difference, and ^ symmetric difference operators for combined operations. These methods accept any iterable input, but always convert inputs to sets internally — pass large iterables with caution. For exclusive presence detection in data pipelines, symmetric_difference is the silent workhorse.

// io.thecodeforge — python tutorial
// 25 lines max
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a.isdisjoint({7, 8}))      # True
print(a ^ b)                      # {1, 2, 5, 6} symmetric diff

a.update([10, 20, 30])            # in-place addition
print(a)                          # {1, 2, 3, 4, 10, 20, 30}

a.intersection_update({1, 3, 10}) # keep only common
print(a)                          # {1, 3, 10}

full = {1, 2, 3}
sub = {1, 2}
print(sub < full)                 # True (proper subset)
print({1, 2} <= {1, 2})          # True (subset, equal)

Frozen Sets: Immutable and Hashable Set Variants

Frozen sets are immutable versions of Python sets. Once created, you cannot add, remove, or modify elements. This immutability makes them hashable, so they can be used as dictionary keys or elements of other sets. Frozen sets are created using the frozenset() constructor, which accepts any iterable. They support all non-mutating set operations like union, intersection, and difference, but methods like .add() or .remove() are not available. Use frozen sets when you need a constant set that must not change, or when you need to store sets inside other sets or as dictionary keys. For example, a frozen set can represent a fixed configuration or a set of immutable options. They are also useful in caching or memoization where the input is a set of parameters. Below is an example of creating a frozen set and using it as a dictionary key.

# Creating a frozen set
frozen = frozenset([1, 2, 3, 3, 4])
print(frozen)  # frozenset({1, 2, 3, 4})

# Using as dictionary key
lookup = {frozen: "value"}
print(lookup[frozen])  # value

# Attempting to modify raises AttributeError
# frozen.add(5)  # AttributeError: 'frozenset' object has no attribute 'add'

Set Operations: Union, Intersection, Difference, Symmetric Difference

Python sets support mathematical set operations that allow you to combine, compare, and contrast sets efficiently. The four primary operations are union, intersection, difference, and symmetric difference. Union (| or .union()) returns a new set containing all elements from both sets. Intersection (& or .intersection()) returns elements common to both sets. Difference (- or .difference()) returns elements in the first set but not in the second. Symmetric difference (^ or .symmetric_difference()) returns elements in either set but not both. These operations can be performed with multiple sets using method chaining or operator chaining. They are optimized and run in O(len(smaller set)) average time. Use these operations for tasks like finding common tags, unique items, or discrepancies between datasets. Below is an example demonstrating all four operations.

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

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

# Intersection
print(a & b)  # {3, 4}
print(a.intersection(b))  # same

# Difference
print(a - b)  # {1, 2}
print(a.difference(b))  # same

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

Set Performance: When to Use Set vs List vs Dict

Choosing between sets, lists, and dictionaries depends on your use case. Sets are optimized for membership testing (in), deduplication, and mathematical operations. Membership testing in a set is O(1) average, compared to O(n) for lists. Sets also automatically remove duplicates. However, sets are unordered and do not support indexing. Lists are ordered and allow duplicates, making them ideal for sequences where order matters. Dictionaries store key-value pairs and provide O(1) key lookup. Use sets when you need to check for existence, remove duplicates, or perform set operations. Use lists when order or indexing is required, or when you need to store duplicates. Use dicts when you need to associate values with unique keys. For large datasets, sets and dicts are much faster for lookups. However, sets consume more memory than lists due to hash table overhead. Below is a performance comparison.

import time

# Large dataset
n = 10**6
list_data = list(range(n))
set_data = set(list_data)

# Membership test
start = time.time()
for i in range(1000):
    _ = n + 1 in list_data
print("List membership:", time.time() - start)

start = time.time()
for i in range(1000):
    _ = n + 1 in set_data
print("Set membership:", time.time() - start)

# Output:
# List membership: ~0.05s
# Set membership: ~0.0001s