Python - Sets

Sets in Python

Sets in Python are one of the most important and efficient data types used for storing multiple unique values. They are mutable and unordered collections with no duplicate elements. Sets are widely used in operations involving mathematical sets like union, intersection, difference, and symmetric difference. Due to their performance efficiency, sets are extremely useful in scenarios involving membership testing and eliminating duplicate values. This tutorial provides a comprehensive and detailed look into Python sets, their features, methods, and best practices.

Introduction to Sets

What is a Set?

A set is a built-in data type in Python that allows you to store a collection of unordered, unique items. Unlike lists and tuples, sets do not allow duplicate elements. Sets are defined using curly braces {} or the set() constructor.

Why Use Sets?

• To eliminate duplicate values from a collection
• To perform efficient membership tests
• To execute mathematical operations such as union and intersection
• To compare and manage distinct datasets

Creating Sets

Using Curly Braces

fruits = {"apple", "banana", "cherry"}

Using the set() Constructor

numbers = set([1, 2, 3, 4])

Creating an Empty Set

Using set() is the correct way to create an empty set, not {} which creates an empty dictionary.

empty_set = set()

Characteristics of Sets

1. Unordered

Items do not maintain insertion order. Their order may appear random.

2. Unique Elements

Each element is distinct and duplicates are automatically removed.

3. Mutable

You can add or remove items after creation. However, the elements themselves must be immutable (e.g., no lists or dictionaries as set items).

Accessing Set Elements

Set elements are not accessible by index. You can loop through the set or convert it to a list to access elements by position.

for fruit in fruits:
    print(fruit)

fruit_list = list(fruits)
print(fruit_list[0])

Modifying Sets

Adding Items

fruits.add("orange")

Adding Multiple Items

fruits.update(["mango", "grape"])

Removing Items

Using remove() - raises error if item not found

fruits.remove("banana")

Using discard() - does nothing if item not found

fruits.discard("banana")

Removing Arbitrary Item

fruits.pop()

Clearing the Set

fruits.clear()

Set Operations

Union

Combines all unique elements from both sets

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # {1, 2, 3, 4, 5}

Intersection

Returns only elements present in both sets

print(a & b)  # {3}

Difference

Returns items in the first set but not in the second

print(a - b)  # {1, 2}

Symmetric Difference

Returns items in either set but not both

print(a ^ b)  # {1, 2, 4, 5}

Set Comparison

Subset and Superset

x = {1, 2}
y = {1, 2, 3}

print(x.issubset(y))   # True
print(y.issuperset(x)) # True

Disjoint Sets

x = {1, 2}
y = {3, 4}
print(x.isdisjoint(y))  # True

Built-in Set Methods

• add()
• update()
• remove()
• discard()
• pop()
• clear()
• union()
• intersection()
• difference()
• symmetric_difference()
• issubset()
• issuperset()
• isdisjoint()
• copy()

Frozen Sets

What is a frozenset?

A frozenset is an immutable version of a set. You cannot add or remove elements from a frozenset after creation.

fs = frozenset([1, 2, 3])

Useful when you need a set that should not change, or when using a set as a dictionary key.

Practical Use Cases

1. Removing Duplicates from a List

names = ["Alice", "Bob", "Alice", "Eve"]
unique_names = list(set(names))

2. Fast Membership Testing

primes = {2, 3, 5, 7, 11}
print(7 in primes)  # True

3. Set Algebra

students_class1 = {"Alice", "Bob", "Charlie"}
students_class2 = {"Bob", "David", "Edward"}
common_students = students_class1.intersection(students_class2)

4. Detecting Uniqueness

def all_unique(items):
    return len(items) == len(set(items))

print(all_unique([1, 2, 3]))  # True
print(all_unique([1, 2, 2]))  # False

Performance Considerations

• Set operations like in are faster than lists for large datasets
• Sets are highly optimized for membership testing
• They use hash tables internally, providing constant time complexity O(1) for adds and checks

Best Practices

• Use sets to eliminate duplicates
• Use set operations for clean and readable code
• Convert set back to list if ordering is needed
• Use frozenset for immutability where required
• Avoid storing mutable elements inside sets

Common Mistakes

• Assuming sets maintain order
• Trying to access set items by index
• Using {} to create an empty set (creates dict instead)
• Trying to store unhashable items (like lists) inside sets

Differences: Set vs List vs Tuple

Sets are a fundamental and powerful data structure in Python. They provide an efficient, expressive, and elegant way to store and manipulate unique data. With operations such as union, intersection, and difference, Python sets allow for elegant mathematical set handling. Whether you're checking for unique elements, performing fast membership tests, or eliminating duplicates, Python sets offer the perfect tool. Additionally, when immutability is needed, frozenset ensures data consistency. By understanding and using sets correctly, you can write better, cleaner, and more efficient Python code.