> ## 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 Nested Comprehension
A nested comprehension in Python is a syntactic construct that either combines multiple iteration clauses (`for`) within a single comprehension or embeds an entire comprehension within the output expression of another. It provides a declarative mechanism for evaluating Cartesian products, flattening nested iterables, or generating multi-dimensional data structures.
There are two distinct architectural patterns for nested comprehensions, dictated by the placement of the brackets and the order of the `for` clauses.
## 1. Multiple `for` Clauses (Single-Dimensional Output)
When multiple `for` clauses are chained within the same set of enclosing brackets, the comprehension yields a single, flattened iterable.
**Syntax:**
```python theme={"dark"}
[expression for outer_target in outer_iterable for inner_target in inner_iterable]
```
**Execution Flow:**
The evaluation order proceeds strictly from **left to right**. The leftmost `for` clause acts as the outermost loop, and subsequent `for` clauses act as nested inner loops. Variables bound in an outer clause are immediately available to subsequent inner clauses.
**Procedural Equivalent:**
```python theme={"dark"}
# Comprehension
result = [x * y for x in iterable_A for y in iterable_B]
# Procedural equivalent
result = []
for x in iterable_A:
for y in iterable_B:
result.append(x * y)
```
## 2. Comprehension as an Output Expression (Multi-Dimensional Output)
When a comprehension is placed in the `expression` position of an outer comprehension, it generates a nested (multi-dimensional) data structure.
**Syntax:**
```python theme={"dark"}
[[inner_expression for inner_target in inner_iterable] for outer_target in outer_iterable]
```
**Execution Flow:**
The evaluation order is driven by the outer comprehension. For every iteration of the outer `for` clause, the entire inner comprehension is evaluated and instantiated as a discrete object (e.g., a new list) before being appended to the outer structure.
**Procedural Equivalent:**
```python theme={"dark"}
# Comprehension
result = [[x * y for x in iterable_A] for y in iterable_B]
# Procedural equivalent
result = []
for y in iterable_B:
inner_list = []
for x in iterable_A:
inner_list.append(x * y)
result.append(inner_list)
```
## Conditional Logic in Nested Comprehensions
Predicate clauses (`if`) can be attached to any `for` clause in a nested comprehension. The condition is evaluated at the specific level of nesting where it is declared.
**Syntax:**
```python theme={"dark"}
[
expression
for outer_target in outer_iterable if outer_condition
for inner_target in inner_iterable if inner_condition
]
```
If `outer_condition` evaluates to `False`, the inner loop is bypassed entirely for that iteration, mirroring the behavior of a `continue` statement in a procedural loop.
## Scope and Variable Resolution
Python comprehensions establish their own local scope. In nested comprehensions:
* **Chained `for` clauses:** Share a single local scope. Name resolution flows left-to-right.
* **Embedded comprehensions:** Each comprehension establishes its own nested scope. The inner comprehension can resolve names bound in the outer comprehension via standard lexical scoping rules (closures), but the outer comprehension cannot access names bound within the inner comprehension.
## Support Across Comprehension Types
Nesting mechanics are identical across all comprehension types. You can freely mix types, such as nesting a list comprehension inside a dictionary comprehension, or chaining `for` clauses within a generator expression.
**Mixed Type Syntax:**
```python theme={"dark"}
# Generator expression containing a list comprehension
( [x for x in inner_iterable] for inner_iterable in outer_iterable )
# Dictionary comprehension with chained for clauses
{ key: value for outer_target in outer_iterable for key, value in outer_target }
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
