Sets

Beginner ~25 min read

Sets are Python's unordered collections with no duplicate elements. They're perfect for removing duplicates, testing membership efficiently, and performing mathematical set operations like union, intersection, and difference. Think of them as mathematical sets from school!

Creating Sets

Sets are created with curly braces {} or the set() constructor. Duplicates are automatically removed, and only immutable (hashable) items can be stored.

# Creating Sets in Python

# 1. Using curly braces {}
print("=== Creating Sets ===")
fruits = {"apple", "banana", "cherry"}
print(f"From braces: {fruits}")
print(f"Type: {type(fruits)}")
print()

# 2. Using set() constructor
print("=== Using set() Constructor ===")
from_list = set([1, 2, 3, 2, 1])  # Duplicates removed!
from_string = set("hello")  # Each character becomes element
from_tuple = set((1, 2, 3))
print(f"From list [1,2,3,2,1]: {from_list}")
print(f"From string 'hello': {from_string}")
print(f"From tuple: {from_tuple}")
print()

# 3. Empty set - MUST use set(), not {}
print("=== Empty Set ===")
empty_set = set()  # Correct way
empty_dict = {}    # This is a dict, not a set!
print(f"set(): {empty_set}, type: {type(empty_set)}")
print(f"{{}}: {empty_dict}, type: {type(empty_dict)}")
print()

# 4. Duplicates are automatically removed
print("=== Automatic Duplicate Removal ===")
numbers = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4}
print(f"Input: {{1, 2, 2, 3, 3, 3, 4, 4, 4, 4}}")
print(f"Result: {numbers}")
print()

# 5. Sets are unordered
print("=== Sets are Unordered ===")
colors = {"red", "green", "blue"}
print(f"Set: {colors}")
print("Order may differ each time you run!")
print()

# 6. Only immutable (hashable) items allowed
print("=== Hashable Items Only ===")
valid_set = {1, "hello", (1, 2), 3.14, True}
print(f"Valid (immutable items): {valid_set}")
# invalid_set = {[1, 2]}  # TypeError: unhashable type: 'list'
print("Cannot add lists, dicts, or other sets as elements!")
print()

# 7. Practical: Remove duplicates from list
print("=== Remove Duplicates from List ===")
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = list(set(my_list))
print(f"Original list: {my_list}")
print(f"Unique (via set): {unique}")

Output

Click Run to execute your code

Empty Set Gotcha: To create an empty set, you MUST use set(), not {}. Empty curly braces {} create an empty dictionary, not a set! This is one of Python's most common gotchas.

Adding and Removing Elements

Sets are mutable - you can add and remove elements. Use add() for single items, update() for multiple items, and remove() or discard() to delete.

# Set Methods: Adding and Removing Elements

# Starting set
fruits = {"apple", "banana", "cherry"}
print(f"Starting set: {fruits}")
print()

# 1. add() - Add single element
print("=== add(element) ===")
fruits.add("orange")
print(f"After add('orange'): {fruits}")

fruits.add("apple")  # Adding existing item - no effect
print(f"After add('apple') again: {fruits}")
print()

# 2. update() - Add multiple elements from any iterable
print("=== update(iterable) ===")
fruits.update(["mango", "grape"])
print(f"After update(['mango', 'grape']): {fruits}")

fruits.update("AB")  # String becomes individual chars
print(f"After update('AB'): {fruits}")
print()

# 3. remove() - Remove element (raises error if not found)
print("=== remove(element) ===")
fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print(f"After remove('banana'): {fruits}")
# fruits.remove("kiwi")  # KeyError: 'kiwi'
print()

# 4. discard() - Remove element (NO error if not found)
print("=== discard(element) ===")
fruits = {"apple", "banana", "cherry"}
fruits.discard("banana")
print(f"After discard('banana'): {fruits}")
fruits.discard("kiwi")  # No error!
print(f"After discard('kiwi'): {fruits}")
print()

# 5. pop() - Remove and return arbitrary element
print("=== pop() ===")
fruits = {"apple", "banana", "cherry"}
removed = fruits.pop()
print(f"pop() returned: {removed}")
print(f"Set after pop: {fruits}")
print()

# 6. clear() - Remove all elements
print("=== clear() ===")
fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(f"After clear(): {fruits}")
print()

# 7. copy() - Create shallow copy
print("=== copy() ===")
original = {1, 2, 3}
copied = original.copy()
copied.add(4)
print(f"Original: {original}")
print(f"Copy after add(4): {copied}")

Output

Click Run to execute your code

Pro Tip: Use discard() instead of remove() when you're not sure if an element exists. remove() raises a KeyError for missing elements, while discard() silently does nothing.

Set Operations

Sets support mathematical operations: union (|), intersection (&), difference (-), and symmetric difference (^). These are powerful tools for comparing and combining data.

# Set Operations: Union, Intersection, Difference

# Two sets for demonstration
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print(f"Set A: {A}")
print(f"Set B: {B}")
print()

# 1. UNION - All elements from both sets
print("=== UNION (A | B) ===")
print("Elements in A OR B (or both)")
union_method = A.union(B)
union_operator = A | B
print(f"A.union(B): {union_method}")
print(f"A | B: {union_operator}")
print()

# 2. INTERSECTION - Common elements
print("=== INTERSECTION (A & B) ===")
print("Elements in A AND B")
inter_method = A.intersection(B)
inter_operator = A & B
print(f"A.intersection(B): {inter_method}")
print(f"A & B: {inter_operator}")
print()

# 3. DIFFERENCE - Elements in first but not second
print("=== DIFFERENCE (A - B) ===")
print("Elements in A but NOT in B")
diff_method = A.difference(B)
diff_operator = A - B
print(f"A.difference(B): {diff_method}")
print(f"A - B: {diff_operator}")
print()

print("=== DIFFERENCE (B - A) ===")
print("Elements in B but NOT in A")
print(f"B - A: {B - A}")
print()

# 4. SYMMETRIC DIFFERENCE - Elements in either, but not both
print("=== SYMMETRIC DIFFERENCE (A ^ B) ===")
print("Elements in A OR B, but NOT in both")
sym_diff_method = A.symmetric_difference(B)
sym_diff_operator = A ^ B
print(f"A.symmetric_difference(B): {sym_diff_method}")
print(f"A ^ B: {sym_diff_operator}")
print()

# 5. Subset and Superset
print("=== SUBSET & SUPERSET ===")
X = {1, 2, 3}
Y = {1, 2, 3, 4, 5}
print(f"X = {X}")
print(f"Y = {Y}")
print(f"X.issubset(Y): {X.issubset(Y)}")       # X <= Y
print(f"Y.issuperset(X): {Y.issuperset(X)}")   # Y >= X
print(f"X < Y (proper subset): {X < Y}")
print()

# 6. Disjoint - No common elements
print("=== DISJOINT ===")
P = {1, 2, 3}
Q = {4, 5, 6}
print(f"P = {P}, Q = {Q}")
print(f"P.isdisjoint(Q): {P.isdisjoint(Q)}")

Output

Click Run to execute your code

Operators vs Methods: Set operations can use operators (|, &, -, ^) or methods (.union(), .intersection(), etc.). Methods accept any iterable as argument, while operators require both sides to be sets.

Practical Use Cases

Sets excel at removing duplicates, finding common elements, fast membership testing, and comparing datasets. Let's see some real-world examples.

# Practical Set Use Cases

# 1. Remove duplicates from a list
print("=== Remove Duplicates ===")
names = ["Alice", "Bob", "Alice", "Charlie", "Bob", "David"]
unique_names = list(set(names))
print(f"Original: {names}")
print(f"Unique: {unique_names}")
print()

# 2. Find common elements between lists
print("=== Common Elements ===")
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = list(set(list1) & set(list2))
print(f"List 1: {list1}")
print(f"List 2: {list2}")
print(f"Common: {common}")
print()

# 3. Find elements in first list but not second
print("=== Elements Only in First ===")
only_in_first = list(set(list1) - set(list2))
print(f"Only in list1: {only_in_first}")
print()

# 4. Check membership (O(1) vs O(n) for lists)
print("=== Fast Membership Testing ===")
valid_users = {"alice", "bob", "charlie", "david"}
username = "bob"
if username in valid_users:  # O(1) lookup!
    print(f"'{username}' is a valid user")
print()

# 5. Count unique items
print("=== Count Unique Items ===")
text = "hello world"
unique_chars = set(text)
print(f"Text: '{text}'")
print(f"Unique characters: {unique_chars}")
print(f"Count: {len(unique_chars)}")
print()

# 6. Compare two datasets
print("=== Compare Datasets ===")
yesterday_users = {"alice", "bob", "charlie"}
today_users = {"bob", "david", "eve"}

new_users = today_users - yesterday_users
lost_users = yesterday_users - today_users
returning_users = yesterday_users & today_users

print(f"Yesterday: {yesterday_users}")
print(f"Today: {today_users}")
print(f"New today: {new_users}")
print(f"Lost today: {lost_users}")
print(f"Returning: {returning_users}")
print()

# 7. Filter with sets
print("=== Efficient Filtering ===")
all_items = ["apple", "banana", "cherry", "date", "elderberry"]
banned = {"banana", "date"}
allowed = [item for item in all_items if item not in banned]
print(f"All items: {all_items}")
print(f"Banned: {banned}")
print(f"Allowed: {allowed}")

Output

Click Run to execute your code

Common Mistakes

1. Using {} for empty set

# Wrong - creates empty dict, not set!
empty = {}
print(type(empty))  # 

# Correct
empty_set = set()
print(type(empty_set))  #

2. Trying to add mutable items

# Wrong - lists are mutable/unhashable
my_set = {[1, 2, 3]}  # TypeError!

# Correct - use tuples instead
my_set = {(1, 2, 3)}  # Works!
print(my_set)

3. Expecting order in sets

# Wrong assumption
my_set = {3, 1, 2}
first = list(my_set)[0]  # NOT guaranteed to be 3!

# Sets are unordered - don't rely on element order
# Use sorted() if you need order
ordered = sorted(my_set)
print(ordered)  # [1, 2, 3]

4. Using remove() without checking

# Wrong - raises KeyError if not found
my_set = {1, 2, 3}
my_set.remove(5)  # KeyError: 5

# Correct - use discard() or check first
my_set.discard(5)  # No error
# OR
if 5 in my_set:
    my_set.remove(5)

Exercise: Guest List Manager

Task: Manage a party guest list using sets.

Requirements:

Add "David" to the guest list
Try adding "Alice" again (observe what happens)
Remove "Bob" from the list

Output

Click Run to execute your code

Show Solution

guests = {"Alice", "Bob", "Charlie"}

# Add David
guests.add("David")
print(f"After adding David: {guests}")

# Try adding Alice again - no duplicate!
guests.add("Alice")
print(f"After adding Alice again: {guests}")

# Remove Bob
guests.remove("Bob")
print(f"After removing Bob: {guests}")

Summary

Creating: Use {} with items, or set() for empty
Properties: Unordered, no duplicates, only hashable items
Adding: add() single, update() multiple
Removing: remove() (error if missing), discard() (no error)
Union: A | B or A.union(B)
Intersection: A & B or A.intersection(B)
Difference: A - B or A.difference(B)
Best for: Removing duplicates, fast membership testing, comparing datasets

What's Next?

Now let's explore Dictionaries - Python's powerful key-value data structure. Dictionaries let you store and retrieve data using descriptive keys instead of numeric indices!

Previous Tuples

Next Dictionaries

Creating Sets

Adding and Removing Elements

Set Operations

Practical Use Cases

Common Mistakes

1. Using {} for empty set

2. Trying to add mutable items

3. Expecting order in sets

4. Using remove() without checking

Exercise: Guest List Manager

Summary

What's Next?

Enjoying these tutorials?