Eric Campbell 5 min read Python

Python Sets: Operations, Methods, and Use Cases

Sets are unordered collections of unique elements, modeled after mathematical sets. Unlike lists or tuples, sets don't maintain insertion order (prior to Python 3.7) and automatically discard...

Key Insights

  • Sets provide O(1) membership testing compared to O(n) for lists, making them dramatically faster for checking if an element exists in large collections
  • Mathematical set operations (union, intersection, difference) are built directly into Python’s syntax with operators like |, &, and -, making data comparison elegant and efficient
  • Sets automatically eliminate duplicates and are perfect for deduplication, finding unique elements, and implementing tag/category systems where order doesn’t matter

Understanding Python Sets

Sets are unordered collections of unique elements, modeled after mathematical sets. Unlike lists or tuples, sets don’t maintain insertion order (prior to Python 3.7) and automatically discard duplicate values. This makes them ideal when you need to track unique items or perform membership tests at scale.

Use sets when you need fast lookups, want to eliminate duplicates, or need to perform mathematical set operations. Stick with lists when order matters or you need indexing. Use tuples for immutable ordered sequences.

# Creating sets - duplicates are automatically removed
numbers = {1, 2, 3, 3, 4, 4, 5}
print(numbers)  # {1, 2, 3, 4, 5}

# Creating from iterables using set()
from_list = set([1, 2, 2, 3, 3, 3])
from_string = set("hello")
print(from_list)    # {1, 2, 3}
print(from_string)  # {'h', 'e', 'l', 'o'}

# Empty set requires set() - {} creates an empty dict
empty = set()

Mathematical Set Operations

Python implements standard mathematical set operations both as operators and methods. The operator syntax is cleaner for simple operations, while methods offer more flexibility for chaining or working with multiple sets.

# Sample data: users who completed different courses
python_users = {'alice', 'bob', 'charlie', 'diana'}
javascript_users = {'bob', 'diana', 'eve', 'frank'}

# Union (|) - all users who took either course
all_users = python_users | javascript_users
# or: all_users = python_users.union(javascript_users)
print(all_users)  # {'alice', 'bob', 'charlie', 'diana', 'eve', 'frank'}

# Intersection (&) - users who took both courses
both_courses = python_users & javascript_users
# or: both_courses = python_users.intersection(javascript_users)
print(both_courses)  # {'bob', 'diana'}

# Difference (-) - users who took Python but not JavaScript
python_only = python_users - javascript_users
# or: python_only = python_users.difference(javascript_users)
print(python_only)  # {'alice', 'charlie'}

# Symmetric difference (^) - users who took exactly one course
exclusive = python_users ^ javascript_users
# or: exclusive = python_users.symmetric_difference(javascript_users)
print(exclusive)  # {'alice', 'charlie', 'eve', 'frank'}

The method versions accept any iterable, not just sets, which provides more flexibility:

users = {'alice', 'bob', 'charlie'}
# This works - list is converted automatically
combined = users.union(['diana', 'eve'])
print(combined)  # {'alice', 'bob', 'charlie', 'diana', 'eve'}

Essential Set Methods

Sets provide methods for modification and querying that make them powerful for data manipulation.

tags = {'python', 'coding', 'tutorial'}

# Adding elements
tags.add('beginner')
print(tags)  # {'python', 'coding', 'tutorial', 'beginner'}

# Adding multiple elements
tags.update(['web', 'backend', 'python'])  # duplicate 'python' ignored
print(tags)  # {'python', 'coding', 'tutorial', 'beginner', 'web', 'backend'}

# Removing elements
tags.remove('beginner')  # raises KeyError if not found
tags.discard('advanced')  # no error if not found - safer
removed = tags.pop()  # removes and returns arbitrary element

# Querying relationships
web_tags = {'web', 'frontend'}
backend_tags = {'python', 'coding', 'backend'}

print(web_tags.issubset(tags))  # False
print(tags.issuperset(backend_tags))  # True
print(web_tags.isdisjoint(backend_tags))  # True - no common elements

The difference between remove() and discard() is critical: use discard() when you’re not sure if an element exists and don’t want to handle exceptions.

Set Comprehensions

Like list comprehensions, set comprehensions provide a concise way to create sets with filtering and transformation logic.

# Extract unique word lengths from a sentence
sentence = "the quick brown fox jumps over the lazy dog"
word_lengths = {len(word) for word in sentence.split()}
print(word_lengths)  # {3, 4, 5}

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

# Extract unique domains from email list
emails = ['user@example.com', 'admin@test.org', 'info@example.com']
domains = {email.split('@')[1] for email in emails}
print(domains)  # {'example.com', 'test.org'}

# Compare to list comprehension - set automatically deduplicates
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_list = list(set([x for x in numbers]))  # two steps
unique_set = {x for x in numbers}  # one step, cleaner

Real-World Use Cases

Sets excel in scenarios where uniqueness and fast membership testing matter more than order or indexing.

Deduplication

# Remove duplicates while preserving unique items
user_ids = [101, 102, 103, 102, 104, 101, 105]
unique_ids = list(set(user_ids))  # [101, 102, 103, 104, 105]

# Deduplicate while preserving order (Python 3.7+)
from collections import OrderedDict
ordered_unique = list(dict.fromkeys(user_ids))

Log Analysis

# Find unique visitors from access logs
access_log = [
    {'ip': '192.168.1.1', 'path': '/home'},
    {'ip': '192.168.1.2', 'path': '/about'},
    {'ip': '192.168.1.1', 'path': '/contact'},
    {'ip': '192.168.1.3', 'path': '/home'},
]

unique_visitors = {entry['ip'] for entry in access_log}
print(f"Unique visitors: {len(unique_visitors)}")  # 3

# Find pages visited by a specific user
user_pages = {entry['path'] for entry in access_log 
              if entry['ip'] == '192.168.1.1'}
print(user_pages)  # {'/home', '/contact'}

Tag Matching Systems

# Content recommendation based on tag overlap
article_tags = {
    'post1': {'python', 'web', 'backend', 'tutorial'},
    'post2': {'javascript', 'web', 'frontend'},
    'post3': {'python', 'data-science', 'tutorial'},
}

user_interests = {'python', 'tutorial', 'backend'}

# Find articles matching user interests
for article, tags in article_tags.items():
    overlap = tags & user_interests
    if overlap:
        score = len(overlap) / len(user_interests)
        print(f"{article}: {score:.1%} match - {overlap}")

# Output:
# post1: 100.0% match - {'python', 'backend', 'tutorial'}
# post3: 66.7% match - {'python', 'tutorial'}

Fast Membership Testing

import time

# Benchmark: set vs list for membership testing
data_size = 100000
test_list = list(range(data_size))
test_set = set(range(data_size))
search_value = data_size - 1  # worst case for list

# List lookup - O(n)
start = time.perf_counter()
result = search_value in test_list
list_time = time.perf_counter() - start

# Set lookup - O(1)
start = time.perf_counter()
result = search_value in test_set
set_time = time.perf_counter() - start

print(f"List lookup: {list_time*1000:.4f}ms")
print(f"Set lookup: {set_time*1000:.4f}ms")
print(f"Set is {list_time/set_time:.0f}x faster")

On typical hardware with 100,000 elements, sets are 1000x+ faster for membership testing.

Performance Considerations

Sets use hash tables internally, providing average O(1) time complexity for add, remove, and membership tests. Lists require O(n) for membership tests and O(n) for removal of arbitrary elements.

The trade-off is memory: sets consume more memory than lists due to hash table overhead. They also require elements to be hashable (immutable types like strings, numbers, tuples).

# This works
valid_set = {1, 'hello', (1, 2), 3.14}

# This fails - lists aren't hashable
try:
    invalid_set = {[1, 2, 3]}
except TypeError as e:
    print(f"Error: {e}")  # unhashable type: 'list'

Use sets when membership testing frequency justifies the memory cost. For small collections (< 100 items), the performance difference is negligible.

Frozensets and Immutability

Frozensets are immutable versions of sets, useful when you need hashable set objects for use as dictionary keys or elements of other sets.

# Frozensets as dictionary keys
user_permissions = {
    frozenset(['read', 'write']): 'editor',
    frozenset(['read']): 'viewer',
    frozenset(['read', 'write', 'delete']): 'admin',
}

current_perms = frozenset(['read', 'write'])
print(user_permissions[current_perms])  # 'editor'

# Nested set structures
departments = {
    frozenset(['alice', 'bob']): 'engineering',
    frozenset(['charlie', 'diana']): 'marketing',
}

# Frozensets support the same query operations
team1 = frozenset(['alice', 'bob', 'charlie'])
team2 = frozenset(['bob', 'charlie', 'diana'])
print(team1 & team2)  # frozenset({'bob', 'charlie'})

Frozensets cannot be modified after creation—no add(), remove(), or update() methods. This immutability makes them safe for use as dictionary keys and enables caching optimizations.

Choose sets for most use cases involving unique collections. Reach for frozensets when you need immutability or must use sets as dictionary keys. Master set operations and your Python code will become more expressive and performant.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.