Генераторные выражения в Python
Обновлено:
Мы уже познакомились с итераторами и знаем, что они позволяют последовательно получать элементы, запоминать место остановки и эффективно использовать оперативную память.
Теперь познакомимся с ещё одним важным инструментом Python — генераторными выражениями (generator expressions).
С их помощью можно создавать генераторы практически так же просто, как мы создаём списки через list comprehension.
1. Вспомним генераторы коллекций
Мы уже умеем создавать разные коллекции с помощью компактных конструкций.
Генератор списка — list comprehension
numbers = [number ** 2 for number in range(5)]
print(numbers)
# [0, 1, 4, 9, 16]
Создание кортежа
numbers = tuple(number ** 2 for number in range(5))
print(numbers)
# (0, 1, 4, 9, 16)
Генератор словаря — dict comprehension
numbers = {
number: number ** 2
for number in range(5)
}
print(numbers)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Генератор множества — set comprehension
numbers = {number ** 2 for number in range(5)}
print(numbers)
# {0, 1, 4, 9, 16}
Порядок элементов множества не гарантирован.
Создание frozenset
numbers = frozenset(
number ** 2 for number in range(5)
)
print(numbers)
# frozenset({0, 1, 4, 9, 16})
Важный момент: в Python существуют отдельные конструкции включений (comprehensions) для list, set и dict.
А вот отдельных синтаксических конструкций tuple comprehension и frozenset comprehension нет.
Когда мы пишем:
tuple(number ** 2 for number in range(5))
или:
frozenset(number ** 2 for number in range(5))
мы передаём генераторное выражение в соответствующий класс, который получает из него элементы и создаёт коллекцию.
Именно с таким выражением мы сейчас и познакомимся.
2. Генераторное выражение
Посмотрим на знакомую конструкцию:
number ** 2 for number in range(5)
Это основная часть нашего выражения.
Если заключить её в квадратные скобки:
[number ** 2 for number in range(5)]
получится список.
Но если использовать круглые скобки:
(number ** 2 for number in range(5))
мы получим генераторное выражение.
Например:
numbers = (number ** 2 for number in range(5))
print(numbers)
Результат будет примерно таким:
<generator object <genexpr> at 0x...>
Вместо готового списка мы получили объект генератора.
Проверим его тип:
print(type(numbers))
# <class 'generator'>
Таким образом, генераторное выражение создаёт генератор, а не готовую коллекцию.
3. Генератор является итератором
Мы уже знаем, что итератор можно обойти циклом for.
Попробуем сделать это с генератором:
numbers = (number ** 2 for number in range(5))
for number in numbers:
print(number)
Результат:
0
1
4
9
16
Теперь попробуем обойти тот же генератор ещё раз:
for number in numbers:
print(number)
Ничего не произойдёт.
Почему?
Потому что генератор является разновидностью итератора.
Первый цикл получил все элементы. Генератор исчерпался, поэтому второй цикл уже ничего не вывел.
Если нам нужен новый обход, необходимо создать новый генератор:
numbers = (number ** 2 for number in range(5))
4. Генераторы работают с next()
Поскольку генератор является итератором, мы можем использовать знакомую функцию:
next()
Например:
numbers = (number ** 2 for number in range(5))
print(next(numbers))
# 0
print(next(numbers))
# 1
print(next(numbers))
# 4
Генератор запоминает, где остановился.
Следующий вызов:
print(next(numbers))
# 9
вернёт очередной элемент.
Затем:
print(next(numbers))
# 16
А ещё один вызов:
next(numbers)
приведёт к исключению:
StopIteration
Это означает, что генератор исчерпан.
Как и у любого итератора, мы можем указать значение по умолчанию:
numbers = (number for number in range(2))
print(next(numbers, None))
# 0
print(next(numbers, None))
# 1
print(next(numbers, None))
# None
5. Генератор вычисляет элементы по запросу
Это одна из важнейших особенностей генераторов.
Рассмотрим генератор списка:
numbers = [
number ** 2
for number in range(5)
]
Python сразу выполняет выражение для всех элементов и создаёт готовый список:
[0, 1, 4, 9, 16]
А теперь:
numbers = (
number ** 2
for number in range(5)
)
Здесь новый список не создаётся.
Вместо этого создаётся генератор, который способен последовательно вычислять необходимые значения.
Когда мы вызываем:
next(numbers)
генератор вычисляет и возвращает очередной элемент.
Пока мы не запрашиваем следующие значения, соответствующие вычисления не выполняются.
Такое поведение называется ленивым вычислением (lazy evaluation).
6. Генераторы экономят оперативную память
Сравним список и генератор.
Для этого используем знакомую функцию:
getsizeof()
из модуля sys.
from sys import getsizeof
numbers_list = [
number
for number in range(10_000)
]
numbers_generator = (
number
for number in range(10_000_000)
)
print(getsizeof(numbers_list))
print(getsizeof(numbers_generator))
В CPython список из 10 000 элементов обычно занимает десятки тысяч байт, а сам объект генератора — порядка нескольких сотен байт.
При этом генератор рассчитан на получение десяти миллионов значений!
Почему такая большая разница?
Список хранит ссылки на все свои элементы.
В типичной 64-битной версии CPython одна ссылка занимает 8 байт.
Поэтому для 10 000 элементов только ссылки занимают примерно:
10 000 × 8 = 80 000 байт
Но помимо ссылок существуют и сами объекты целых чисел.
В распространённых сборках CPython небольшое целое число может занимать около 28 байт.
Поэтому суммарная память, связанная со списком из 10 000 чисел, может составлять несколько сотен килобайт.
При этом getsizeof(numbers_list) показывает непосредственный размер списка, но не включает размеры объектов, на которые он ссылается.
Дополнительно можно посмотреть:
from sys import getsizeof
numbers = list(range(10_000))
list_size = getsizeof(numbers)
elements_size = sum(
getsizeof(number)
for number in numbers
)
print(list_size)
print(elements_size)
print(list_size + elements_size)
Последняя сумма демонстрирует приблизительную стоимость списка вместе с его элементами.
Это не точное измерение дополнительной занятой памяти: некоторые объекты могут использоваться совместно с другими частями программы.
А что хранит генератор?
Генератор не создаёт заранее десять миллионов чисел.
Он хранит состояние вычислений и информацию, необходимую для получения очередных значений.
Поэтому его собственный размер не растёт пропорционально количеству будущих элементов.
Важно: генератор может удерживать ссылки на другие объекты, например исходную коллекцию. Поэтому маленький размер объекта генератора не всегда означает столь же маленький общий расход памяти.
Но когда данные можно получать постепенно, генераторы позволяют обрабатывать огромные последовательности без создания промежуточного списка.
7. Генератор можно передать в sum()
Предположим, мы хотим получить сумму квадратов чисел.
Создадим генератор:
numbers = (
number ** 2
for number in range(5)
)
Теперь передадим его в:
sum()
print(sum(numbers))
# 30
Функция sum() последовательно получает элементы генератора и складывает их.
После этого генератор исчерпан.
Поэтому:
print(sum(numbers))
# 0
Второй вызов возвращает 0, потому что элементов больше нет.
Это ещё раз показывает, что генератор можно использовать только до его исчерпания.
8. Генераторное выражение непосредственно в функции
В предыдущем примере мы сначала создали переменную:
numbers = (
number ** 2
for number in range(5)
)
А затем передали генератор в sum().
Но часто отдельная переменная вообще не нужна.
Можно написать:
result = sum(
number ** 2
for number in range(5)
)
print(result)
# 30
Здесь генераторное выражение создаётся прямо внутри вызова функции.
Обратите внимание: мы не добавили вторую пару круглых скобок.
Когда генераторное выражение является единственным аргументом функции, дополнительные скобки можно опустить.
То есть эти два варианта эквивалентны:
sum(number ** 2 for number in range(5))
sum((number ** 2 for number in range(5)))
Первый обычно выглядит лучше.
Если у функции есть другие аргументы, генераторное выражение необходимо заключать в собственные круглые скобки.
Например:
sum(
(number ** 2 for number in range(5)),
100,
)
Здесь 100 — начальное значение суммы.
9. Генераторное выражение в sorted()
Предположим, у нас есть числа:
numbers = [5, -2, 3, -4, 1]
Мы хотим:
- Возвести каждое число в квадрат.
- Отсортировать полученные значения.
- Получить новый список.
Можно использовать генератор списка:
result = sorted([
number ** 2
for number in numbers
])
print(result)
# [1, 4, 9, 16, 25]
Этот вариант работает, но сначала создаёт промежуточный список квадратов, а затем sorted() создаёт отсортированный список.
Более удобный вариант:
result = sorted(
number ** 2
for number in numbers
)
print(result)
# [1, 4, 9, 16, 25]
Теперь мы передаём в sorted() генераторное выражение.
Python не создаёт отдельный список квадратов перед вызовом sorted().
При этом сама функция sorted() всё равно должна получить значения и создать итоговый список, необходимый для сортировки.
То есть здесь мы экономим память на промежуточной коллекции, а не выполняем сортировку без хранения элементов.
10. Генераторные выражения в max() и min()
Аналогично можно использовать генератор с функциями:
max()
min()
Например:
numbers = [3, 7, 2, 9, 4]
result = max(
number ** 2
for number in numbers
)
print(result)
# 81
Или:
numbers = [-10, -5, 3, 8]
result = min(
abs(number)
for number in numbers
)
print(result)
# 3
Здесь генераторное выражение вычисляет значения по мере необходимости.
Функциям min() и max() не требуется создавать полный список обработанных значений для поиска минимального или максимального элемента.
Это делает такой подход особенно полезным для больших последовательностей.
11. Генераторное выражение в join()
Ещё один интересный пример — строковый метод:
join()
Предположим, у нас есть список слов:
words = [
' python ',
' sql ',
' django ',
]
Мы хотим удалить пробелы по краям каждого слова, перевести слова в верхний регистр и объединить их через запятую.
Можно написать:
result = ', '.join(
word.strip().upper()
for word in words
)
print(result)
Результат:
PYTHON, SQL, DJANGO
Что происходит?
Сначала генераторное выражение последовательно применяет:
word.strip().upper()
к каждому слову.
А join() объединяет полученные строки через:
', '
Таким образом, мы смогли совместить преобразование элементов и их объединение в одной конструкции.
Важный нюанс: реализация join() может внутренне собирать временную последовательность элементов. Поэтому генераторное выражение здесь прежде всего избавляет нас от необходимости явно создавать промежуточный список, но не гарантирует минимальный расход памяти.
12. Генераторные выражения с условием if
Как и в list comprehension, внутри генераторного выражения можно использовать условие.
Например:
numbers = [10, -5, 20, -15, 30]
result = sum(
number
for number in numbers
if number > 0
)
print(result)
# 60
Здесь генератор отдаёт только положительные числа.
А sum() складывает их.
Мы совместили:
- обход коллекции;
- фильтрацию;
- вычисление суммы.
И нам не потребовалось создавать дополнительный список.
13. Генераторные выражения в any() и all()
Мы уже знакомы с двумя встроенными функциями:
any()
all()
Они особенно хорошо сочетаются с генераторными выражениями.
Например, проверим, есть ли среди чисел хотя бы одно отрицательное:
numbers = [10, 20, -5, 30]
result = any(
number < 0
for number in numbers
)
print(result)
# True
Генератор последовательно возвращает результаты сравнений:
False
False
True
...
Как только any() получает первое True, проверка заканчивается.
А теперь проверим, все ли числа положительные:
numbers = [10, 20, 30]
result = all(
number > 0
for number in numbers
)
print(result)
# True
Здесь генератор возвращает логические значения, а all() проверяет, что все они истинные.
Обе функции поддерживают короткое замыкание, поэтому могут завершить обход генератора досрочно.
14. Генераторное выражение в extend()
Мы уже знаем метод списка:
extend()
Он добавляет элементы итерируемого объекта в существующий список.
Например:
numbers = [10, 20]
numbers.extend(
number ** 2
for number in range(3, 6)
)
print(numbers)
Результат:
[10, 20, 9, 16, 25]
Здесь генератор последовательно возвращает квадраты чисел:
9
16
25
А extend() добавляет их в исходный список.
Промежуточный список квадратов создавать не требуется.
15. Генераторное выражение в dict.fromkeys()
Генератор можно передать и в уже знакомый метод:
dict.fromkeys()
Например:
words = [
'Python',
'SQL',
'Django',
]
result = dict.fromkeys(
(word.lower() for word in words),
0,
)
print(result)
Результат:
{
'python': 0,
'sql': 0,
'django': 0,
}
Генератор создаёт ключи, переводя строки в нижний регистр.
А dict.fromkeys() создаёт словарь, в котором каждому ключу соответствует значение 0.
Здесь дополнительные круглые скобки вокруг генераторного выражения необходимы, поскольку в fromkeys() мы передаём два аргумента.
16. Генераторы можно передавать в конструкторы коллекций
Как и любой итерируемый объект, генератор можно передать в:
list()
tuple()
set()
frozenset()
Например:
numbers = (number ** 2 for number in range(5))
print(tuple(numbers))
# (0, 1, 4, 9, 16)
Аналогично:
numbers = (number ** 2 for number in range(5))
print(set(numbers))
# {0, 1, 4, 9, 16}
Но важно помнить: такие операции получают все элементы генератора и создают полноценные коллекции.
Сам генератор после этого будет исчерпан.
Поэтому, если итоговая коллекция вообще не нужна, обычно лучше не преобразовывать генератор в список только ради того, чтобы обойти его.
17. Распаковка генератора
Генераторы поддерживают уже знакомую распаковку через *.
Например:
numbers = (number ** 2 for number in range(5))
print(*numbers)
Результат:
0 1 4 9 16
При этом распаковка получает все элементы, поэтому генератор исчерпывается.
18. Множественное присваивание
Генератор можно распаковать и через множественное присваивание:
numbers = (number ** 2 for number in range(3))
first, second, third = numbers
print(first)
# 0
print(second)
# 1
print(third)
# 4
Если количество полученных элементов не совпадает с количеством переменных, возникнет ValueError.
Также можно использовать звёздочку:
numbers = (number for number in range(5))
first, *middle, last = numbers
print(first)
# 0
print(middle)
# [1, 2, 3]
print(last)
# 4
Здесь middle становится списком, содержащим промежуточные значения.
19. Длина и индексация генератора
Генератор не поддерживает обычное получение длины через:
len()
Например:
numbers = (number for number in range(5))
print(len(numbers))
Получим исключение:
TypeError
Аналогично не поддерживается обращение по индексу:
numbers[0]
Это тоже приведёт к TypeError.
Генератор предназначен для последовательного получения элементов через next() или цикл for, а не для произвольного обращения по индексам.
20. Логическое значение генератора
Посмотрим:
numbers = (number for number in range(3))
print(bool(numbers))
# True
Теперь полностью обойдём его:
print(list(numbers))
# [0, 1, 2]
Повторим проверку:
print(bool(numbers))
# True
Хотя генератор уже исчерпан, результат остался True.
Так происходит потому, что обычный генератор не определяет логическое значение через количество оставшихся элементов.
Поэтому такой код:
if numbers:
print('Генератор не пуст')
не позволяет проверить, остались ли элементы в генераторе.
Это важное отличие генераторов от привычных коллекций.
21. Методы генератора
Посмотрим, какие атрибуты и методы есть у генератора:
numbers = (number for number in range(5))
print(dir(numbers))
Мы увидим довольно много служебных имён, в том числе:
send
throw
close
Эти методы позволяют управлять работой генератора.
Но для их полноценного понимания нам необходимо познакомиться с ключевым словом:
yield
Эту тему разберём позже.
Пока для работы с генераторными выражениями достаточно знакомых нам инструментов:
iter()
next()
и цикла:
for
Аннотация генератора
22. Generator из collections.abc
Для аннотации генераторов существует специальный класс:
Generator
Импортируем:
from collections.abc import Generator
Теперь можем аннотировать переменную:
from collections.abc import Generator
numbers: Generator[int, None, None] = (
number ** 2
for number in range(5)
)
В такой записи:
Generator[int, None, None]
первый параметр:
int
описывает тип значений, которые отдаёт генератор.
Остальные два параметра относятся к дополнительным возможностям генераторов, которые мы изучим вместе с yield.
Пока для обычного генераторного выражения достаточно знать эту форму записи.
23. Можно использовать Iterator
Мы уже знаем, что генератор является итератором.
Поэтому его можно аннотировать и так:
from collections.abc import Iterator
numbers: Iterator[int] = (
number ** 2
for number in range(5)
)
Или ещё более общим образом:
from collections.abc import Iterable
numbers: Iterable[int] = (
number ** 2
for number in range(5)
)
Но эти аннотации сообщают анализатору разное количество информации.
| Аннотация | Что она гарантирует |
|---|---|
Iterable[int] |
Объект можно обходить, получая int |
Iterator[int] |
Объект поддерживает получение следующего int через next() |
Generator[int, None, None] |
Объект является генератором с соответствующими типами |
Для обычного генераторного выражения часто достаточно аннотации:
Iterator[int]
Если же мы хотим явно показать, что объект является генератором, используем Generator.
24. Проверка через isinstance()
Объекты Iterable, Iterator и Generator из модуля collections.abc можно использовать с:
isinstance()
Например:
from collections.abc import (
Generator,
Iterable,
Iterator,
)
numbers = (number for number in range(5))
print(isinstance(numbers, Iterable))
# True
print(isinstance(numbers, Iterator))
# True
print(isinstance(numbers, Generator))
# True
Почему везде True?
Потому что генератор:
- является итерируемым объектом;
- является итератором;
- поддерживает специальный интерфейс генератора.
Дополнительно проверим:
print(iter(numbers) is numbers)
# True
Как и у других итераторов, вызов iter() с уже существующим генератором возвращает сам генератор.
25. Когда использовать список, а когда генератор
Генератор не всегда является лучшим выбором.
Например, если нам требуется несколько раз обращаться к элементам по индексам:
numbers[0]
numbers[5]
лучше использовать список.
То же самое, если мы хотим многократно обходить одну и ту же готовую коллекцию без повторного вычисления значений.
Но если наша задача — один раз последовательно обработать элементы, генератор часто оказывается очень удобным.
Например:
result = sum(
number ** 2
for number in range(1_000_000)
)
Здесь нет необходимости создавать список из миллиона квадратов чисел.
Мы просто последовательно вычисляем значения и передаём их в sum().
Краткое сравнение
| Особенность | Список | Генератор |
|---|---|---|
| Создаёт все элементы сразу | Да | Нет |
| Вычисляет значения по запросу | Нет | Да |
| Поддерживает индексацию | Да | Нет |
Поддерживает len() |
Да | Нет |
| Можно многократно обходить | Да | Нет, после исчерпания |
Работает с next() напрямую |
Нет | Да |
| Хранит все полученные элементы | Да | Обычно нет |
| Подходит для последовательной обработки больших объёмов данных | Да, но требует памяти для списка | Часто особенно удобен |
Главное по теме
Генераторное выражение — это компактный способ создать генератор.
Например:
numbers = (
number ** 2
for number in range(5)
)
Генератор является разновидностью итератора, поэтому поддерживает его основные свойства.
Основные особенности генератора
- Ленивые вычисления. Значения вычисляются по мере запроса.
- Экономия памяти. Не требуется заранее создавать коллекцию со всеми результатами.
- Сохранение состояния. Генератор помнит, где остановился.
- Однократный обход. После исчерпания генератор не начинается заново.
- Поддержка
next(). Можно вручную получать очередные элементы. - Поддержка
for. Генератор можно обходить обычным циклом. - Совместимость с итерируемыми интерфейсами. Его можно передавать в
sum(),sorted(),min(),max(),join(),extend()и другие функции и методы, принимающие итерируемые объекты. - Распаковка. Поддерживаются
*и множественное присваивание. - Нет обычной длины и индексов.
len()и обращение через[index]не поддерживаются. - Проверка через
bool()не показывает исчерпанность. Обычный генератор остаётся истинным даже после получения всех элементов.
Чаще всего генераторное выражение удобно использовать непосредственно внутри функции:
result = sum(
number ** 2
for number in range(100)
)
или:
result = sorted(
word.upper()
for word in ['python', 'sql', 'django']
)
Так мы можем объединять обход, преобразование, фильтрацию и последующую обработку элементов без необходимости явно создавать промежуточную коллекцию.
В дальнейшем мы познакомимся с ключевым словом yield и научимся создавать более сложные генераторы при помощи обычных функций.