A list comprehension is a concise, readable way to build a list by transforming and/or filtering an iterable in a single expression — Python's idiomatic alternative to a for loop that appends to a list.
squares = []
n ():
squares.append(n ** )
squares = [n ** n ()]
Read it as "the square of n, for each n in range(5)." It's more concise and often faster than the manual loop.
# keep only even numbers
evens = [n for n in range(10) if n % 2 == 0] # [0, 2, 4, 6, 8]
# transform AND filter together
result = [n * 2 for n in range(10) if n % 2 == 0] # [0, 4, 8, 12, 16]
# if/else goes BEFORE the for (it's part of the expression, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(4)]
# ["even", "odd", "even", "odd"]
{x ** 2 for x in range(5)} # set comprehension → {0, 1, 4, 9, 16}
{k: v for k, v in pairs} # dict comprehension
(x ** 2 for x in range(5)) # generator expression — LAZY, memory-efficient
The same syntax builds sets and dicts; with parentheses it becomes a generator expression that produces values lazily (no full list in memory — great for large data).
# ❌ deeply nested / complex logic → a regular loop is more readable
matrix = [[row[i] for row in data] for i in range(cols)] # OK, but don't over-nest
Keep comprehensions simple; if they need multiple nested loops or complex conditionals, a plain loop is clearer.
List comprehensions are quintessentially "Pythonic" — concise, readable, and often faster than equivalent loops, used constantly for transforming and filtering data.
Mastering them (plus their set/dict/generator variants, and the lazy generator expression for big data) is essential for writing idiomatic Python.
Knowing when to use them (simple transforms/filters) versus a regular loop (complex logic) is the mark of clean, readable code.