Generators & iterators (1/3)

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

🔸контейнер (container)
🔸итерируемый объект (iterable)
🔸итератор (iterator)
🔸генератор (generator)
🔸генераторное выражение (generator expression)
🔸списковое включение (list comprehension)

Контейнеры
Контейнер — это тип данных, предназначенный для хранения элементов и предоставляющий набор операций для работы с ними. Сами контейнеры и, как правило, их элементы хранятся в памяти. В Python существует масса разнообразных контейнеров, среди которых всем хорошо знакомые:

🔸list, deque, …
🔸set, frozensets, …
🔸dict, defaultdict, OrderedDict, Counter, …
🔸tuple, namedtuple, …
🔸str

📎Технически, объект является контейнером тогда, когда он предоставляет возможность определить наличие или отсутствие в нём конкретного элемента.
📎Обратите внимание, что несмотря на то, что большинство контейнеров предоставляют возможность извлекать из них любой элемент, само по себе наличие этой возможности не делает объект контейнером, а лишь итерируемым объектом.

Итерируемые объекты
Как было уже сказано, большинство контейнеров являются итерируемыми. Но в то же время множество других типов данных являются итерируемыми, например, файлы, сокеты и тому подобные. В то время как контейнеры обычно содержат конечное количество элементов, просто итерируемый объект может представлять собой источник бесконечных данных.

Итерируемым объектом является любой объект, который может предоставить итератор, который, в свою очередь, и возвращает отдельные элементы. На первый взгляд это звучит немного странновато, но тем не менее очень важно понимать разницу между интерируемым объектом и итератором. Рассмотрим пример:

>>> x = [1, 2, 3]
>>> y = iter(x)
>>> z = iter(x)
>>> next(y)
1
>>> next(y)
2
>>> next(z)
1

Здесь х — это итерируемый объект, в то время как y и z два отдельных экземпляра итератора, производящего значения из итерируемого объекта x. Как мы видим, y и z сохраняют состояние между вызовами next(). В данном примере в качестве источника данных для итератора используется список, но это не является обязательным условием.

📎Часто, чтобы сократить объем кода, классы итерируемых объектов имплементируют сразу оба метода: __iter()__ и __next()__, при этом __iter()__ возвращает self. Таким образом класс одновременно является и итерируемым и итератором самого себя. Однако, лучшей практикой всё же считается в качестве итератора возвращать отдельный объект.

#tips #generators

Generators & iterators (2/3)

Итераторы
Итак, чем же является итератор? Итератор — это вспомогательный объект, возвращающий следующий элемент всякий раз, когда выполняется вызов функции __next__() с передачей этого объекта в качестве аргумента. Таким образом, любой объект, предоставляющий метод __next__(), является итератором, возвращающим следующий элемент при вызове этого метода, при этом совершенно неважно как именно это происходит.

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

Существует бесчисленное множество примеров использования итераторов. Например, все функции пакета itertools возвращают итераторы.

📌Некоторые из них генерируют бесконечные последовательности:

>>> from itertools import count
>>> counter = count(start=1)
>>> next(counter)
1
>>> next(counter)
2

📌Некоторые создают бесконечные последовательности из конечных:

>>> from itertools import cycle
>>> colors = cycle(['red', 'white', 'blue'])
>>> next(colors)
'red'
>>> next(colors)
'white'
>>> next(colors)
'blue'
>>> next(colors)
'red’

📌Или конечные последовательности из бесконечных:

>>> from itertools import islice
>>> colors = cycle(['red', 'white', 'blue'])
>>> limited = islice(colors, 0, 4)
>>> for x in limited:                         
...     print(x)
red
white
blue
red

Генераторы
Итак, наконец-то мы добрались до самого интересного! Генераторы являются безумно интересной и полезной штукой в Python. Генератор — это особый, более изящный случай итератора.

Используя генератор, вы можете создавать итераторы, вроде того, что мы рассмотрели выше, используя более лаконичный синтаксис, и не создавая при этом отдельный класс с методами __iter__() и __next__().

Давайте внесём немного ясности:

любой генератор является итератором (но не наоборот!);
следовательно, любой генератор является "ленивой фабрикой", возвращающей значения последовательности по требованию.
Вот пример итератора последовательности чисел Фибоначчи в исполнении генератора:

>>> def fib():
...     a, b = 0, 1
...     while True:
...         yield b
...         a, b = b, a + b
...
>>> f = fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Ну как? Не находите, что это выглядит намного элегантнее простого итератора? Весь секрет кроется в ключевом слове yield. Давайте разберёмся, что к чему.

Во-первых, обратите внимание, что fib является обычной функцией, ничего особенного. Однако же, в ней отсутствует оператор return, возвращающий значение. В данном случае возвращаемым значением функции будет генератор (то есть, по сути, итератор — фабрика значений, сохраняющая состояние между обращениями к ней).

Теперь, когда происходит вызов функции fib

f = fib()

будет создан и возвращён экземпляр генератора. К данному моменту ещё никакого кода внутри функции не выполняется и генератор ожидает вызова.

Дальше созданный экземпляр генератора передаётся в качестве аргумента функции islice, которая также возвращает итератор, следовательно также никакого кода функции fib пока что не выполняется.

И, наконец, происходит вызов list() с передачей в качестве аргумента итератора, возвращённого функцией islice(). Чтобы list() смогла построить объект списка на основе полученного аргумента, ей необходимо получить все значения из этого аргумента. Для этого list() выполняет последовательные вызовы метода next() итератора, возвращённого вызовом islice(), который, в свою очередь, выполняет последовательные вызовы next() в экземпляре итератора f.

#tips #generators

​Generators & iterators (3/3)

Типы генераторов
В Python существует два типа генераторов: генераторные функции и генераторные выражения. Генератором является любая функция, содержащая yield в любом месте её кода. Пример такого генератора мы только что рассмотрели. Другой разновидностью генераторов в Python являются генераторные выражения, своим видом напоминающие списковые выражения. Использование генераторных выражений бывает очень хорошим решением в ряде случаев.

Предположим, вы используете следующую конструкцию, чтобы создать список квадратов чисел:

>>> numbers = [1, 2, 3, 4, 5, 6]
>>> [x * x for x in numbers]
[1, 4, 9, 16, 25, 36]

Или, то же самое, но в виде множества:

>>> {x * x for x in numbers}
{1, 4, 36, 9, 16, 25}

Или в виде словаря:

>>> {x: x * x for x in numbers}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

Или, наконец, используя генераторное выражение (обратите внимание, это НЕ кортеж!):

>>> lazy_squares = (x * x for x in numbers)
>>> lazy_squares
 at 0x10d1f5510>

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

📌Если вы всё ещё не используете генераторы и хотели бы начать делать это, попробуйте начать с того, что обратите внимание на все участки вашего кода, имеющие вид:

def something():
    result = []
    for ... in ...:
        result.append(x)
    return result

И замените их генераторами:

def iter_something():
    for ... in ...:
        yield x

#tips #generators

Чай из itertools

Если вы читали предыдущие посты про итераторы, то примерно представляете как они работают (если нет, ищите по тегу #generators). Итератор обычно выдает значения по одному (с помощью метода __next__, например). Это означает, что получать значения из итератора может только один потребитель. Однако, это можно исправить.

📌tee принимает два аргумента: исходный итератор и количество новых итераторов, на которые разделится исходный. А возвращает он кортеж из новых итераторов.

from itertools import tee

def get_iter():
    for i in range(5):
        yield i

one, two, three = tee(get_iter(), 3)

print(f'next is {next(one)}')
print(f'next is {next(two)}')
for item in three:
    print(f'next is {item}')

Вывод:

next is 0
next is 0
next is 0
next is 1
next is 2
next is 3
next is 4

Видно, что каждый из полученных итераторов по сути является независимой копией исходного get_iter.

Несколько замечаний:
📌Не следует пытаться итерировать исходный get_iter, иначе производные итераторы могут потерять некоторые значения.
📌tee хранит в памяти извлеченные элементы, чтобы остальные потребители могли их получить, даже если исходный итератор уже сместился. Поэтому, если элементов много либо они большие, это может серьезно повлиять на расход памяти.

#tee #iterators