> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Set Comprehension
A set comprehension is a concise syntactic construct in Python used to generate a new `set` object by evaluating an expression for each item in an iterable. It combines the mechanics of a `for` loop and optional conditional filtering into a single expression enclosed in curly braces `{}`, automatically enforcing set properties such as the uniqueness of elements.
## Basic Syntax and Execution
The fundamental structure evaluates an expression for every item in an iterable. The absence of a key-value colon (`:`) in the expression differentiates a set comprehension from a dictionary comprehension.
```python theme={"dark"}
# Syntax: {expression for item in iterable}
numbers = [1, 2, 2, 3, 4, 4, 5]
squared_set = {x**2 for x in numbers}
print(squared_set)
# Output: {1, 4, 9, 16, 25} (Note: sets are unordered, output order may vary)
```
## Conditional Filtering
You can append an `if` clause to filter which items from the iterable are processed. The `expression` is only evaluated and added to the set if the `condition` evaluates to `True`.
```python theme={"dark"}
# Syntax: {expression for item in iterable if condition}
numbers = [1, 2, 3, 4, 5, 6]
even_squared_set = {x**2 for x in numbers if x % 2 == 0}
print(even_squared_set)
# Output: {16, 4, 36}
```
## Components
* **`expression`**: The operation or value to be evaluated and inserted into the resulting set. This expression must evaluate to a **hashable** type.
* **`item`**: The target variable representing the current element yielded by the iterable during iteration.
* **`iterable`**: Any Python object capable of returning its members one at a time (e.g., lists, tuples, generators, strings).
* **`condition`** *(Optional)*: A boolean expression acting as a filter.
## Behavioral Characteristics
1. **Automatic Deduplication**: Because the output is a standard Python `set`, if the `expression` evaluates to the same value for multiple items in the iterable, the resulting set will only contain a single instance of that value.
```python theme={"dark"}
chars = ['a', 'b', 'a', 'c', 'b']
unique_chars = {char.upper() for char in chars}
print(unique_chars)
# Output: {'A', 'C', 'B'}
```
2. **Hashability Requirement**: Sets are implemented using hash tables. Therefore, the output of the `expression` must be hashable (e.g., integers, strings, tuples). If the expression yields an unhashable type (like a list or dictionary), Python will raise a `TypeError`.
3. **Lack of Ordering**: The resulting set is an unordered collection. It does not preserve the iteration order of the original `iterable`.
## Advanced Syntax Variations
Set comprehensions support nested loops and inline conditional expressions (ternary operators).
**Nested Iteration:**
You can iterate over multiple iterables within the same comprehension. The evaluation order is equivalent to nested `for` loops, reading from left to right.
```python theme={"dark"}
# Syntax: {expression for item_a in iterable_a for item_b in iterable_b}
matrix = [[1, 2], [1, 3], [2, 4]]
flattened_unique_set = {num for row in matrix for num in row}
print(flattened_unique_set)
# Output: {1, 2, 3, 4}
```
**Ternary Operations in the Expression:**
While the `if` clause at the end of the comprehension acts as a filter, you can also use Python's ternary operator within the `expression` itself to alter the output based on a condition, rather than filtering the item out entirely.
```python theme={"dark"}
# Syntax: {value_if_true if condition else value_if_false for item in iterable}
numbers = [-2, -1, 0, 1, 2]
sign_set = {"positive" if x > 0 else "non-positive" for x in numbers}
print(sign_set)
# Output: {'positive', 'non-positive'}
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
