> ## 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 List Comprehension A list comprehension is a concise syntactic construct in Python used to generate a new list by evaluating an expression for each item of an existing iterable, optionally filtering the elements based on conditional statements. In the CPython reference implementation, list comprehensions are optimized for performance; the compiler emits a specialized `LIST_APPEND` bytecode, which avoids the dynamic attribute lookup and function call overhead of the `.append()` method required by standard `for` loops. ```python theme={"dark"} [expression for target_list in iterable if condition1 if condition2] ``` ## Structural Components 1. **`expression`**: The operation or value to be evaluated and inserted into the new list. This can be a simple variable reference, a mathematical operation, a method call, or a complex conditional expression. 2. **`for target_list in iterable`**: The iteration clause. * `iterable`: Any Python object capable of returning its members one at a time. This includes objects that implement the `__iter__()` protocol, as well as objects that implement the sequence protocol via `__getitem__()` (accepting integer indices starting from `0` and raising an `IndexError` when exhausted). * `target_list`: The local variable(s) bound to the current value yielded by the iterable during each iteration step. 3. **`if condition`** *(Optional)*: A predicate clause acting as a filter. It is evaluated for truthiness. If the condition evaluates to `True`, the `expression` is evaluated and the result is appended to the new list. If `False`, the item is skipped. Multiple `if` clauses can be chained sequentially in a single comprehension (e.g., `if cond1 if cond2`), which implicitly acts as a logical `and`. ## Syntactic Variations ### Conditional Expressions (Ternary Operators) When a conditional dictates the *output value* rather than filtering the iterable, Python's ternary operator is placed inside the `expression` segment, preceding the `for` keyword. ```python theme={"dark"} [value_if_true if condition else value_if_false for target_list in iterable] ``` *Note: An `else` clause cannot be used in the trailing filter condition at the end of the comprehension.* ### Nested Comprehensions List comprehensions support multiple `for` clauses to handle nested iterables. The clauses are evaluated in a strictly left-to-right order, mirroring the structure of nested standard `for` loops (outermost loop first, innermost loop last). ```python theme={"dark"} [expression for outer_target in outer_iterable for inner_target in inner_iterable] ``` It is also possible to nest a list comprehension entirely within the `expression` of another list comprehension, which evaluates the inner comprehension for every step of the outer iteration. ```python theme={"dark"} [[inner_expression for inner_target in inner_iterable] for outer_target in outer_iterable] ``` ## Technical Characteristics * **Eager Evaluation:** List comprehensions evaluate eagerly. The entire list is constructed in memory before the execution moves to the next line of code. For exceptionally large datasets, this can lead to high memory consumption (where a generator expression, using `()`, would be preferred for lazy evaluation). * **Variable Scope:** In Python 3.x, list comprehensions execute within their own isolated local scope. The variables bound in the `target_list` do not leak into or overwrite variables in the enclosing namespace. * **Return Type:** The construct strictly returns a `list` object, regardless of the type of the input `iterable`.

Tired of Poor Python Skills? Fix That With Deep Grasping! Learn More