[2026] Python Comprehensions | List, Dict, Set, and Generator Expressions

Introduction

“Build a list in one line”

Comprehensions are a concise, fast feature of Pythonic code.

1. List comprehensions

What they are

A list comprehension builds a list in a single expression. For many cases it is clearer and faster than a manual for loop with append. Syntax: [expr for var in iterable if condition]

Basics

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# Traditional loop
# 실행 예제
squares = []
for i in range(10):
    squares.append(i ** 2)
print(squares)
# List comprehension
squares = [i ** 2 for i in range(10)]
print(squares)

Rough timing comparison (order-of-magnitude; depends on Python version and hardware): 아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import time
start = time.time()
result1 = []
for i in range(1000000):
    result1.append(i ** 2)
print(f"for loop: {time.time() - start:.4f}s")
start = time.time()
result2 = [i ** 2 for i in range(1000000)]
print(f"comprehension: {time.time() - start:.4f}s")

Filtering with if

아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

evens = [i for i in range(10) if i % 2 == 0]
print(evens)
multiples = [i for i in range(30) if i % 3 == 0 and i > 10]
print(multiples)
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
long_words = [word for word in words if len(word) > 5]
print(long_words)

Conditional expressions (if / else)

다음은 python를 활용한 상세한 구현 코드입니다. 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

labels = ['even' if i % 2 == 0 else 'odd' for i in range(5)]
print(labels)
# if/else sits before the final `for`:
# [expr_if_true if cond else expr_if_false for x in iterable]
numbers = [-2, -1, 0, 1, 2]
signs = [
    'positive' if n > 0 else ('negative' if n < 0 else 'zero')
    for n in numbers
]
print(signs)
scores = [95, 85, 75, 65, 55]
grades = [
    'A' if s >= 90 else 'B' if s >= 80 else 'C' if s >= 70 else 'D' if s >= 60 else 'F'
    for s in scores
]
print(grades)

Filter (if only) vs map (if/else) 아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

evens = [i for i in range(10) if i % 2 == 0]
labels = ['even' if i % 2 == 0 else 'odd' for i in range(10)]
positive_squares = [i ** 2 if i > 0 else 0 for i in range(-5, 6) if i != 0]
print(positive_squares)

Nested loops

다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = []
for row in matrix:
    for num in row:
        flat.append(num)
print(flat)
flat = [num for row in matrix for num in row]
print(flat)
# Left `for` is outer, right `for` is inner — same order as nested fors
multiplication_table = [
    f"{i} x {j} = {i*j}"
    for i in range(2, 10)
    for j in range(1, 10)
]
print(multiplication_table[:5])
coordinates = [(x, y) for x in range(3) for y in range(3)]
print(coordinates)
diagonal = [(x, y) for x in range(5) for y in range(5) if x == y]
print(diagonal)

Nested comprehension vs nested lists 아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

matrix = [[i * j for j in range(5)] for i in range(5)]
print(matrix)
matrix = []
for i in range(5):
    row = []
    for j in range(5):
        row.append(i * j)
    matrix.append(row)

---

2. Dictionary comprehensions

Syntax

{key_expr: value_expr for var in iterable if condition} 아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

squares_dict = {}
for i in range(5):
    squares_dict[i] = i ** 2
squares_dict = {i: i ** 2 for i in range(5)}
print(squares_dict)
names = ['Alice', 'Bob', 'Charlie']
name_dict = {i: name for i, name in enumerate(names)}
print(name_dict)

Filtering and transforms

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

even_squares = {i: i ** 2 for i in range(10) if i % 2 == 0}
print(even_squares)
scores = {'Alice': 85, 'Bob': 92, 'Carol': 78, 'Dana': 95}
high_scores = {name: score for name, score in scores.items() if score >= 90}
print(high_scores)
data = {'apple': 5, 'banana': 3, 'cherry': 8, 'date': 2}
filtered = {
    k.upper(): v * 2
    for k, v in data.items()
    if len(k) > 4 and v > 3
}
print(filtered)

Swapping keys and values

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}
print(swapped)
original = {'a': 1, 'b': 2, 'c': 1}
swapped = {v: k for k, v in original.items()}
print(swapped)
from collections import defaultdict
swapped_multi = defaultdict(list)
for k, v in original.items():
    swapped_multi[v].append(k)
print(dict(swapped_multi))

Practical snippets

다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

words = ['apple', 'banana', 'cherry', 'date']
word_lengths = {word: len(word) for word in words}
print(word_lengths)
env_str = "DEBUG=True,PORT=8000,HOST=localhost"
env_dict = {
    pair.split('=')[0]: pair.split('=')[1]
    for pair in env_str.split(',')
}
print(env_dict)
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'Seoul']
person = {k: v for k, v in zip(keys, values)}
print(person)
products = {'apple': 1000, 'banana': 500, 'cherry': 2000, 'date': 800}
discounted = {
    name: price * 0.9
    for name, price in products.items()
    if price >= 1000
}
print(discounted)

---

3. Set comprehensions

Syntax

{expr for var in iterable if condition} — unordered, unique elements. 아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = set(numbers)
unique = {n for n in numbers}
print(unique)
numbers = [1, -2, 2, -3, 3, -4, 4]
abs_unique = {abs(n) for n in numbers}
print(abs_unique)

Conditional sets

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

even_set = {i for i in range(10) if i % 2 == 0}
print(even_set)
text = "Hello World"
vowels = {char.lower() for char in text if char.lower() in 'aeiou'}
print(vowels)
words = ['hi', 'hello', 'hey', 'hello', 'world', 'hi']
long_words = {word for word in words if len(word) >= 3}
print(long_words)

Examples

다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

emails = [
    'alice@gmail.com',
    'bob@yahoo.com',
    'charlie@gmail.com',
    'david@outlook.com',
    'eve@gmail.com'
]
domains = {email.split('@')[1] for email in emails}
print(domains)
files = ['image.jpg', 'doc.pdf', 'photo.jpg', 'video.mp4', 'report.pdf']
extensions = {file.split('.')[-1] for file in files}
print(extensions)
numbers = [123, 456, 789, 111, 222, 333]
last_digits = {n % 10 for n in numbers}
print(last_digits)

Set operations

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = {x for x in list1} & {x for x in list2}
print(common)
print(set(list1) & set(list2))
diff = {x for x in list1} - {x for x in list2}
print(diff)
union = {x for x in list1} | {x for x in list2}
print(union)

---

4. Generator expressions

Syntax

(expr for var in iterable if condition) — lazy, one value at a time. 다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

squares_list = [i ** 2 for i in range(1000000)]
print(type(squares_list))
squares_gen = (i ** 2 for i in range(1000000))
print(type(squares_gen))
print(next(squares_gen))
print(next(squares_gen))
for square in (i ** 2 for i in range(5)):
    print(square, end=' ')
print()
gen = (i for i in range(3))
print(list(gen))
print(list(gen))

Memory footprint (illustrative)

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

import sys
list_comp = [i for i in range(100000)]
print(sys.getsizeof(list_comp))
gen_expr = (i for i in range(100000))
print(sys.getsizeof(gen_expr))

When generators shine

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

total = sum(i ** 2 for i in range(1000000))
maximum = max(i ** 2 for i in range(1000))
has_large = any(i ** 2 > 10000 for i in range(1000000))
with open('large_file.txt') as f:
    non_empty_lines = sum(1 for line in f if line.strip())
numbers = range(1000000)
evens = (x for x in numbers if x % 2 == 0)
squares = (x ** 2 for x in evens)
large = (x for x in squares if x > 100)
result = sum(large)

Generator vs list

아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# Generator: one pass, low memory
total = sum(i ** 2 for i in range(1000000))
# List: multiple passes, indexing, len()
squares = [i ** 2 for i in range(10)]
print(squares[5])
print(len(squares))
print(sum(squares))
print(max(squares))

---

5. Practical examples

Example 1: CSV-like string to dict rows

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

csv_data = "name,age,city\nAlice,25,Seoul\nBob,30,Busan\nCarol,28,Daejeon"
lines = csv_data.strip().split('\n')
header = lines[0].split(',')
data = [
    dict(zip(header, line.split(',')))
    for line in lines[1:]
]
print(data)

Typed conversion 아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

data_typed = [
    {
        'name': parts[0],
        'age': int(parts[1]),
        'city': parts[2]
    }
    for line in lines[1:]
    for parts in [line.split(',')]
]
print(data_typed)

Example 2: student records

다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

students = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Carol', 'score': 78},
    {'name': 'Dana', 'score': 95},
    {'name': 'Eve', 'score': 88}
]
high_scores = [s['name'] for s in students if s['score'] >= 90]
print(high_scores)
graded = [
    {**s, 'grade': 'A' if s['score'] >= 90 else 'B' if s['score'] >= 80 else 'C'}
    for s in students
]
print(graded)
passed = [
    {**s, 'grade': 'A' if s['score'] >= 90 else 'B'}
    for s in students
    if s['score'] >= 80
]
print(passed)

Example 3: cleaning strings

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

names = ['  alice  ', 'BOB', '  Charlie', 'david  ']
cleaned = [name.strip().lower() for name in names]
print(cleaned)
capitalized = [name.strip().capitalize() for name in names]
print(capitalized)
filtered = [name.strip() for name in names if len(name.strip()) >= 3]
print(filtered)

Example 4: file paths

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import os
files = ['data.txt', 'image.png', 'report.txt', 'video.mp4', 'notes.txt']
txt_files = [f for f in files if f.endswith('.txt')]
print(txt_files)
names_only = [os.path.splitext(f)[0] for f in txt_files]
print(names_only)
base_path = '/home/user/documents'
full_paths = [os.path.join(base_path, f) for f in txt_files]
print(full_paths)

Example 5: JSON API payload

다음은 python를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

api_response = {
    'users': [
        {'id': 1, 'name': 'Alice', 'active': True, 'age': 25},
        {'id': 2, 'name': 'Bob', 'active': False, 'age': 30},
        {'id': 3, 'name': 'Charlie', 'active': True, 'age': 35},
        {'id': 4, 'name': 'David', 'active': True, 'age': 28}
    ]
}
active_ids = [
    user['id']
    for user in api_response['users']
    if user['active']
]
print(active_ids)
active_users = [
    {'name': user['name'], 'age': user['age']}
    for user in api_response['users']
    if user['active']
]
print(active_users)
senior_active = [
    user['name']
    for user in api_response['users']
    if user['active'] and user['age'] >= 30
]
print(senior_active)

---

6. Performance notes

Memory: list vs generator

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

import sys
squares_list = [i ** 2 for i in range(1000000)]
squares_gen = (i ** 2 for i in range(1000000))
print(sys.getsizeof(squares_list))
print(sys.getsizeof(squares_gen))

Micro-benchmark (illustrative)

다음은 python를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import time
data = list(range(1000000))
start = time.time()
result1 = [x * 2 for x in data if x % 2 == 0]
print(f"comprehension: {time.time() - start:.4f}s")
start = time.time()
result2 = []
for x in data:
    if x % 2 == 0:
        result2.append(x * 2)
print(f"for loop: {time.time() - start:.4f}s")
start = time.time()
result3 = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, data)))
print(f"map+filter: {time.time() - start:.4f}s")

Deeply nested comprehensions

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

def is_ascending(x, y, z):
    return x < y < z
result = [
    z
    for x in range(10)
    for y in range(10)
    for z in range(10)
    if is_ascending(x, y, z)
]
from itertools import combinations
result = [c[2] for c in combinations(range(10), 3)]

---

7. Style and best practices

Readability first

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

squares = [x ** 2 for x in range(10)]
result = []
for x in range(10):
    if x % 2 == 0:
        temp = x ** 2
        if temp > 20:
            result.append(temp)
        else:
            result.append(temp * 2)
# Avoid overly dense one-liners that hide intent

Common pitfalls

1) Accidental shared rows in a matrix 아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

matrix = [[0] * 3] * 3
matrix[0][0] = 1
print(matrix)
matrix = [[0] * 3 for _ in range(3)]
matrix[0][0] = 1
print(matrix)

2) Building a list just to sum

total = sum([i ** 2 for i in range(1000000)])
total = sum(i ** 2 for i in range(1000000))

3) Side effects inside comprehensions 아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

results = []
[results.append(x * 2) for x in range(10)]
results = []
for x in range(10):
    results.append(x * 2)
results = [x * 2 for x in range(10)]

Debug strategy

아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

data = [1, 2, 3, 4, 5]
filtered = [x for x in data if x % 2 == 0]
print(filtered)
result = [x ** 2 for x in filtered]
print(result)

Patterns

아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

raw_names = ['  ALICE  ', 'bob', '  Charlie  ', 'DAVID']
normalized = [name.strip().title() for name in raw_names]
print(normalized)
numbers = range(1, 11)
even_sum = sum(x for x in numbers if x % 2 == 0)
odd_sum = sum(x for x in numbers if x % 2 == 1)
print(even_sum, odd_sum)

---

8. Troubleshooting

“list index out of range”

아래 코드는 python를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

data = [[1, 2], [3, 4, 5], [6]]
result = [row[2] for row in data if len(row) > 2]
print(result)
result = [row[2] if len(row) > 2 else None for row in data]
print(result)

Duplicate keys in dict comprehensions

아래 코드는 python를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

items = [('a', 1), ('b', 2), ('a', 3)]
d = {k: v for k, v in items}
print(d)
from collections import defaultdict
d = defaultdict(list)
[d[k].append(v) for k, v in items]
print(dict(d))

Exceptions inside comprehensions

아래 코드는 python를 사용한 구현 예제입니다. 함수를 통해 로직을 구현합니다, 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

data = ['1', '2', 'three', '4', 'five']
result = [int(x) for x in data if x.isdigit()]
def safe_int(x):
    try:
        return int(x)
    except ValueError:
        return None
result = [safe_int(x) for x in data]
result_filtered = [x for x in result if x is not None]
print(result_filtered)

---

9. Quick reference table

Situation	Prefer	Why
Simple map/filter	Comprehension	Short and fast
Complex branching	for loop	Clarity
Side effects (I/O, DB)	for loop	Obvious intent
One-pass huge data	Generator expression	Memory
Need index, len, many passes	List comprehension	Reusable list

---

10. Exercises

Exercise 1

Squares of multiples of 3 from 1 through 20:

# Expected: [9, 36, 81, 144, 225, 324]

Exercise 2

Turn people = [('Alice', 25), ('Bob', 30), ('Charlie', 35)] into {name: age}.

Exercise 3

From a 2-D list, flatten even numbers only.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# Expected: [2, 4, 6, 8]

Exercise 4

Classify temperatures as "cold" (<10), "mild" (10–25), or "hot" (>25).

temps = [5, 15, 30, 8, 22, 28]

Answers

아래 코드는 python를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다. ```python multiples_of_3 = [x ** 2 for x in range(1, 21) if x % 3 == 0] people = [('Alice', 25), ('Bob', 30), ('Charlie', 35)] people_dict = {name: age for name, age in people} matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] evens_flat = [num for row in matrix for num in row if num % 2 == 0] temps = [5, 15, 30, 8, 22, 28] labels = [ 'cold' if t < 10 else 'mild' if t <= 25 else 'hot' for t in temps ] print(labels) ```

--- ## Summary ### Key takeaways 1. **List comprehension**: `[expr for x in iterable if cond]` — concise list construction. 2. **Dict comprehension**: `{k: v for ...}` — build mappings in one expression. 3. **Set comprehension**: `{expr for ...}` — unique values with optional transforms. 4. **Generator expression**: `(expr for ...)` — lazy iteration, tiny memory footprint. 5. **Readability wins**: reach for a plain loop when the comprehension becomes cryptic. ### After you master comprehensions - Code tends to be **shorter and idiomatic** - Data prep tasks feel **lighter** - You can choose **list vs generator** deliberately ### Next steps - [Decorators](/blog/python-series-10-decorators-en/) - Generator **functions** with `yield` - [Functions | lambdas and higher-order functions](/blog/python-series-04-functions-en/) --- ## Related posts

• Python environment setup | Install Python on Windows and Mac