3.6 Python Sets: A Comprehensive Guide

Python sets are a powerful built-in data type designed to store unordered collections of unique elements. They are highly efficient for tasks requiring duplicate elimination and performing mathematical set operations.

Key Properties of Sets

• Unordered: Elements within a set do not maintain a specific order. The position of an element is not guaranteed.
• Unique Elements: Sets automatically discard any duplicate values. Each element in a set must be distinct.
• Mutable: Sets are mutable, meaning you can add or remove elements after the set has been created.
• Heterogeneous (with immutable elements): Sets can contain elements of different data types, but all elements must be immutable (e.g., numbers, strings, tuples). Mutable elements like lists or dictionaries cannot be included in a set.

# Example of a heterogeneous set
my_set = {1, "Python", (2, 3)}
print(my_set)

{1, 'Python', (2, 3)}

Creating Sets

There are two primary ways to create sets in Python:

1. Using Curly Braces {}

Enclose elements within curly braces, separated by commas.

# Creating a set using curly braces
my_set = {10, 20, 30, 40}
print(my_set)

{10, 20, 30, 40}

Important Note: To create an empty set, you must use set(). Using {} creates an empty dictionary.

# Incorrect way to create an empty set
empty_dict = {}
print(type(empty_dict))

# Correct way to create an empty set
empty_set = set()
print(type(empty_set))

<class 'dict'>
<class 'set'>

2. Using the set() Constructor

The set() constructor can be used with any iterable (like lists, tuples, or strings) to create a set.

# Creating a set from a list
my_list = [10, 20, 30, 40, 20] # Note the duplicate '20'
my_set_from_list = set(my_list)
print(my_set_from_list)

# Creating a set from a tuple
my_tuple = (5, 10, 15, 10)
my_set_from_tuple = set(my_tuple)
print(my_set_from_tuple)

# Creating a set from a string
my_string = "hello"
my_set_from_string = set(my_string)
print(my_set_from_string)

{40, 10, 20, 30}
{5, 10, 15}
{'o', 'l', 'h', 'e'}

Duplicate Removal

As a key feature, sets automatically handle duplicate elements. When you create a set with repeated values, only one instance of each value is stored.

# Demonstrating duplicate removal
my_set = {1, 1, 2, 2, 3, 4, 3}
print(my_set)

{1, 2, 3, 4}

Modifying Sets: Adding and Removing Elements

Adding Elements

• add(element): Adds a single element to the set. If the element is already present, the set remains unchanged.

  my_set = {1, 2, 3}
  my_set.add(4)
  print(my_set)
  
  my_set.add(2) # Adding an existing element
  print(my_set)

  {1, 2, 3, 4}
  {1, 2, 3, 4}

• update(iterable): Adds multiple elements from an iterable (like a list or another set) to the set.

  my_set = {1, 2, 3}
  another_list = [3, 4, 5]
  my_set.update(another_list)
  print(my_set)
  
  another_set = {5, 6, 7}
  my_set.update(another_set)
  print(my_set)

  {1, 2, 3, 4, 5}
  {1, 2, 3, 4, 5, 6, 7}

Removing Elements

• remove(element): Removes a specific element from the set. If the element is not found in the set, it raises a KeyError.

  my_set = {1, 2, 3, 4}
  my_set.remove(2)
  print(my_set)
  
  # This will raise a KeyError:
  # my_set.remove(5)

  {1, 3, 4}

• discard(element): Removes an element from the set if it is present. If the element is not found, it does nothing and does not raise an error. This is often preferred when you're not certain if an element exists.

  my_set = {1, 2, 3, 4}
  my_set.discard(3)
  print(my_set)
  
  my_set.discard(5) # Element 5 is not present, no error is raised
  print(my_set)

  {1, 2, 4}
  {1, 2, 4}

• pop(): Removes and returns an arbitrary element from the set. Since sets are unordered, you don't know which element will be removed. It raises a KeyError if the set is empty.

  my_set = {10, 20, 30, 40}
  removed_element = my_set.pop()
  print(f"Removed element: {removed_element}")
  print(f"Set after pop: {my_set}")

  Removed element: 10
  Set after pop: {20, 30, 40}

• clear(): Removes all elements from the set, making it empty.

  my_set = {1, 2, 3}
  my_set.clear()
  print(my_set)

  set()

Membership Testing

You can efficiently check if an element is present in a set using the in keyword.

my_set = {10, 20, 30}

if 20 in my_set:
    print("20 is in the set.")
else:
    print("20 is not in the set.")

if 50 in my_set:
    print("50 is in the set.")
else:
    print("50 is not in the set.")

20 is in the set.
50 is not in the set.

Set Operations

Python sets support standard mathematical set operations, which can be performed using either methods or operators.

Example:

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

print(f"Union (a \| b): {a | b}")
print(f"Intersection (a & b): {a & b}")
print(f"Difference (a - b): {a - b}")
print(f"Symmetric Difference (a ^ b): {a ^ b}")

print(f"Union (a.union(b)): {a.union(b)}")
print(f"Intersection (a.intersection(b)): {a.intersection(b)}")
print(f"Difference (a.difference(b)): {a.difference(b)}")
print(f"Symmetric Difference (a.symmetric_difference(b)): {a.symmetric_difference(b)}")

Union (a | b): {1, 2, 3, 4, 5, 6}
Intersection (a & b): {3, 4}
Difference (a - b): {1, 2}
Symmetric Difference (a ^ b): {1, 2, 5, 6}
Union (a.union(b)): {1, 2, 3, 4, 5, 6}
Intersection (a.intersection(b)): {3, 4}
Difference (a.difference(b)): {1, 2}
Symmetric Difference (a.symmetric_difference(b)): {1, 2, 5, 6}

Set Comprehension

Set comprehensions provide a concise way to create sets based on existing iterables, similar to list comprehensions.

Syntax:

{expression for item in iterable if condition}

Example 1: Squares of numbers 1 to 5

squares = {x**2 for x in range(1, 6)}
print(squares)

{1, 4, 9, 16, 25}

Example 2: Even numbers from 1 to 10

evens = {x for x in range(1, 11) if x % 2 == 0}
print(evens)

{2, 4, 6, 8, 10}

Example 3: Nested Set Comprehension (creating pairs)

nested = {(x, y) for x in range(2) for y in range(2)}
print(nested)

{(0, 1), (1, 0), (1, 1), (0, 0)}

Frozen Sets

A frozenset is an immutable version of a set. Once created, you cannot add, remove, or change its elements. This makes them useful in situations where you need a set to remain constant, such as dictionary keys or for ensuring data integrity.

Creating a Frozen Set

Use the frozenset() constructor.

frozen_set = frozenset([10, 20, 30])
print(frozen_set)
print(type(frozen_set))

frozenset({10, 20, 30})
<class 'frozenset'>

Immutability of Frozen Sets

Attempting to modify a frozenset will result in an AttributeError.

# Attempting to add an element to a frozenset
try:
    frozen_set.add(40)
except AttributeError as e:
    print(f"Error: {e}")

Error: 'frozenset' object has no attribute 'add'

When to Use Sets

• Removing duplicates: When you need a collection of unique items from a larger, possibly duplicate-filled collection.
• Membership testing: Quickly checking for the presence or absence of an item.
• Set theory operations: Performing unions, intersections, differences, etc., on collections of data.
• Unordered data: When the order of elements is not important.
• Immutable collections: When you need a collection of unique items that cannot be changed (use frozenset).

Sets offer significant performance advantages for these specific tasks compared to lists or tuples.