Python Tutorial — Learn Python Step by Step

Python List Comprehension

List comprehensions provide a concise, readable way to create lists from existing iterables. They replace multi-line loops with a single expressive line.

Basic Syntax

# Syntax: [expression for item in iterable]

# Traditional loop
squares = []
for x in range(10):
    squares.append(x ** 2)

# List comprehension — same result, one line
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# More examples
names = ["alice", "bob", "charlie"]
upper_names = [name.upper() for name in names]
# ["ALICE", "BOB", "CHARLIE"]

lengths = [len(name) for name in names]
# [5, 3, 7]

Filtering with Conditions

# Syntax: [expression for item in iterable if condition]

# Get even numbers only
evens = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Filter strings by length
words = ["hi", "hello", "hey", "howdy", "yo"]
long_words = [w for w in words if len(w) > 3]
# ["hello", "howdy"]

# Filter and transform together
numbers = [1, -2, 3, -4, 5, -6]
positive_doubled = [n * 2 for n in numbers if n > 0]
# [2, 6, 10]

# Multiple conditions
values = range(100)
special = [x for x in values if x % 3 == 0 if x % 5 == 0]
# [0, 15, 30, 45, 60, 75, 90] — divisible by both 3 and 5

if/else in Comprehensions

# if/else goes BEFORE for (it is part of the expression)
# Syntax: [value_if_true if condition else value_if_false for item in iterable]

numbers = [1, -2, 3, -4, 5]
absolute = [n if n >= 0 else -n for n in numbers]
# [1, 2, 3, 4, 5]

# Classify values
scores = [85, 42, 91, 67, 55, 78]
results = ["pass" if s >= 60 else "fail" for s in scores]
# ["pass", "fail", "pass", "pass", "fail", "pass"]

# Replace values conditionally
data = [10, None, 30, None, 50]
cleaned = [x if x is not None else 0 for x in data]
# [10, 0, 30, 0, 50]

Nested Comprehensions

# Flatten a 2D list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Create a 2D grid
grid = [[0 for col in range(4)] for row in range(3)]
# [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

# All combinations
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
combos = [f"{color}-{size}" for color in colors for size in sizes]
# ["red-S", "red-M", "red-L", "blue-S", "blue-M", "blue-L"]

# Transpose a matrix
transposed = [[row[i] for row in matrix] for i in range(3)]
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Dict and Set Comprehensions

# Dictionary comprehension: {key: value for item in iterable}
words = ["hello", "world", "python", "code"]
word_lengths = {w: len(w) for w in words}
# {"hello": 5, "world": 5, "python": 6, "code": 4}

# Swap keys and values
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
# {1: "a", 2: "b", 3: "c"}

# Filter a dictionary
scores = {"Alice": 85, "Bob": 42, "Charlie": 91, "Diana": 67}
passed = {name: score for name, score in scores.items() if score >= 60}
# {"Alice": 85, "Charlie": 91, "Diana": 67}

# Set comprehension: {expression for item in iterable}
sentence = "hello world hello python world"
unique_lengths = {len(word) for word in sentence.split()}
# {5, 6} — only unique values

When NOT to Use Comprehensions

# AVOID: too complex or hard to read
# BAD — difficult to understand at a glance
result = [x.strip().lower() for x in open("file.txt") if x.strip() and not x.startswith("#") and len(x) < 100]

# GOOD — use a regular loop for complex logic
result = []
for line in open("file.txt"):
    line = line.strip()
    if not line or line.startswith("#"):
        continue
    if len(line) >= 100:
        continue
    result.append(line.lower())

# AVOID: side effects in comprehensions
# BAD — comprehension for side effects (confusing)
[print(x) for x in items]  # creates useless list of Nones

# GOOD — use a for loop
for x in items:
    print(x)

• List comprehensions are faster and more Pythonic than equivalent for + append loops.
• Filter with if at the end; use if/else before for to transform values.
• Use dict comprehensions ({k: v for ...}) and set comprehensions ({x for ...}) too.
• Keep comprehensions simple — if it needs more than ~80 characters, use a regular loop.
• Never use comprehensions for side effects (printing, writing files) — use a loop instead.