Python set comprehension is a concise way to build a set from an iterable. It looks similar to list comprehension, but it uses curly braces and returns a set, so duplicate values are removed automatically. Use it when you want unique results from a transformation or filter.
The general pattern is {expression for item in iterable if condition}. The condition is optional. Python's reference documentation for list, set, and dictionary displays defines this syntax, and the Python tutorial on sets explains the uniqueness behavior. The main tradeoff is simple: set comprehension is compact and removes duplicates, but it should not be used when output order is the most important requirement.
Basic Set Comprehension Syntax
A set comprehension evaluates an expression for each item in an iterable. The result is a set, not a list, so the display order is not something your program should depend on.
numbers = range(6)
squares = {number * number for number in numbers}
print(squares)
This creates a set of square values. If two input values produce the same output, the set keeps only one copy. That automatic deduplication is the main reason to choose a set comprehension over a list comprehension.
Use Conditions in Set Comprehension
Add an if clause when you only want some values from the input. The condition is evaluated before the expression is added to the set.
even_squares = {
number * number
for number in range(10)
if number % 2 == 0
}
print(even_squares)
This keeps only even numbers before squaring them. A condition can check membership, string content, numeric ranges, or any other expression that returns True or False. Conditions are especially useful when the source data contains placeholders, blanks, or values outside the range you want to keep.
Remove Duplicates While Transforming Values
Set comprehension is useful when you need to normalize values and remove duplicates at the same time. For strings, combine strip() and lower() with a filter.
names = [" Ada ", "ada", "Lin", "LIN", ""]
clean_names = {
name.strip().lower()
for name in names
if name.strip()
}
print(clean_names)
This example keeps one normalized version of each name. For more on lowercase cleanup, see Python lowercase string handling.
Set Comprehension With Math Expressions
The expression part can contain calculations or function calls. This is useful for building derived numeric sets without writing a separate loop.
distances = [-3, -2, -1, 0, 1, 2, 3]
absolute_values = {abs(value) for value in distances}
print(absolute_values)
The output contains unique absolute values because -3 and 3 both become 3. This behavior is different from a list, which would keep both transformed entries. It is also useful when you only care whether a result exists, not how many times it appeared.
Nested Set Comprehension
A set comprehension can use more than one for clause. This is helpful for combinations, coordinates, or flattening small nested inputs.
rows = [1, 2]
columns = ["A", "B", "C"]
cells = {f"{column}{row}" for row in rows for column in columns}
print(cells)
Keep nested comprehensions short. If the expression becomes hard to scan, a normal loop is easier to maintain. For nested mapping structures, see nested dictionaries in Python.
Set Comprehension vs List Comprehension
Use list comprehension when order and duplicates matter. Use set comprehension when uniqueness matters more than order. The syntax differs only by brackets: square brackets make a list, and curly braces make a set.
values = [1, 1, 2, 2, 3]
as_list = [value * 2 for value in values]
as_set = {value * 2 for value in values}
print(as_list)
print(as_set)
The list keeps repeated values, while the set removes duplicates. If you are moving between list and set representations, the guide to convert a list to a set in Python covers the direct conversion.
Common Mistakes
The most common mistake is expecting a set comprehension to keep insertion order like a list. A set is designed for uniqueness and membership tests. Another mistake is using unhashable values such as lists or dictionaries as set items. If you need unique dictionaries, track a hashable key instead.
Also avoid confusing a set comprehension with a dictionary comprehension. Both use curly braces. A dictionary comprehension has a key-value expression such as {key: value for item in items}. A set comprehension has only one output expression. For dictionary-related memory topics, see Python dictionary size.
Where Set Comprehension Helps
Set comprehension is useful for tags, normalized usernames, unique IDs, file extensions, and membership checks. It is also a good companion to list union work when you need unique values from several collections; see Python union of lists for that pattern. For generator-like syntax around tuples, PythonPool also has a guide to tuple comprehension.
Use a normal loop when the transformation needs several steps, logging, exception handling, or comments. Comprehensions are best when the expression is short enough to understand at a glance. Readability matters more than compressing every loop into one line.
Conclusion
Use Python set comprehension when you want to transform or filter values and keep only unique results. The syntax is compact, but the result is still a set: order is not the main feature, and every item must be hashable. For ordered output or duplicate-preserving output, use a list comprehension instead.