Функция генератор python это

Функция генератор python это

Генераторы Python: что это такое и зачем они нужны

Генераторы используют, чтобы оперативная память не давилась большими объёмами информации. В Python это фишки, экономящие память.

Допустим, у вас есть файл, который весит десяток гигабайт. Из него нужно выбрать и обработать строки, подходящие под какое-то условие, а то и сравнить со строками другого большого файла.

Другой пример: нужно проанализировать практически бесконечный поток данных. Это могут быть, например, показания счётчиков, биржевые котировки, сетевой трафик.

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

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

Программист, консультант, специалист по документированию. Легко и доступно рассказывает о сложных вещах в программировании и дизайне.

Что такое генератор и как он работает?

• Генератор — это объект, который сразу при создании не вычисляет значения всех своих элементов.
• Он хранит в памяти только последний вычисленный элемент, правило перехода к следующему и условие, при котором выполнение прерывается.
• Вычисление следующего значения происходит лишь при выполнении метода next(). Предыдущее значение при этом теряется.

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

Рассмотрим пример: создадим объект-генератор gen с помощью так называемого генераторного выражения. Он будет считать квадраты чисел от 1 до 4 — такую последовательность создаёт функция range(1,5).

Когда мы выведем на консоль переменную gen, то увидим лишь сообщение, что это объект-генератор.

При четырёх вызовах метода next(a) будут по одному рассчитываться и выводиться на консоль значения генератора: 1, 4, 9, 16. Причём в памяти будет сохраняться только последнее значение, а предыдущие сотрутся.

Когда мы попытаемся вызвать next(gen) в пятый раз, генератор сотрёт из памяти последний элемент (число 16) и выдаст исключение StopIteration.

Всё! Генератор больше не работает. Сколько бы мы ни вызывали next(gen), ничего считаться не будет. Чтобы запустить генератор ещё раз, придётся создавать его заново.

И что, для вычисления генератора придётся много раз вызывать next()?

Нет, значения можно вычислять в цикле for. В этом случае метод next() вызывается неявно. Например:

Когда весь цикл пройден, произойдёт исключение StopIteration. Хотя на консоль сообщение об этом не выводится, но генератор помнит о нём и больше работать не будет. То есть цикл for можно запускать только один раз, во второй раз не получится. Нельзя об этом забывать.

И чем помогут генераторы в наших задачах?

Для этого сначала рассмотрим упрощённый способ создания генератора — с помощью генераторного выражения.

Генераторные выражения позволяют создавать объект-генератор в одну строчку. В общем случае их пишут по шаблону:

( выражение for j in итерируемый объект if условие)

Где for, in, if — ключевые слова, j — переменная.

Пример генераторного выражения мы рассмотрели выше. Теперь посмотрим, как можно применить его для обработки большого файла.

Перед нами задача: на сервере есть огромный журнал событий log.txt, в котором хранятся сведения о работе какой-то системы за год. Из него нужно выбрать и обработать для статистики данные об ошибках — строки, содержащие слово error.

Такие строки можно выбрать и сохранить в памяти с помощью списка:

Здесь path — путь к файлу log. В результате сформируется список вида:

[строка1, строка2, строка3, ….. ]

В списке e_l содержатся все строки со словом error, они записаны в память компьютера. Теперь их можно обработать в цикле. Недостаток метода в том, что, если таких строк будет слишком много, они переполнят память и вызовут ошибку MemoryError.

Переполнения памяти можно избежать, если организовать поточную обработку данных с использованием объекта-генератора. Мы создадим его с помощью генераторного выражения (оно отличается от генератора списка только круглыми скобками).

Рассмотрим следующий код:

• Генераторное выражение возвращает объект-генератор err_gen.
• Генератор начинает в цикле выбирать из файла по одной строке со словом error и передавать их на обработку.
• Обработанная строка стирается из памяти, а следующая записывается и обрабатывается. И так до конца цикла.

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

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

Как ещё можно создавать генераторы?

Генераторные выражения — это упрощённый вариант функций-генераторов, также создающих генераторы.

Функция-генератор отличается от обычной функции тем, что вместо команды return в ней используется yield. И если return завершает работу функции, то инструкция yield лишь приостанавливает её, при этом она возвращает какое-то значение.

При первом вызове метода next() выполняется код функции с первой команды до yield. При втором next() и последующих до конца генератора — код со следующей после yield команды и до тех пор, пока yield не встретится снова.

Чтобы было понятнее, рассмотрим небольшой пример:

Здесь функция f_gen(5) при вызове создаёт генератор a. Мы видим это, когда выводим a на консоль.

Посчитаем значения генератора в цикле for.

• При первой итерации выполняется код функции до yield: переменная s = 1, n = 1, yield возвращает 2.
• При второй итерации выполняется оператор после yield, далее к началу цикла и опять до yield: s = 2, n = 2, yield возвращает 6.
• Соответственно, при третьей и четвёртой итерации генерируются значения 12 и 20, после чего выполнение генератора прекращается.

Как видим, значения переменных n и s между вызовами сохраняются.

Yield — инструмент очень гибкий. Его можно несколько раз использовать в коде функции-генератора. В этом случае команды yield служат разделителями кода: при первом вызове метода next() выполняется код до первого yield, при следующих вызовах — операторы между yield. При этом в генераторной функции необязательно должен быть цикл, все значения генератора и так посчитаются.

Как создать бесконечную последовательность

Рассмотрим, как можно с помощью генератора создать математическую последовательность, например, программу, генерирующую простые числа (напоминаем, это числа, не имеющие делителей, кроме 1).

Наша программа будет последовательно анализировать целые числа больше 1. Для каждого числа n программа ищет делители в диапазоне от 2 до √n. Если делители есть, программа переходит к следующему числу. Если их нет, значит, n — число простое, и программа выводит его на печать.

Этот код выдаёт бесконечную последовательность простых чисел без ограничения сверху. Остановить его можно только вручную.

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

Какие ещё методы есть у генераторов?

Когда-то был один next(), но в Python 2.5 появилось ещё три метода:

• .close() — останавливает выполнение генератора;
• .throw() — генератор бросает исключение;
• .send() — интересный метод, позволяет отправлять значения генератору.

Рассмотрим пару небольших примеров.

Сначала на .close() и .throw():

Программа создаёт два генератора, возвращающих бесконечную последовательность квадратов чисел. Их выполнение прекращается с помощью методов .close() и .throw().

Пример использования .send()

Здесь мы не получаем значения генератора, а отправляем их на обработку с помощью метода .send().

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

Что ещё можно сказать

С изучения генераторов начинается освоение последовательной обработки гигантских потоков данных. Это может быть, например, трейдинг и технический анализ в биржевых операциях.

Но даже если не говорить о глобальных задачах, скрипты с применением генераторов — это способ избежать копирования данных в память. Генераторы позволяют экономить ресурсы компьютера и создавать красивый чистый код.

Изучить генераторы и другие объекты Python можно на курсах в Skillbox. Вы получите серьёзные теоретические знания и практический опыт. С самого начала обучения будете участвовать в реальных проектах. Те, кто успешно окончит курсы, станут программистами middle-уровня, а мы поможем найти хорошую работу.

№30 Генераторы / для начинающих

В этой статье вы научитесь создавать и использовать функции и выражения генераторов в Python. Также узнаете, зачем и когда их стоит использовать в программах. Будут рассмотрены основные отличия от итераторов и обычных функций.

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

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

Генератор предоставляет способ создания итераторов, решая следующую распространенную проблему.

Создание итератора в Python — достаточно громоздкая операция. Для этого нужно написать класс и реализовать методы __iter__() и __next__() . После этого требуется настроить внутренние состояния и вызывать исключение StopIteration , когда больше нечего возвращать.

Как создать генератор в Python?

Генератор — это альтернативный и более простой способ возвращать итераторы. Процедура создания не отличается от объявления обычной функции.

Есть два простых способа создания генераторов в Python.

Функция генератора

Генератор создается по принципу обычной функции.

Отличие заключается в том, что вместо return используется инструкция yield . Она уведомляет интерпретатор Python о том, что это генератор, и возвращает итератор.

Синтаксис функции генератора:

Return всегда является последней инструкцией при вызове функции, в то время как yield временно приостанавливает исполнение, сохраняет состояние и затем может продолжить работу позже.

Дальше простейший пример функции генератора Python, которая определяет следующее значение в последовательности Фибоначчи.

Демонстрация функции генератора Python:

В этом примере в функции генератора есть цикл while, который вычисляет следующее значение Фибоначчи. Инструкция yield является частью цикла.

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

Такая функция не будет выполняться до тех пор, пока не будет вызван метод next() с вернувшимся объектом в качестве аргумента (то есть fib ). Для итерации повторим все шаги шесть раз.

Первые пять вызовов next() были успешными и возвращали соответствующий элемент последовательности Фибоначчи. А вот последний вернул исключение StopIteration , поскольку элементов, которые можно было бы вернуть, больше не осталось.

Вот что будет выведено после выполнения.

1
2
3
5
8
Traceback (most recent call last):
File «C:/Python/Python3/python_generator.py», line 29, in
print(next(fib))
StopIteration

Выражение генератора

Python позволяет писать выражения генератора для создания анонимных функций генератора. Процесс напоминает создание лямбда-функций для создания анонимных функций.

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

Еще одно отличие между «list comprehension» и «выражением генератора» в том, что при создании списков возвращается целый список, а в случае с генераторами — только одно значение за раз.

Пример выражение генератора Python:

В примере выше out вернет список со значениями, возведенными в квадрат. То есть, сразу готовый результат.

Выражение генератора вернет итератор, который будет выдавать по одному значению за раз. В списке 4 элемента. Таким образом четыре последовательных вызова метода next() напечатают квадратные корни соответствующих элементов списка.

Но поскольку метод был вызван 5 раз, то вернулось также исключение StopIteration .

[2.00, 4.0, 8.00, 16.0]
at 0x000000000359E308>
2.0
4.0
8.0
16.0
Traceback (most recent call last):
File «C:/Python/Python3/python_generator.py», line 17, in
print(next(out))
StopIteration

Как использовать генератор в Python?

Теперь пришло время разобраться с тем, как использовать генератор в программах. В прошлых примерах метод next() применялся по отношению к итератору, который возвращала функция генератора.

С помощью метода next()

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

В примере ниже значения выводятся с помощью генератора.

Демонстрация генератора next():

Этот пример не отличается от предыдущих, но каждый элемент здесь возвращается генератором с помощью метода next() . Для этого сперва создается объект генератора gen , который является идентификатором, хранящим состояние генератора.

Каждый вызов next() объекта генератора приводит к выполнению вплоть до инструкции yield. Затем Python возвращает значение и сохраняет состояние для последующего использования.

Использование цикла for

Также можно использовать цикл for для итерации по объекту генератора. В этом случае вызов next() происходит неявно, но элементы все равно возвращаются один за одним.

Генератор для демонстрации цикла:

Return vs. yield

Ключевое слово return — это финальная инструкция в функции. Она предоставляет способ для возвращения значения. При возвращении весь локальный стек очищается. И новый вызов начнется с первой инструкции.

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

Генератор vs. функция

Дальше перечислены основные отличия между генератором и обычной функцией.

• Генератор использует yield для отправления значения пользователю, а у функции для этого есть return ;
• При использовании генератора вызовов yield может быть больше чем один;
• Вызов yield останавливает исполнение и возвращает итератор, а return всегда выполняется последним;
• Вызов метода next() приводит к выполнению функции генератора;
• Локальные переменные и состояния сохраняются между последовательными вызовами метода next() ;
• Каждый дополнительный вызов next() вызывает исключение StopIteration , если нет следующих элементов для обработки.

Дальше пример функции генератора с несколькими yield .

Вывод будет такой.

Первый yield
Второй yield
Последний yield

Когда использовать генератор?

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

• Генераторы помогают обрабатывать большие объемы данных. Они позволяют производить так называемые ленивые вычисления. Подобным образом происходит потоковая обработка.
• Генераторы можно устанавливать друг за другом и использовать их как Unix-каналы.
• Генераторы позволяют настроить одновременное исполнение
• Они часто используются для чтения крупных файлов. Это делает код чище и компактнее, разделяя процесс на более мелкие сущности.
• Генераторы особенно полезны для веб-скрапинга и увеличения эффективности поиска. Они позволяют получить одну страницу, выполнить какую-то операцию и двигаться к следующей. Этот подход куда эффективнее чем получение всех страниц сразу и использование отдельного цикла для их обработки.

Зачем использовать генераторы?

Генераторы предоставляют разные преимущества для программистов и расширяют особенности, которые проявляются во время выполнения.

Удобные для программистов

Генератор кажется сложной концепцией, но его легко использовать в программах. Это хорошая альтернатива итераторам.

Рассмотрим следующий пример реализации арифметической прогрессии с помощью класса итератора.

Создание арифметической прогрессии с помощью класса итератора:

Генераторы Python. Их создание и использование

Приходилось ли вам когда-либо работать с настолько большим набором данных, что он переполнял память вашего компьютера? Или быть может у вас была сложная функция, для которой нужно было бы сохранять внутреннее состояние при вызове? А если при этом функция была слишком маленькой, чтобы оправдать создание собственного класса? Во всех этих случаях вам придут на помощь генераторы Python и ключевое слово .

Прочитав эту статью, вы узнаете:

• Что собой представляют генераторы Python и как их использовать
• Как задавать функции и выражения создающие генераторы
• Как работает в Python ключевое слово yield

Если вы являетесь Питонистом начального или среднего уровня и вы заинтересованы в том, чтобы научиться работать с большими наборами данных в питоновском стиле, то скорее всего это руководство для вас.

По ссылке ниже вы можете скачать копию файла с данными, используемыми в этом руководстве.

Использование Генераторов

Функции генераторов (их описание можно почитать в PEP 255) представляют собой особый вид функций, которые возвращают «ленивый итератор». И хотя содержимое этих объектов вы можете перебирать также как и списки, но при этом, в отличие от списков, ленивые итераторы не хранят свое содержимое в памяти. Чтобы составить общее представление об итераторах в Python взгляните на статью Python “for” Loops (Definite Iteration).

Теперь, когда вы имеете примерное представление о том, чем является генератор, у вас наверняка появилось желание увидеть как он работает. Давайте рассмотри два примера. В первом вы увидите общий принцип работы генераторов. В последующих у вас будет возможность изучить работу генераторов более подробно.

Пример 1: Чтение больших файлов

Списки Python

Работа с потоками данных и большими файлами, такими например как CSV, являются наиболее распространенными вариантами использования генераторов. Давайте возьмем CSV файл (CSV является стандартным форматом для обмена данными, колонки в нем разделяются при помощи запятых). Предположим, что вы хотите посчитать количество имеющихся в нем рядов. Код ниже предлагает один из путей для, того, чтобы осуществить это:

Глядя на этот пример, вы можете предположить что csv_gen является списком. Для того чтобы заполнить этот список, csv_reader() открывает файл и загружает его содержимое в csv_gen . Затем программа перебирает список, увеличивая значение row_count для каждого следующего ряда.

Это вполне приемлемое решение, но будет ли этот подход работать, если файл окажется слишком большим? А что если файл окажется больше чем вся доступная память, которая есть в нашем распоряжении? Для того чтобы ответить на этот вопрос, давайте предположим, что csv_reder() будет открывать файл и считывать его в массив.

Эта функция открывает данный файл и использует file.read() вместе со .split() для того, чтобы добавить каждый ряд данных как отдельный элемент списка. Если бы вы использовали эту версию cvs_reader() в блоке кода с подсчетом (вы его увидите далее), тогда бы вы увидели следующее сообщение:

В этом случае open() возвращает объект генератора, который вы можете «лениво» (не обсчитывая заранее) перебирать ряд за рядом. Тем не менее, file.read().split() загружает все данные в память сразу, вызывая ошибку памяти (MemoryError).

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

Генераторы Python

Давайте взглянем на новое определение функции csv_reader() :

В этой версии вы открываете файл и проходите его содержимое, возвращая ряд за рядом. Этот код выводит следующий результат без каких-либо ошибок:

Почему так получилось? Да потому что вы по сути превратили функцию csv_reader() в генератор. Эта версия кода открывает файл, проходит по строкам и извлекает для чтения лишь отдельный ряд, вместо того, чтобы возвращать весь файл целиком.

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

Такой способ создания генератора csv_gen является более лаконичным.

Более подробно о yield мы расскажем позже, а пока запомните основные отличия между использованием ключевых слов yield и return:

• Использование приведет к созданию генератора.
• Использование приведет к возврату только первой строки файла.

Пример 2: Создание бесконечной последовательности

Давайте теперь в качестве другого примера рассмотрим генератор бесконечной последовательности. В Python для того, чтобы получить конечную последовательность мы обычно вызываем функцию range() . Затем мы передаем ее значение как аргумент в функцию list() :

Создание же бесконечной последовательности стопроцентно потребует от нас использования генератора. Причина проста — ограниченность памяти нашего компьютера.

Этот блок кода не велик и хорошо смотрится. Сперва, мы задаем переменную num и создаем бесконечный цикл. Затем мы немедленно извлекаем num с помощью yield в ее исходном состоянии (это во многом повторяет то, что делает range()) . После этого мы увеличиваем num на 1.

Если вы попробуете запустить этот код в теле цикла for, то увидите, что на самом деле он бесконечный:

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

Вместо использования Loop, вы также можете использовать на генераторе функцию next() . Это окажется особенно удобным при тестировании работы генератора в консоли:

Здесь у нас показан генератор, под названием gen , который мы можем вручную перебирать с помощью вызова функции next() . Это работает как отличная проверка. Она позволяет нам убедиться что генератор выдает результат, который мы от него ожидаем.

Примечание: Когда мы используем next() , Python вызывает метод .__next__() , для функции, которая передается в качестве аргумента. При этом существуют специальные возможности, но разговор о них находится за рамками данной статьи. Если вам интересно, попробуйте поменять аргументы, которые передаются в next() и посмотрите на результат.

Пример 3: Нахождение палиндромов

Вы можете использовать бесконечные последовательности множеством различных способов. Одним из них, который мы отметим особенно, является создание детектора палиндромов. Детектор палиндромов выявляет все последовательности букв и цифр, которые являются палиндромами. Это слова или числа, которые читаются одинаково вперед и назад, как «121» например. Сперва давайте зададим наш числовой детектор палиндромов:

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

В консоли выводятся только те номера, которые читаются одинаково и вперед и назад.

Примечание: на практике вам вряд ли придется писать свой собственный бесконечный генератор последовательностей, по той простой причине, что есть уже очень эффективный генератор itertools.count() из модуля .

Теперь, когда вы познакомились с простым примером использования генератора бесконечной последовательности, давайте рассмотрим более детально работу этого генератора.

Понимание работы генератора Python

К этому моменту вы уже познакомились с двумя основными способами создания генераторов: с помощью функции и с помощью выражения. У вас также должно было сформироваться интуитивное представление о том, как работает генератор. Давайте теперь уделим некоторое время тому, чтобы сделать наши знания более четкими.

Функции генераторов выглядят и действуют как обычные функции, но с одной определяющей особенностью. А именно, функция генератора используют ключевое слово yield вместо return . Давайте вспомним функцию генератора, которую мы написали ранее:

Это похоже на типичное определение функции, за исключением yield и кода, который следует за ним. Ключевое слово yield применяется там, где значение нужно отправить обратно вызывающей стороне. Но в отличие от return , выхода из функции в данном случае не происходит. Вместо этого, при возврате состояние функции запоминается. Более того, когда next() вызывается для объекта-генератора (явно или неявно в цикле for), ранее полученная переменная num увеличивается, а затем возвращается снова. Поскольку функции генератора похожи на другие функции и действуют подобным образом, вы можете предположить, что выражения создающие генераторы очень похожи на другие выражениях в Python создающие объекты.

Примечание. Если вы хотите больше узнать о генераторах списков, множеств и словарей в Python, можете прочитать статью Эффективное использование генераторов списков (англ).

Создание генератора с помощью выражения

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

Давайте для примера возьмем возведение в квадрат некоторых чисел:

И nums_squared_lc , и nums_squared_gc выглядят практически одинаково, но есть одно ключевое отличие. Вы сможете его заметить? Для первого объекта использовались квадратные скобки и это привело к созданию списка. Для второго использовались круглые скобки, и это привело к созданию генератора. Посмотрите, что произойдет, если мы выведем содержание каждого из этих объектов:

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

Профилирование эффективности генератора

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

Вы можете сделать это с помощью вызова функции sys.getsizeof () :

В этом случае размер списка, полученного с помощью выражения составляет 87 624 байта, а размер генератора — только 120. То есть, список занимает памяти в 700 раз больше, чем генератор! Однако нужно помнить одну вещь. Если размер списка меньше доступной памяти на работающей машине, тогда обработка его будет занимать меньше времени, чем аналогичная обработка генератора. Чтобы удостовериться в этом, давайте просуммируем результаты приведенных выше выражений. Вы можете использовать для анализа функцию cProfile.run () :

Здесь вы можете видеть, что суммирование всех значений, содержащихся в списке заняло около трети времени аналогичного суммирования с помощью генератора. Поэтому если скорость является для вас проблемой, а память — нет, то список, возможно, окажется лучшим инструментом для работы.

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

Запомните, что выражения создающие списки возвращают списки, в то время как выражения генераторов возвращают генераторы. Генераторы работают одинаково, независимо от того, построены они на основе функции или выражения. Использование выражения позволяет вам задать простые генераторы одной строкой и также предполагает yield в конце каждой итерации. Ключевое слово yield , безусловно, является основой, на которой основывается вся функциональность генераторов. В следующих статьях мы углубимся в его работу.

Подробно про генераторы Python – что такое и как работают

Что такое генераторы в Python?

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

Создание итерации в Python сопряжено с большими трудностями; нам нужно реализовать методы __iter __() и __next __() для отслеживания внутренних состояний.

Создание итераторов – длительный процесс. Вот почему генератор играет важную роль в упрощении этого процесса. Если в итерации не найдено значение, возникает исключение StopIteration.

Как создать функцию генератора в Python?

Создать генератор на Python довольно просто. Он похож на обычную функцию, определяемую ключевым словом def, и использует ключевое слово yield вместо return. Или мы можем сказать, что если тело любой функции содержит оператор yield, он автоматически становится функцией-генератором. Рассмотрим следующий пример:

Yield вместо return

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

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

Рассмотрим следующий пример.

Разница между функцией генератора и нормальной функцией

• Нормальная функция содержит только один оператор return, тогда как функция генератора может содержать один или несколько операторов yield.
• Когда вызываются функции генератора, нормальная функция немедленно приостанавливается, и управление передается вызывающей стороне.
• Локальные переменные и их состояния запоминаются между последовательными вызовами.
• Исключение StopIteration возникает автоматически при завершении функции.

Генератор выражения

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

Представление выражения генератора похоже на понимание списка Python. Единственное отличие состоит в том, что квадратные скобки заменены круглыми скобками. Понимание списка вычисляет весь список, тогда как выражение генератора вычисляет один элемент за раз.

Рассмотрим следующий пример:

В приведенной выше программе list comprehension вернуло список элементов в третьей степени, тогда как выражение генератора вернуло ссылку на вычисленное значение. Вместо применения цикла for мы также можем вызвать next() для объекта-генератора. Рассмотрим другой пример:

Примечание: – Когда мы вызываем next(), Python вызывает __next __() для функции, в которую мы передали его в качестве параметра.

В приведенной выше программе мы использовали функцию next(), которая вернула следующий элемент списка.

Пример программы для печати таблицы заданного числа с помощью генератора:

В приведенном выше примере функция генератора выполняет итерацию с использованием цикла for.

Преимущества

Есть различные преимущества генераторов. Некоторые из них приведены ниже:

• Легко реализовать

Генераторы проще реализовать по сравнению с итератором. В итераторе мы должны реализовать функцию __iter __() и __next __().

• Эффективная память

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

Генератор бесконечной последовательности – отличный пример оптимизации памяти. Давайте обсудим это в приведенном ниже примере, используя функцию sys.getsizeof().

Из вышеприведенного вывода видно, что для list comprehension используется 4508 байт памяти, тогда как generator expression использует 56 байт памяти. Это означает, что объекты-генераторы намного эффективнее, чем сжатие списков.

• Конвейерная обработка с помощью генератора

Data Pipeline предоставляет возможность обрабатывать большие наборы данных или поток данных без использования дополнительной памяти компьютера.

Предположим, у нас есть файл журнала известного ресторана. В файле журнала есть столбец(4-й столбец), в котором отслеживается количество гамбургеров, проданных каждый час, и мы хотим просуммировать его, чтобы найти общее количество гамбургеров, проданных за 4 года. В этом сценарии генератор может создать конвейер с серией операций. Ниже приведен его код:

• Возможность сгенерировать бесконечную последовательность

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

В этом руководстве мы узнали о генераторах Python.

Итерируемый объект, итератор и генератор

Привет, уважаемые читатели Хабрахабра. В этой статье попробуем разобраться что такое итерируемый объект, итератор и генератор. Рассмотрим как они реализованы и используются. Примеры написан на Python, но итераторы и генераторы, на мой взгляд, фундаментальные понятия, которые были актуальны 20 лет назад и еще более актуальны сейчас, при этом за это время фактически не изменились.

Итераторы

Для начала вспомним, что из себя представляет паттерн «Итератор(Iterator)».
Назначение:

• для доступа к содержимому агрегированных объектов без раскрытия их внутреннего представления;
• для поддержки нескольких активных обходов одного и того же агрегированного объекта (желательно, но не обязательно);
• для предоставления единообразного интерфейса с целью обхода различных агрегированных структур.

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

Существуют два вида итераторов, внешний и внутренний.
Внешний итератор — это классический (pull-based) итератор, когда процессом обхода явно управляет клиент путем вызова метода Next.
Внутренний итератор — это push-based-итератор, которому передается callback функция, и он сам уведомляет клиента о получении следующего элемента.

Классическая диаграмма паттерна “Итератор”, как она описана в небезызвестной книги «банды четырех»:

Aggregate — составной объект, по которому может перемещаться итератор;
Iterator — определяет интерфейс итератора;
ConcreteAggregate — конкретная реализация агрегата;
ConcreteIterator — конкретная реализация итератора для определенного агрегата;
Client — использует объект Aggregate и итератор для его обхода.

Пробуем реализовать на Python классический итератор

Конкретная реализация итератора для списка:

Конкретная реализация агрегата:

Теперь мы можем создать объект коллекции и обойти все ее элементы с помощью итератора:

А так как мы реализовали метод first, который сбрасывает итератор в начальное состояние, то можно воспользоваться этим же итератором еще раз:

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

Протокол итерирования в Python

В книге «банды четырех» о реализации итератора написано:

Минимальный интерфейс класса Iterator состоит из операций First, Next, IsDone и CurrentItem. Но если очень хочется, то этот интерфейс можно упростить, объединив операции Next, IsDone и CurrentItem в одну, которая будет переходить к следующему объекту и возвращать его. Если обход завершен, то эта операция вернет специальное значения(например, 0), обозначающее конец итерации.

Именно так и реализовано в Python, но вместо специального значения, о конце итерации говорит StopIteration. Проще просить прощения, чем разрешения.

Сначала важно определиться с терминами.

Рассмотрим итерируемый объект (Iterable). В стандартной библиотеке он объявлен как абстрактный класс collections.abc.Iterable:

У него есть абстрактный метод __iter__ который должен вернуть объект итератора. И метод __subclasshook__ который проверяет наличие у класса метод __iter__. Таким образом, получается, что итерируемый объект это любой объект который реализует метод __iter__

Но есть один момент, это функция iter(). Именно эту функцией использует например цикл for для получения итератора. Функция iter() в первую очередь для получения итератора из объекта, вызывает его метод __iter__. Если метод не реализован, то она проверяет наличие метода __getitem__ и если он реализован, то на его основе создается итератор. __getitem__ должен принимать индекс с нуля. Если не реализован ни один из этих методов, тогда будет вызвано исключение TypeError.

Итого, итерируемый объект — это любой объект, от которого встроенная функция iter() может получить итератор. Последовательности(abc.Sequence) всегда итерируемые, поскольку они реализуют метод __getitem__

Теперь посмотрим, что с итераторами в Python. Они представлены абстрактным классом collections.abc.Iterator:

__next__ Возвращает следующий доступный элемент и вызывает исключение StopIteration, когда элементов не осталось.
__iter__ Возвращает self. Это позволяет использовать итератор там, где ожидается итерируемых объект, например for.
__subclasshook__ Проверяет наличие у класса метода __iter__ и __next__

Итого, итератор в python — это любой объект, реализующий метод __next__ без аргументов, который должен вернуть следующий элемент или ошибку StopIteration. Также он реализует метод __iter__ и поэтому сам является итерируемым объектом.

Таким образом можно реализовать итерируемый объект на основе списка и его итератор:

Функция next() вызывает метод __next__. Ей можно передать второй аргумент который она будет возвращать по окончанию итерации вместо ошибки StopIteration.

Прежде чем переходить к генераторам, рассмотрим еще одну возможность встроенной функции iter(). Ее можно вызывать с двумя аргументами, что позволит создать из вызываемого объекта(функция или класс с реализованным методом __call__) итератор. Первый аргумент должен быть вызываемым объектом, а второй — неким ограничителем. Вызываемый объект вызывается на каждой итерации и итерирование завершается, когда возбуждается исключение StopIteration или возвращается значения ограничителя.

Например, из функции которая произвольно возвращает 1-6, можно сделать итератор, который будет возвращать значения пока не «выпадет» 6:

Небольшой класс ProgrammingLanguages, у которого есть кортеж c языками программирования, конструктор принимает начальное значения индекса по названию языка и функция __call__ которая перебирает кортеж.

Можем перебрать все языки начиная с C# и до последнего:

Еще один пример:

Генераторы

С точки зрения реализации, генератор в Python — это языковая конструкция, которую можно реализовать двумя способами: как функция с ключевым словом yield или как генераторное выражение. В результате вызова функции или вычисления выражения, получаем объект-генератор типа types.GeneratorType.

В объекте-генераторе определены методы __next__ и __iter__, то есть реализован протокол итератора, с этой точки зрения, в Python любой генератор является итератором.
Концептуально, итератор — это механизм поэлементного обхода данных, а генератор позволяет отложено создавать результат при итерации. Генератор может создавать результат на основе какого то алгоритма или брать элементы из источника данных(коллекция, файлы, сетевое подключения и пр) и изменять их.

Ярким пример являются функции range и enumerate:

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

Yield

Для начало напишем простой генератор не используя объект-генератор. Это генератор чисел Фибоначчи:

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

Любая функция в Python, в теле которой встречается ключевое слово yield, называется генераторной функцией — при вызове она возвращает объект-генератор.
Объект-генератор реализует интерфейс итератора, соответственно с этим объектом можно работать, как с любым другим итерируемым объектом.

Рассмотрим работу yield:

1. при вызове функции gen_fun создается объект-генератор
2. for вызывает iter() с этим объектом и получает итератор этого генератора
3. в цикле вызывает функция next() с этим итератором пока не будет получено исключение StopIteration
4. при каждом вызове next выполнение в функции начинается с того места где было завершено в последний раз и продолжается до следующего yield

Происходит приблизительно следующее. Генераторная функция разбивается на части:

Создается стейт-машина в которой при каждом вызове __next__ меняется состояния и в зависимости от него вызывается тот или иной кусок кода. Если в функции yield в цикле, то соответственно состояние стейт-машины зацикливается пока не будет выполнено условие.

Свой вариант range:

Генераторное выражение (generator expression)

Если кратко, то синтаксически более короткий способ создать генератор, не определяя и не вызывая функцию. А так как это выражение, то у него есть и ряд ограничений. В основном удобно использовать для генерации коллекций, их несложных преобразований и применений на них условий.

В языках программирования есть такие понятия, как ленивые/отложенные вычисления(lazy evaluation) и жадные вычисления(eager/greedy evaluation). Генераторы можно считать отложенным вычислением, в этом смысле списковое включение(list comprehension) очень похожи на генераторное выражение, но являются разными подходами.

Первый вариант работает схожим с нашей функцией cool_range образом и может генерировать без проблем любой диапазон. А вот второй вариант создаст сразу целый список, со всеми вытекающими от сюда проблемами.

Yield from

Для обхода ограниченно вложенных структур, традиционный подход использовать вложенные циклы. Тот же подход можно использовать когда генераторная функция должна отдавать значения, порождаемые другим генератором.

Функция похожая на itertools.chain:

Но вложенные циклы можно убрать, добавив конструкцию yield from:

Основная польза yield from в создании прямого канала между внутренним генератором и клиентом внешнего генератора. Но это уже больше тема про сопрограммы(coroutines), которые заслуживают отдельной статьи. Там же можно обсудить методы генератора: close(), throw() и send().

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

Генераторы и итераторы в Python

Генератор в Python – одна из самых полезных и специальных функций. Мы можем превратить функцию в итератор, используя генераторы Python.

1. Базовая структура генератора
2. Получить значение генератора с точным вызовом next()
3. Получение значения генератора с косвенным вызовом next()
4. Порядок работы
5. Вывод программы
6. Протокол Iterator
7. Пример
8. Создание
9. Зачем нужен итератор?

Базовая структура генератора

По сути, генератор в Python – это функция. Вы можете рассматривать следующее, как базовую структуру генератора.

В приведенной выше структуре вы можете видеть, что все похоже на функцию, за исключением одного ключевого слова yield. Это ключевое слово играет жизненно важную роль. Только использование yield превращает обычную функцию в генератор.

Обычная функция возвращает какое-то значение, генератор возвращает какое-то значение и автоматически реализует next() и _iter_.

Генератор написан как обычные функции, но использует оператор yield всякий раз, когда они хотят вернуть какие-то данные. Каждый раз, когда функция next() вызывается для функции генератора, он возобновляет работу с того места, где он остановился (он запоминает все значения данных и какой оператор был выполнен последним).

Давайте теперь изучим каждую строку предыдущего кода:

• Строка 2 – это объявление генератора, принимающего аргумент. Это необязательный аргумент, все зависит от программиста, который будет реализовывать генератор.
• Строка 3, 5 – упоминает, что могут быть и другие утверждения.
• Строка 4 – является важной частью вышеуказанной программы. Он говорит, что значение аргумента должно быть получено на основе некоторых условий, которые могут быть указаны в утверждениях.
• Строка 8 – вызывает генератор с параметром 10, а строка 9 печатает возвращенный объект генератора.

Если вы запустите указанную выше программу, она выдаст следующее:

Обратите внимание, что приведенный выше результат не является значением. Фактически это указывает, где находится объект. Чтобы получить реальное значение, воспользуйтесь итератором. Затем next() будет вызываться для объекта, чтобы получить следующее полученное значение.

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

Затем он выведет значение 10, которое было передано в качестве аргумента и получено.

Получить значение генератора с точным вызовом next()

Теперь взгляните на следующую программу, в которой мы вызываем функцию next() генератора.

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

Приведенный выше код будет выводиться следующим образом:

Получение значения генератора с косвенным вызовом next()

Вы можете получить значения генератора, используя цикл for. Следующая программа показывает, как можно распечатать значения с помощью цикла for и генератора. Это даст тот же результат.

Порядок работы

Давайте теперь посмотрим, как на самом деле работает генератор. Обычная функция завершается после оператора return, а генератор – нет.

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

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

Вывод программы

Посмотрим другой код:

Помните, что range() – это встроенный генератор, который генерирует число в пределах верхней границы.

Итератор – это объект, который используется для итерации по итерируемому элементу.

Большинство объектов в Python являются итеративными. Все последовательности, такие как Python String, Python List, Python Dictionary и т.д., являются повторяемыми. Что такое итератор? Предположим, группа из 5 мальчиков выстроилась в линию. Вы указываете на первого мальчика и спрашиваете его, как его зовут. Затем он ответил. После этого вы спрашиваете следующего мальчика и так далее. Изображение ниже иллюстрирует это.

В этом случае вы Итератор. Очевидно, группа мальчиков – повторяющийся элемент.

Протокол Iterator

Протокол Iterator в Python включает две функции. Один – iter(), другой – next(). В этом разделе мы узнаем, как пройти по итерируемому элементу, используя протокол Iterator.

В предыдущем разделе мы привели пример группы из 5 мальчиков и вас. Вы итератор, а группа мальчиков – повторяемый элемент. Зная имя одного мальчика, вы задаете тот же вопрос следующему мальчику.

После этого вы делаете это снова. Функция iter() используется для создания итератора повторяемого элемента. А функция next() используется для перехода к следующему элементу.

Пример

Если итератор превысит количество повторяемых элементов, метод next() вызовет исключение StopIteration. Смотрите код ниже для примера:

Создание

Однако вы можете создать свои собственные указанные итераторы в Python. Для этого вам необходимо реализовать класс.

Как мы уже говорили ранее, протокол состоит из двух методов. Итак, нам нужно реализовать этот метод.

Например, вы хотите создать список чисел Фибоначчи, чтобы каждый раз при вызове следующей функции он возвращал вам следующее число.

Чтобы вызвать исключение, мы ограничиваем значение n ниже 10. Если значение n достигнет 10, это вызовет исключение. Код будет таким:

Итак, на выходе будет:

Зачем нужен итератор?

После прохождения предыдущего раздела у вас может возникнуть вопрос, зачем нам нужен Iterator.

Что ж, мы уже видели, что итератор может проходить по итерируемому элементу. Предположим, что в нашем предыдущем примере, если мы составим список чисел Фибоначчи, а затем проходим его через Iterator, это потребует огромной памяти. Но если вы создадите простой класс, вы сможете выполнить свою задачу, не потребляя столько памяти.

Источник: nevinka-info.ru