В прошлом уроке классы забирали атрибуты и методы у родителя, и наследование заметно сократило объём кода. Тот же принцип компактности теперь спускается на уровень списков: 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 и срезом на конце новичок разбирает дольше, чем потратил бы на обычный цикл с тем же алгоритмом. Здесь честнее вернуться к развёрнутому циклу: код с именами переменных и понятными шагами проще проверить, отладить и изменить.
Практический ориентир, которым пользуются многие разработчики, сводится к короткой проверке перед сохранением однострочника:
- строка помещается на экран и не требует горизонтальной прокрутки;
- вложенных for в ней не больше одного, а if не больше двух;
- лямбда умещается в пару слов и не нуждается в переносах;
- смысл считывается без комментария над строкой;
- через месяц код останется понятным без долгого вглядывания.
Если хотя бы один пункт не выполнен, обычный цикл с append останется лучшим выбором. Генераторы списка, лямбды, map и filter существуют ради читателя, а не ради экономии нажатий клавиш. Владение обоими стилями и отличает уверенного программиста от поклонника фокусов: первый выбирает форму записи под задачу, второй гонится за длиной строки.
Впереди двадцать второй урок, посвящённый датам и регулярным выражениям: модуль datetime научит считать дни между событиями, а модуль re вытащит из строки телефон, почту или дату по шаблону. Инструменты этого урока пригодятся сразу, ведь отбор подходящих строк и чисел из текста генератор списка выполняет одной строчкой.