> ## 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 Conditional Comprehension
Conditional comprehension is a syntactic construct in Python that integrates conditional logic into list, dictionary, set, or generator comprehensions. It evaluates predicates during the iteration process to either filter the elements yielded from an iterable or dynamically alter the expression applied to those elements.
The behavior of the comprehension changes fundamentally based on the placement of the conditional clause relative to the `for` keyword. There are two primary structural forms: filtering and mapping.
## 1. Filtering (Right-Side `if`)
When the `if` statement is placed at the end of the comprehension, it acts as a filter. The predicate is evaluated for each item drawn from the iterable. If the predicate evaluates to `False`, the item is discarded, and the leading expression is never evaluated for that iteration.
```python theme={"dark"}
[expression for item in iterable if predicate]
```
**Evaluation Order:**
1. Retrieve `item` from `iterable`.
2. Evaluate `predicate(item)`.
3. If `True`, evaluate `expression(item)` and append to the resulting collection.
## 2. Mapping via Ternary Operator (Left-Side `if-else`)
When the conditional logic is placed before the `for` keyword, it utilizes Python's ternary conditional operator (`x if condition else y`). This form does not filter the iterable; the length of the output collection will always match the length of the input iterable. Instead, it evaluates a predicate to determine *which* expression to execute and yield.
```python theme={"dark"}
[expression_if_true if predicate else expression_if_false for item in iterable]
```
**Evaluation Order:**
1. Retrieve `item` from `iterable`.
2. Evaluate `predicate(item)`.
3. If `True`, evaluate `expression_if_true(item)`.
4. If `False`, evaluate `expression_if_false(item)`.
5. Append the evaluated result to the collection.
## 3. Combined Filtering and Mapping
Both constructs can be used simultaneously within a single comprehension. The right-side filter is evaluated first to determine if the item should be processed, followed by the left-side ternary operator to determine the output value.
```python theme={"dark"}
[
expression_if_true if mapping_predicate else expression_if_false
for item in iterable
if filter_predicate
]
```
## Application Across Data Structures
The exact same conditional syntax applies to all comprehension-supporting data structures in Python. The only syntactic difference is the enclosing brackets or braces, and in the case of dictionaries, the key-value pair expression.
**Dictionary Comprehension:**
```python theme={"dark"}
{key_expr: val_expr for item in iterable if predicate}
```
**Set Comprehension:**
```python theme={"dark"}
{expression for item in iterable if predicate}
```
**Generator Expression:**
```python theme={"dark"}
(expression for item in iterable if predicate)
```
## Multiple Conditions
Python allows chaining multiple `if` clauses on the right side. Multiple `if` clauses are implicitly joined by a logical `and`.
```python theme={"dark"}
# Implicit 'and' evaluation
[expression for item in iterable if predicate_A if predicate_B]
# Equivalent explicit 'and' evaluation
[expression for item in iterable if predicate_A and predicate_B]
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
