Списковые включения в Python: синтаксис, фильтрация и dict-comprehension

Одна строка - одна идея

Ты уже писал этот паттерн несколько раз: начать с пустого списка, пройти по чему-то, может, отфильтровать и положить в результат.

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

Списковое включение говорит то же самое в одну строку:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

Читается слева направо: «новый список, состоящий из n * 2 для каждого n в numbers». Структура - [expression for item in iterable].

Это не специфичный для Python трюк - его называют comprehension, потому что ты декларативно описываешь, что попадает в новый список, а не расписываешь механику сборки.

Добавляем фильтр

Добавь if после части с циклом - получишь фильтр:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = [n for n in numbers if n % 2 == 0]
print(evens)

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

Второе читается: «n * n для каждого n в numbers, но только если n нечётное».

Эквивалентный цикл:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

Оба варианта нормальны. Включение короче и, когда прочтёшь несколько, реально быстрее сканируется глазом - намерение прямо в одной строке.

Map и filter одновременно

Можно пропустить значения через функцию и одновременно отфильтровать:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

Для каждого слова длиннее 3 символов включаем его версию в верхнем регистре.

Вложенные циклы во включении

Два for-а дают пару в стиле декартова произведения:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

Порядок такой же, как если бы ты вложил циклы: первый for - внешний, второй - внутренний. Читается слева направо, как и эквивалентный цикл с отступами.

Два уровня - примерно предел, после которого обычный цикл читается лучше. Дошёл до трёх - переключайся обратно на циклы.

Включения словарей и множеств

Та же идея, другие скобки:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension - produces a dict
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension - produces a set
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

Включения множеств на первый взгляд выглядят так же, как включения словарей, - разница в key: value против одного выражения. Фигурные плюс : - словарь; фигурные без : - множество.

Generator-выражения

Близнец спискового включения, но с круглыми скобками вместо квадратных - и, что критично, он не строит список:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

Заметь: генератор мы передали прямо в sum() и any() - без лишних скобок. Generator-выражения - правильный инструмент, когда вызывающей стороне достаточно один раз проитерироваться. Для больших коллекций они экономят память по сравнению с полным списком.

Когда взять обычный цикл

Включения соблазнительны. Технически туда можно напихать много. Не стоит.

Тянись к обычному циклу, когда:

• Преобразование состоит из нескольких шагов. Если нужны промежуточные переменные - распиши.
• Есть сложная обработка ошибок или ветвление.
• Любой читатель вынужден задержаться на строке дважды, чтобы её понять.

Правило, которое я применяю: если могу прочесть включение на одном вдохе и понять, что оно делает, - оно остаётся. Спотыкаюсь - переписываю в цикл.

Некоторые включения выглядят умно, но изматывают:

# Clever but exhausting:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# Clearer as a loop:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

Результат тот же. Цикл - пять строк вместо одной, но «длиннее» ≠ «хуже».

Несколько паттернов, которые пригодятся

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# Grab one attribute from each element.
names = [u["name"] for u in users]
print(names)

# Filter and project in one go.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# Build a lookup dict keyed by a field.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# Count how many pass a test.
active_count = sum(1 for u in users if u["active"])
print(active_count)

Эти пять паттернов покрывают удивительно большую долю повседневной работы с данными.

Дальше

Ты уже видел основные коллекционные типы и включение, которое их связывает. Следующая глава - функции: упаковка поведения в именованные, переиспользуемые единицы.