В прошлом уроке классы забирали атрибуты и методы у родителя, и наследование заметно сократило объём кода. Тот же принцип компактности теперь спускается на уровень списков: Python умеет строить новый список одним выражением, создавать функцию без имени и прогонять данные через встроенные map и filter без единого развёрнутого цикла. Эти приёмы встречаются в чужом коде постоянно, поэтому без них читать документацию и примеры из статей оказывается сложнее, чем писать собственные программы. Разобраться придётся один раз, зато потом короткие конструкции перестанут выглядеть шифровками.

Обычный цикл и его компактная замена

Логично начать с задачи, знакомой каждому: возвести все числа списка в квадрат. Классическое решение через цикл занимает четыре строки.

numbers = [1, 2, 3, 4, 5]
squares = []
for n in numbers:
    squares.append(n ** 2)
print(squares)  # [1, 4, 9, 16, 25]

Работает здесь по сути одна содержательная строка, а остальные готовят почву: пустая заготовка списка, открытие цикла, вызов append. Python позволяет записать ту же мысль одним выражением.

numbers = [1, 2, 3, 4, 5]
squares = [n ** 2 for n in numbers]
print(squares)  # [1, 4, 9, 16, 25]

Такая запись называется генератором списка, по-английски list comprehension. Общая форма выглядит как [выражение for переменная in последовательность]. Читается она почти как фраза на естественном языке: возьми n, возведи в квадрат, перебирая numbers. Интерпретатор делает ровно то же самое, что и цикл из первого примера: по очереди подставляет каждый элемент, вычисляет выражение и складывает результат в новый список. Исходный список numbers остаётся нетронутым, в памяти появляется отдельный объект.

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

prices = [100, 250, 40, 990]
sale = [round(p * 0.9, 2) for p in prices]
print(sale)  # [90.0, 225.0, 36.0, 891.0]

names = ["аня", "борис", "вера"]
fixed = [name.capitalize() for name in names]
print(fixed)  # ['Аня', 'Борис', 'Вера']

Выражение в начале может быть любым: арифметикой, вызовом функции, конкатенацией строк, обращением к элементу вложенной структуры. Источником тоже служит не только список, а любая перебираемая сущность: строка, диапазон range, содержимое файла. Числовой диапазон встречается чаще прочих.

table = [i * 7 for i in range(1, 10)]
print(table)  # [7, 14, 21, 28, 35, 42, 49, 56, 63]

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

Условие if внутри генератора списка

Отбор элементов без генератора требует цикла с вложенной проверкой, а здесь условие пишется прямо в строке. Знак if ставится в самый конец, после for, и пропускает элементы, не прошедшие проверку.

numbers = [12, -3, 45, -8, 7, -30]
positives = [n for n in numbers if n > 0]
print(positives)  # [12, 45, 7]

Читается связка легко: оставь n, перебирая numbers, если n больше нуля. Внутри условия работает любая проверка, от сравнения чисел до вызова методов строки.

words = ["кот", "дом", "велосипед", "еж", "трамвай"]
long_words = [w for w in words if len(w) > 4]
print(long_words)  # ['велосипед', 'трамвай']

Подводный камень, на котором спотыкаются почти все новички, связан с позицией оператора if. Фильтрующий if с условием стоит справа от for. Если же нужно выбирать между двумя вариантами для каждого элемента, используется тернарный оператор, и тогда if вместе с else переезжает в начало, в самое выражение.

marks = [5, 3, 4, 2, 5, 3]
labels = ["зачёт" if m >= 3 else "незачёт" for m in marks]
print(labels)  # ['зачёт', 'зачёт', 'зачёт', 'незачёт', 'зачёт', 'зачёт']

Короткое мнемоническое правило звучит так: справа if без else, слева if с else. Оно спасает от синтаксической ошибки в самый частый момент знакомства с этим синтаксисом.

Та же идея распространяется и на словари. Генератор словаря записывается в фигурных скобках, а выражение превращается в пару ключ и значение, разделённые двоеточием.

words = ["кот", "бегемот", "лиса"]
lengths = {w: len(w) for w in words}
print(lengths)  # {'кот': 3, 'бегемот': 7, 'лиса': 4}

cubes = {n: n ** 3 for n in range(1, 6)}
print(cubes)  # {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

Одна строка заменяет цикл с пустым словарём и ручным заполнением пар. Условие if работает и здесь, например чтобы оставить в словаре только короткие слова: {w: len(w) for w in words if len(w) <= 4}.

Лямбда-функции без имени и лишних строк

Обычная функция объявляется через def, получает имя и может занимать сколько угодно строк.

def double(x):
    return x * 2

print(double(7))  # 14

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

double = lambda x: x * 2
print(double(7))  # 14

Слово return не пишется: интерпретатор сам отдаёт значение выражения после двоеточия. Лямбда называется анонимной, потому что у неё нет собственного имени; переменная double держит объект функции точно так же, как держала бы число. Внутри допускается ровно одно выражение, никаких циклов, присваиваний и многострочной логики. Отсюда простое правило: замысел не влез в одно выражение, значит пора возвращаться к def с нормальным именем.

Присваивать лямбду переменной можно, хотя пользы в этом мало, а читаемость страдает: разыскивая место, где объявлена функция, читатель найдёт не привычный def. Главная работа лямбды начинается в момент передачи её аргументом в другую функцию, и следующая глава как раз про таких получателей.

Связка map и filter с функцией list

Встроенная функция map принимает другую функцию и последовательность, после чего применяет функцию к каждому элементу по очереди.

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6, 8, 10]

Важная деталь: map возвращает не готовый список, а ленивый объект-итератор, который выдаёт значения по одному и только по запросу. На огромных наборах данных это экономит память, но для print результат приходится оборачивать в list(), иначе на экран выйдет служебная запись вместо данных.

lazy = map(str, [1, 2, 3])
print(lazy)  # <map object at 0x7f8b1c2d3e50>, адрес меняется при каждом запуске
print(list(lazy))  # ['1', '2', '3']

Вторая встроенная функция, filter, работает как сито: оставляет только те элементы, для которых переданная функция вернула истину.

numbers = [12, -3, 45, -8, 7, -30]
positives = list(filter(lambda x: x > 0, numbers))
print(positives)  # [12, 45, 7]

Обе функции собираются в цепочку, где сначала отбирается нужное, затем преобразуется.

words = ["кот", "бегемот", "лиса", "ёж"]
lengths = list(map(len, filter(lambda w: len(w) > 3, words)))
print(lengths)  # [7, 4]

В примере map получила готовую функцию len, а не лямбду: встроенные функции подставлять даже удобнее, ничего не приходится писать заново. Генератор списка решает ту же задачу короче и совсем без лямбды.

lengths = [len(w) for w in words if len(w) > 3]

Опытные разработчики обычно выбирают генератор списка для простых преобразований, а map и filter оставляют для случаев, когда подходящая функция уже существует и её можно просто передать готовой.

Сортировка sorted с параметром key и лямбдой

Функция sorted сортирует почти всё, но по умолчанию сравнивает элементы напрямую: строки выстраиваются по алфавиту, числа по возрастанию.

words = ["бегемот", "кот", "лиса"]
print(sorted(words))  # ['бегемот', 'кот', 'лиса']

Параметр key меняет правило сравнения. Ему передают функцию, и сортировка идёт по результату её вызова для каждого элемента. Готовая функция len расставляет слова от короткого к длинному.

print(sorted(words, key=len))  # ['кот', 'лиса', 'бегемот']

Когда подходящего поля нет в виде готовой функции, на помощь приходит лямбда. Список кортежей сортируют по конкретной позиции, например по цене товара.

goods = [("стол", 3000), ("стул", 900), ("лампа", 1500)]
by_price = sorted(goods, key=lambda item: item[1])
print(by_price)  # [('стул', 900), ('лампа', 1500), ('стол', 3000)]

Параметр reverse=True разворачивает порядок на обратный, а такой же аргумент key принимают min и max, что позволяет одной строкой найти запись с наименьшим значением.

cheapest = min(goods, key=lambda item: item[1])
print(cheapest)  # ('стул', 900)

scores = {"аня": 92, "борис": 78, "вера": 85}
top = sorted(scores, key=lambda name: scores[name], reverse=True)
print(top)  # ['аня', 'вера', 'борис']

Связка sorted, key и лямбды встречается в реальных проектах чаще прочих приёмов из урока: почти любая таблица данных требует сортировки по выбранному полю, и лямбда решает вопрос одной строкой. Похожий результат можно собрать и генератором словаря с предварительной сортировкой, но вариант с key короче и понятнее.

Вложенные генераторы списков и работа с матрицами

Когда данные организованы в виде вложенных последовательностей - например, матрица как список списков - генератор списка может "распаковывать" их одним выражением. Два предложения for подряд читаются слева направо: внешний цикл идет первым, внутренний - вторым.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Эквивалентный развёрнутый цикл выглядел бы так:

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

Условие if после внутреннего for фильтрует уже "выпрямленные" элементы:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
odds = [x for row in matrix for x in row if x % 2 != 0]
print(odds)  # [1, 3, 5, 7, 9]

Можно также применять преобразование к каждому элементу до выпрямления:

matrix = [[1, 2], [3, 4], [5, 6]]
squared = [x ** 2 for row in matrix for x in row]
print(squared)  # [1, 4, 9, 16, 25, 36]

Три и более for подряд допускаются синтаксически, но читаемость падает резко. На практике вложенность глубже двух уровней лучше выносить в отдельную функцию или использовать itertools.chain. Пример с тремя уровнями для иллюстрации:

cube = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
flat3 = [x for matrix in cube for row in matrix for x in row]
print(flat3)  # [1, 2, 3, 4, 5, 6, 7, 8]

Генераторы выражений: ленивые аналоги без квадратных скобок

Если квадратные скобки убрать, получится генератор выражения (generator expression). Он не строит список сразу, а возвращает итератор, который вычисляет значения по требованию. Это экономит память на больших данных и позволяет работать с бесконечными последовательностями.

numbers = range(1_000_000)
squares_gen = (n ** 2 for n in numbers)
print(squares_gen)  # <generator object <genexpr> at 0x...>
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

Генератор выражения можно передать напрямую в любую функцию, принимающую итератор: sum, max, min, sorted, any, all. Скобки вокруг выражения в вызове функции не нужны - их уже есть у вызова.

numbers = range(1_000_000)
total = sum(n ** 2 for n in numbers)
print(total)  # 333332833333500000

Ленивость даёт преимущество, когда не все элементы нужны. any и all останавливаются на первом подходящем или неподходящем значении:

numbers = range(1_000_000)
has_large = any(n > 900_000 for n in numbers)
print(has_large)  # True, проверка остановилась на 900001

Сравнение: генератор списка создаёт миллион чисел в памяти, генератор выражения - только один за раз:

import sys

# Генератор списка: весь список в памяти
squares_list = [n ** 2 for n in range(100_000)]
print(sys.getsizeof(squares_list))  # ~800_000 байт + сами объекты int

# Генератор выражения: только объект-генератор
squares_gen = (n ** 2 for n in range(100_000))
print(sys.getsizeof(squares_gen))  # ~200 байт, данные не созданы

Генератор выражения нельзя "перемотать" назад или использовать повторно - после исчерпания он пуст. Если нужен повторный проход, нужно превратить в список или создать новый генератор.

gen = (n ** 2 for n in range(3))
print(list(gen))  # [0, 1, 4]
print(list(gen))  # [], пусто!

Сравнение производительности: генератор списка vs генератор выражения vs map/filter

На небольших данных разница в скорости незаметна, но на миллионах элементов проявляются характерные черты каждого подхода. Измерения на типичном процессоре (Python 3.11+):

import timeit

# 1. Генератор списка - сразу создаёт все объекты в памяти
setup = "numbers = range(1_000_000)"
list_comp = timeit.timeit("[n ** 2 for n in numbers]", setup=setup, number=3)
print(f"list comprehension: {list_comp:.3f} сек")

# 2. Генератор выражения + list() - похожее время, но пиковое потребление ниже
gen_expr = timeit.timeit("list(n ** 2 for n in numbers)", setup=setup, number=3)
print(f"generator expression + list: {gen_expr:.3f} сек")

# 3. map с лямбдой - чуть медленнее из-за вызова функции на каждом шаге
map_lambda = timeit.timeit("list(map(lambda n: n ** 2, numbers))", setup=setup, number=3)
print(f"map + lambda: {map_lambda:.3f} сек")

# 4. map с встроенной функцией (если применимо) - быстрее лямбды
map_pow = timeit.timeit("list(map(pow, numbers, [2]*1_000_000))", setup=setup, number=3)
print(f"map + pow: {map_pow:.3f} сек")

# 5. Только итерация без сохранения - генератор выражения выигрывает
iter_list = timeit.timeit("for _ in [n ** 2 for n in numbers]: pass", setup=setup, number=3)
iter_gen = timeit.timeit("for _ in (n ** 2 for n in numbers): pass", setup=setup, number=3)
print(f"iteration list: {iter_list:.3f} сек, generator: {iter_gen:.3f} сек")

Типичный результат (сек, меньше - лучше):

list comprehension: 0.180 сек
generator expression + list: 0.195 сек
map + lambda: 0.290 сек
map + pow: 0.150 сек
iteration list: 0.140 сек, generator: 0.095 сек

Выводы:
- Генератор списка немного быстрее, когда результат нужен целиком и сразу.
- Генератор выражения выигрывает при ленивой итерации (for, any, all, sum без сохранения).
- map с встроенной функцией может обогнать генератор списка, но map с лямбдой почти всегда медленнее.
- Память: генератор выражения - константные накладные расходы, генератор списка - линейные от размера.

Продвинутые примеры с itertools.chain и сложные цепочки map/filter

Модуль itertools предоставляет инструменты для работы с итераторами, которые сочетаются с map и filter нативно. itertools.chain "склеивает" несколько итераторов в один, не создавая промежуточных списков.

from itertools import chain

# Объединение нескольких диапазонов без создания списков
numbers = chain(range(10), range(20, 30), range(100, 105))
squares = list(map(lambda x: x ** 2, numbers))
print(squares[:5])   # [0, 1, 4, 9, 16]
print(squares[-3:])  # [10000, 10201, 10404]

chain.from_iterable распаковывает итератор итераторов - идеально для выпрямления вложенных структур лениво:

from itertools import chain

matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = chain.from_iterable(matrix)
print(list(flat))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Сложная цепочка: отфильтровать чётные, возвести в куб, взять первые 5, просуммировать - всё лениво, без лишних списков:

from itertools import chain, islice

data = chain(range(100), range(200, 300))
result = sum(
    islice(
        map(lambda x: x ** 3, filter(lambda x: x % 2 == 0, data)),
        5
    )
)
print(result)  # 0^3 + 2^3 + 4^3 + 6^3 + 8^3 = 0 + 8 + 64 + 216 + 512 = 800

Тот же алгоритм через генератор выражения:

from itertools import chain, islice

data = chain(range(100), range(200, 300))
result = sum(
    islice(
        (x ** 3 for x in data if x % 2 == 0),
        5
    )
)
print(result)  # 800

Пример с реальными данными: парсинг лог-файла, отбор ошибок, извлечение кодов, подсчёт уникальных - всё в одной цепочке:

from itertools import chain

log_lines = [
    "2024-01-15 10:00:01 INFO User login",
    "2024-01-15 10:00:05 ERROR 500 Database timeout",
    "2024-01-15 10:00:10 WARN High memory usage",
    "2024-01-15 10:00:15 ERROR 404 Not found",
    "2024-01-15 10:00:20 INFO Request completed",
]

# Ленивая цепочка: split -> filter ERROR -> extract code -> unique -> count
error_codes = set(
    line.split()[3]
    for line in log_lines
    if "ERROR" in line
)
print(error_codes)  # {'500', '404'}
print(len(error_codes))  # 2

Комбинация map/filter с zip для параллельной обработки нескольких последовательностей:

names = ["аня", "борис", "вера"]
ages = [25, 30, 22]
cities = ["Москва", "СПб", "Казань"]

# zip объединяет, map преобразует каждую тройку
profiles = list(map(
    lambda t: f"{t[0]} ({t[1]}), {t[2]}",
    zip(names, ages, cities)
))
print(profiles)  # ['аня (25), Москва', 'борис (30), СПб', 'вера (22), Казань']

# Фильтрация по возрасту через filter
adults = list(filter(
    lambda t: t[1] >= 25,
    zip(names, ages, cities)
))
print(adults)  # [('аня', 25, 'Москва'), ('борис', 30, 'СПб')]

Граница между компактностью и читаемостью кода

Короткий код не равен хорошему. Генератор списка хорош, пока смысл считывается с первого взгляда; как только в строке сплетаются два цикла и пара условий, однострочник превращается в головоломку.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
odds = [x for row in matrix for x in row if x % 2 != 0]
print(odds)  # [1, 3, 5, 7, 9]

Два for подряд уже требуют внимания, хотя такой пример ещё поддаётся расшифровке. А записи вроде [x * y for x in a for y in b if x != y] с дополнительным sorted и срезом на конце новичок разбирает дольше, чем потратил бы на обычный цикл с тем же алгоритмом. Здесь честнее вернуться к развёрнутому циклу: код с именами переменных и понятными шагами проще проверить, отладить и изменить.

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

  1. строка помещается на экран и не требует горизонтальной прокрутки;
  2. вложенных for в ней не больше одного, а if не больше двух;
  3. лямбда умещается в пару слов и не нуждается в переносах;
  4. смысл считывается без комментария над строкой;
  5. через месяц код останется понятным без долгого вглядывания.

Если хотя бы один пункт не выполнен, обычный цикл с append останется лучшим выбором. Генераторы списка, лямбды, map и filter существуют ради читателя, а не ради экономии нажатий клавиш. Владение обоими стилями и отличает уверенного программиста от поклонника фокусов: первый выбирает форму записи под задачу, второй гонится за длиной строки.

Впереди двадцать второй урок, посвящённый датам и регулярным выражениям: модуль datetime научит считать дни между событиями, а модуль re вытащит из строки телефон, почту или дату по шаблону. Инструменты этого урока пригодятся сразу, ведь отбор подходящих строк и чисел из текста генератор списка выполняет одной строчкой.