How to make a set in Python

Python sets provide a powerful way to store unique, unordered collections of items. These built-in data structures enable efficient membership testing, mathematical operations, and duplicate elimination through methods like add(), remove(), and intersection().

This guide covers essential techniques for working with sets, practical applications, and debugging tips. All code examples were created with Claude, an AI assistant built by Anthropic.

Creating a simple set

fruits = {"apple", "banana", "cherry"}
print(fruits)
print(type(fruits))

{'cherry', 'banana', 'apple'}
<class 'set'>

The code demonstrates two key approaches to creating Python sets. The curly brace syntax {} offers a more concise way to define sets compared to using the set() constructor. This literal notation mirrors how developers write mathematical sets, making the code more intuitive and readable.

The output reveals important characteristics of Python sets:

• Elements appear in an arbitrary order, highlighting the unordered nature of sets
• Python automatically handles duplicate removal during set creation
• The type() function confirms the data structure is a native set object

Basic set creation and modification

Building on these fundamentals, Python sets support flexible creation from existing data structures and offer intuitive methods like add() and remove() for modifying set contents.

Creating sets from other data structures

numbers_list = [1, 2, 2, 3, 4, 4, 5]
numbers_set = set(numbers_list)
print("Original list:", numbers_list)
print("Set from list:", numbers_set)

Original list: [1, 2, 2, 3, 4, 4, 5]
Set from list: {1, 2, 3, 4, 5}

The set() constructor efficiently transforms any iterable data structure into a set. In this example, it converts a list containing duplicate numbers into a set with unique values.

• Python automatically removes duplicate values (2 and 4) during the conversion process
• The original order isn't preserved since sets are unordered by design
• The set() constructor works with other iterables too including tuples, strings, and dictionaries

This conversion pattern proves especially useful when you need to quickly eliminate duplicates from existing collections or perform set operations on your data. The set() constructor handles all the complexity of duplicate removal and data structure conversion internally.

Adding elements with add() and update()

colors = {"red", "green"}
colors.add("blue")
colors.update(["yellow", "orange"])
print(colors)

{'red', 'blue', 'yellow', 'orange', 'green'}

Python sets provide two primary methods for adding elements. The add() method inserts a single item, while update() lets you add multiple elements at once from any iterable like lists or tuples.

• Use add() for inserting individual elements. The code example shows this with colors.add("blue")
• Choose update() when you need to add multiple items simultaneously. The example demonstrates this by adding both "yellow" and "orange" in one operation
• Both methods automatically handle duplicates. If you try to add an element that already exists in the set, Python simply ignores it

These methods maintain the set's core property of storing only unique values while offering flexible ways to expand your data collection.

Removing elements with remove(), discard(), and pop()

animals = {"dog", "cat", "bird", "fish"}
animals.remove("bird")
animals.discard("elephant")
popped = animals.pop()
print("After modifications:", animals)
print("Popped element:", popped)

After modifications: {'cat', 'dog'}
Popped element: fish

Python offers three distinct methods to remove elements from sets. Each serves a specific purpose and handles errors differently.

• The remove() method deletes a specific element. It raises a KeyError if the element doesn't exist in the set
• Use discard() when you want to safely remove an element without raising errors. The code shows this by attempting to remove "elephant" which doesn't exist in the set
• The pop() method removes and returns an arbitrary element from the set. Since sets are unordered, you can't predict which element it will remove

In the example, remove() deletes "bird", discard() safely attempts to remove a non-existent "elephant", and pop() removes "fish". The final set contains only "cat" and "dog".

Advanced set techniques and operations

Building on these foundational set operations, Python provides advanced techniques like set comprehensions, immutable frozenset objects, and mathematical operators that enable sophisticated data manipulation and analysis.

Using set comprehensions

squares = {x**2 for x in range(1, 6)}
even_squares = {x**2 for x in range(1, 11) if x % 2 == 0}
print("Squares:", squares)
print("Even squares:", even_squares)

Squares: {1, 4, 9, 16, 25}
Even squares: {4, 16, 36, 64, 100}

Set comprehensions provide a concise way to create sets using a single line of code. The syntax mirrors list comprehensions but uses curly braces instead of square brackets.

• The first example {x**2 for x in range(1, 6)} creates a set of squared numbers from 1 to 5
• The second example adds a conditional statement if x % 2 == 0 to filter for even numbers only
• Python evaluates the expression x**2 for each value that meets the conditions

Set comprehensions automatically handle duplicate removal. They excel at creating sets from mathematical sequences or filtered data. This makes them particularly useful for data transformation and mathematical operations where uniqueness matters.

Working with immutable frozenset

regular_set = {"a", "b", "c"}
frozen = frozenset(regular_set)
print(frozen)
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([3, 4, 5])
print(fs1.intersection(fs2))

frozenset({'c', 'b', 'a'})
frozenset({3})

The frozenset creates an immutable version of a regular set. Once created, you can't modify its contents. This immutability makes frozenset objects perfect for use as dictionary keys or elements within other sets.

• The code converts a regular set of letters into a frozenset using the frozenset() constructor
• Despite being immutable, frozenset objects support all non-modifying set operations like intersection()
• The example demonstrates this by finding the common element (3) between two frozenset objects

Think of a frozenset as a read-only snapshot of your data. It preserves the uniqueness property of sets while preventing accidental modifications that could break your program's logic.

Set operations with operators

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
print("Union:", set_a | set_b)
print("Intersection:", set_a & set_b)
print("Difference (A-B):", set_a - set_b)
print("Symmetric difference:", set_a ^ set_b)

Union: {1, 2, 3, 4, 5, 6, 7, 8}
Intersection: {4, 5}
Difference (A-B): {1, 2, 3}
Symmetric difference: {1, 2, 3, 6, 7, 8}

Python sets support mathematical operations through intuitive operators that mirror standard set theory notation. The vertical bar | creates a union containing all unique elements from both sets. The ampersand & finds common elements through intersection.

• The minus operator - returns elements present in the first set but not in the second
• Use the caret ^ for symmetric difference. This operation returns elements present in either set but not in both
• These operators provide a more readable alternative to method calls like union() or intersection()

The example demonstrates how two overlapping sets {1, 2, 3, 4, 5} and {4, 5, 6, 7, 8} combine and compare through these operators. Python automatically handles the complexity of set operations while maintaining uniqueness in the results.

Finding unique words in text processing

Python sets excel at extracting unique elements from text data through the set() constructor and split() method, enabling efficient word frequency analysis and duplicate removal in natural language processing tasks.

text = "to be or not to be that is the question"
words = text.split()
unique_words = set(words)
print("Original text:", text)
print("Unique words:", unique_words)
print(f"Word count: {len(words)}, Unique word count: {len(unique_words)}")

This code demonstrates efficient text analysis using Python's string and set operations. The split() function first breaks the input text into a list of individual words. Converting this list to a set with set(words) automatically removes any duplicate words while preserving unique ones.

• The len(words) shows the total count of words including duplicates
• The len(unique_words) reveals how many distinct words appear in the text
• The f-string provides a clean way to display both counts in a single line

This pattern proves especially valuable when analyzing larger texts where manual duplicate tracking becomes impractical. The set's automatic deduplication handles all the complexity behind the scenes.

Finding common friends with intersection() in social networks

The intersection() method efficiently identifies mutual connections between social network users by finding common elements between friend sets, enabling features like friend suggestions and shared connection analysis.

user1_friends = {"Alice", "Bob", "Charlie", "David", "Eve"}
user2_friends = {"Bob", "Charlie", "Frank", "Grace", "Heidi"}
common_friends = user1_friends.intersection(user2_friends)
unique_to_user1 = user1_friends - user2_friends
print(f"Common friends: {common_friends}")
print(f"Friends unique to User 1: {unique_to_user1}")
print(f"Total unique friends: {user1_friends | user2_friends}")

This code demonstrates three key set operations for analyzing relationships between two friend groups. The intersection() method finds mutual friends "Bob" and "Charlie" that both users share. The subtraction operator - identifies friends exclusive to the first user. Finally, the union operator | combines both friend lists into a single set of all unique friends.

• The intersection() reveals overlapping connections
• The subtraction shows who only User 1 knows
• The union provides a complete network view without duplicates

These operations efficiently process friend relationships while automatically handling duplicate names and maintaining data uniqueness.

Common errors and challenges

Python sets can trigger specific errors during common operations like iteration, type handling, and indexing. Understanding these challenges helps you write more reliable code.

Avoiding RuntimeError when modifying a set during iteration

Modifying a set while iterating through it can trigger a RuntimeError. This common pitfall occurs when you try to change set contents using methods like remove() or add() during a for loop. The following code demonstrates this error in action.

numbers = {1, 2, 3, 4, 5}
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # This causes RuntimeError
print(numbers)

Python's set iterator expects the collection to remain stable during iteration. When remove() deletes elements mid-loop, it disrupts this stability and triggers the error. Let's examine a safer approach in the code below.

numbers = {1, 2, 3, 4, 5}
numbers_to_remove = {num for num in numbers if num % 2 == 0}
numbers -= numbers_to_remove
print(numbers)

The solution creates a separate set using a set comprehension to identify elements for removal first. Then it uses the subtraction operator -= to modify the original set in one clean operation. This approach avoids the RuntimeError by preventing direct modification during iteration.

• Watch for this error when filtering or modifying sets based on their contents
• The pattern applies to any situation where you need to remove multiple elements based on a condition
• Consider using set comprehensions or temporary collections when you need to modify sets based on their current contents

Handling unhashable types in sets with TypeError

Python sets require all elements to be hashable, meaning they have a consistent hash value that never changes. When you try to add mutable objects like lists or dictionaries to a set, Python raises a TypeError. The following code demonstrates this common pitfall.

my_set = {1, 2, 3}
my_set.add([4, 5, 6])  # Lists are unhashable - TypeError
print(my_set)

Lists contain multiple values that can change over time. This mutability makes them incompatible with Python's hashing system, which requires stable values. The code below demonstrates the proper approach to handle this scenario.

my_set = {1, 2, 3}
my_set.update([4, 5, 6])  # update() adds individual elements
print(my_set)

The update() method provides a safer way to add multiple elements to a set. Instead of trying to insert an entire list as a single element, it adds each item individually. This approach avoids the TypeError that occurs when attempting to add unhashable types like lists or dictionaries.

• Watch for this error when working with complex data structures like lists of lists or nested dictionaries
• Remember that sets can only contain immutable elements like numbers, strings, or tuples
• Consider converting mutable objects to immutable ones before adding them to sets

When designing data structures that use sets, plan ahead for the types of elements you'll store. This prevents runtime errors and maintains data integrity throughout your program's execution.

Remembering that sets can't be accessed with index notation

Unlike lists or tuples, Python sets don't support index-based access with square bracket notation []. Attempting to retrieve elements by position triggers a TypeError. The code below demonstrates this common mistake when developers try accessing set elements like they would with ordered sequences.

fruits = {"apple", "banana", "cherry"}
print(fruits[0])  # TypeError: 'set' object is not subscriptable

Sets store elements in an arbitrary order that can change between program runs. When you try to access elements with an index like fruits[0], Python can't determine which element should be "first." The following code demonstrates the proper way to work with set elements.

fruits = {"apple", "banana", "cherry"}
fruits_list = list(fruits)
print(fruits_list[0])  # Convert to list for indexing

Converting a set to a list with list(fruits) provides a simple workaround when you need index-based access to elements. This approach creates an ordered sequence that supports traditional indexing while preserving the original set's unique values.

• Watch for this error when porting code from lists to sets
• Remember that sets prioritize uniqueness and membership testing over ordered access
• Consider whether you truly need index-based access. Sets excel at different operations like checking if elements exist or removing duplicates

If your code frequently needs both unique values and ordered access, maintain parallel data structures. Keep the set for uniqueness operations and a separate list for indexed lookups.