Что такое yield python

Понимание yield в Python

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

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

Различия между списком и генератором

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

При запуске этого кода, программа вернёт результат «list». Теперь давайте переберём все элементы в списке squared_list.

Приведенный выше сценарий вернёт следующие результаты:

Теперь создадим генератор и выполнить ту же задачу:

Генератор создаётся подобно коллекции списка, но вместо квадратных скобок нужно использовать круглые скобки. Приведенный выше сценарий вернёт значение «generator» как тип переменной squared_gen. Теперь давайте переберём элементы генератора с помощью цикла for.

Выходные данные такие же, как у списка. Так в чем же разница? Одно из главных отличий заключается в том, как в список и генератор хранят элементы в памяти. Списки хранят все элементы в памяти сразу, тогда как генераторы «создают» каждый элемент на лету, отображая их, а затем перемещаются к следующему элементу, удаляя предыдущий элемент из памяти.

Один из способов проверить это, узнать длину как списка, так и генератора, который только что создали. Функции len(squared_list) вернет 5, а len(squared_gen) выдаст ошибку отсутствия длины у генератора. Кроме того, список можно перебирать столько раз, сколько захотите, но генератор можно перебирать только один раз. Для повторной итерации необходимо создать генератор снова.

Использование ключевого слова yield

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

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

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

В этом скрипте создается функция cube_numbers, которая принимает список чисел, вычисляет их куб и возвращает вызывающему объекту список целиком. При вызове этой функции список кубов возвращается и сохраняется в переменную cubes. Как видно из вывода, возвращаемые данные – это список целиком:

Теперь, изменим сценарий, так чтобы он возвращал генератор.

В приведенном выше скрипте функция cube_numbers возвращает генератор вместо списка кубов чисел. Создать генератор с помощью ключевого слова yield очень просто. Здесь нам не нужна временная переменная cube_list для хранения куба числа, поэтому даже наш метод cube_numbers проще. Кроме того, не используется оператор return, но вместо него используется слово yield для возвращения куба числа внутри цикла.

Теперь, когда функция cube_number возвращает генератор, проверим его, запустив код:

Несмотря на то, что был произведён вызов функции cube_numbers, она фактически не выполняется на данный момент времени, и в памяти еще нет элементов.

Получение значение из генератора:

Вышеуказанная функция возвратит «1». Теперь, когда снова вызывается next генератора, функция cube_numbers возобновит выполнение с того места, где она ранее остановилась на yield. Функция будет продолжать выполняться до тех пор, пока снова не найдет yield. Следующая функция будет продолжать возвращать значение куба по одному, пока все значения в списке не будут проитерированы.

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

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

Оптимизация производительности

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

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

В приведенном ниже коде представлена функция, которая возвращает список, содержащий 1 миллион фиктивных объектов car. Рассчитаем память, процессорное время до и после вызова функции.

Взглянем на следующий код:

Примечание: возможно, придется выполнить pip install psutil, чтобы этот код был работоспособен.

На компьютере автора статьи получены следующие результаты (в вашем случае результаты могут быть иными):

До создания списка потребляемая память процесса составляла 8 МБ, а после создания списка с 1 миллионом элементов занимаемая память подскочила до 334 МБ. Кроме того, для создания списка было затрачено 1.58 секунды.

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

Результаты при выполнении вышеуказанного скрипта:

Из выходных данных видно, что при использовании генераторов разница в потреблении памяти незначительна (она остается на уровне 8 МБ), так как генераторы не хранят элементы в памяти. Кроме того, время, затраченное на вызов функции генератора, составило всего 0,000003 секунды – это намного меньше затраченного времени, по сравнению с списком.

Вывод

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

Источник

Ключевое слово yield в Python

Сравнение yield и return

Пример yield

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

Он отлично работает, когда значение «count» не слишком велико. Если мы укажем count как 100000, тогда наша функция будет использовать много памяти для хранения такого количества значений в списке.

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

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

Я использую модуль ресурсов Python для печати использования памяти и времени обоих сценариев.

У меня четыре текстовых файла разного размера.

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

Вот данные в табличном формате для лучшего понимания.

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

Но с ключевым словом yield преимущества памяти огромны. Использование памяти прямо пропорционально размеру файла с помощью оператора return. Это почти постоянно с функцией генератора.

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

Пример отправки вывода Python

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

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

В противном случае мы получим TypeError: невозможно отправить значение, отличное от None, только что запущенному генератору.

Выход из выражения

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

Мы можем использовать «yield from» в функции generate_ints(), чтобы создать двунаправленное соединение между вызывающей программой и суб-итератором.

Фактическая выгода от «yield from» видна, когда нам нужно отправить данные в функцию генератора.

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

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

Источник

Генератор yield в Python

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

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

Различия между списком и генератором

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

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

Теперь давайте переберем все элементы в squared_list.

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

Теперь давайте создадим генератор и выполним ту же самую задачу:

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

Вывод такой же, как и у списка. Так в чем разница? Одно из основных различий заключается в том, как список и генераторы хранят элементы в памяти. Списки хранят все элементы в памяти сразу, тогда как генераторы «создают» каждый элемент на лету, отображают его, а затем переходит к следующему элементу, удаляя предыдущий элемент из памяти.

Один из способов проверить это – проверить длину только что созданного списка и генератора. Len (squared_list) вернет 5, а len (squared_gen) выдаст ошибку, что у генератора нет длины. Кроме того, вы можете перебирать список столько раз, сколько хотите, но вы можете перебирать генератор только один раз. Чтобы повторить итерацию снова, вы должны снова создать генератор.

Использование yield

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

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

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

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

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

В приведенном выше сценарии функция cube_numbers возвращает генератор вместо списка чисел в кубе. Создать генератор с помощью ключевого слова yield очень просто. Здесь нам не нужна временная переменная cube_list для хранения числа в кубе, поэтому даже наш метод cube_numbers проще. Кроме того, не требуется никакого оператора return, вместо этого ключевое слово yield используется для возврата числа в кубе внутри цикла for.

Теперь, когда вызывается функция cube_number, возвращается генератор, что мы можем проверить, запустив код:

Несмотря на то, что мы вызвали функцию cube_numbers, она фактически не выполняется в этот момент времени, и в памяти еще нет никаких элементов.

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

Вот как вы получаете значение от своего генератора:

Вышеупомянутая функция вернет «1». Теперь, когда вы снова вызываете next в генераторе, функция cube_numbers возобновит выполнение с того места, где она остановилась ранее на yield. Функция будет продолжать выполняться, пока снова не найдет yield. Следующая функция будет продолжать возвращать кубическое значение одно за другим, пока все значения в списке не будут повторены.

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

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

Оптимизированная производительность

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

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

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

Взгляните на следующий код:

Примечание. Возможно, вам придется установить psutil, чтобы этот код работал на вашем компьютере.

На машине, на которой был запущен код, были получены следующие результаты (ваш может выглядеть немного иначе):

До создания списка память процесса составляла 8 МБ, а после создания списка с 1 миллионом элементов занимаемая память увеличилась до 334 МБ. Кроме того, на создание списка ушло 1,58 секунды.

Теперь давайте повторим описанный выше процесс, но заменим список генератором. Выполните следующий скрипт:

Здесь мы должны использовать цикл for car in car_list_gen (1000000), чтобы гарантировать, что все 1000000 автомобилей действительно сгенерированы.

Следующие результаты были получены при выполнении вышеуказанного скрипта:

Из выходных данных вы можете видеть, что при использовании генераторов разница в памяти намного меньше, чем раньше (от 8 МБ до 40 МБ), поскольку генераторы не сохраняют элементы в памяти. Кроме того, время, затраченное на вызов функции генератора, также было немного быстрее – 1,37 секунды, что примерно на 14% быстрее, чем создание списка.

Заключение

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

Источник

Как работает yield

На StackOverflow часто задают вопросы, подробно освещённые в документации. Ценность их в том, что на некоторые из них кто-нибудь даёт ответ, обладающий гораздо большей степенью ясности и наглядности, чем может себе позволить документация. Этот — один из них.

Вот исходный вопрос:

Как используется ключевое слово yield в Python? Что оно делает?

Например, я пытаюсь понять этот код (**):

Что происходит при вызове метода _get_child_candidates? Возвращается список, какой-то элемент? Вызывается ли он снова? Когда последующие вызовы прекращаются?

** Код принадлежит Jochen Schulz (jrschulz), который написал отличную Python-библиотеку для метрических пространств. Вот ссылка на исходники: http://well-adjusted.de/

Итераторы

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

Mylist является итерируемым объектом. Когда вы создаёте список, используя генераторное выражение, вы создаёте также итератор:

Всё, к чему можно применить конструкцию «for… in. », является итерируемым объектом: списки, строки, файлы… Это удобно, потому что можно считывать из них значения сколько потребуется — однако все значения хранятся в памяти, а это не всегда желательно, если у вас много значений.

Генераторы

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

Всё то же самое, разве что используются круглые скобки вместо квадратных. НО: нельзя применить конструкцию for i in mygenerator второй раз, так как генератор может быть использован только единожды: он вычисляет 0, потом забывает про него и вычисляет 1, завершаяя вычислением 4 — одно за другим.

Yield

Yield это ключевое слово, которое используется примерно как return — отличие в том, что функция вернёт генератор.

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

Чтобы освоить yield, вы должны понимать, что когда вы вызываете функцию, код внутри тела функции не исполняется. Функция только возвращает объект-генератор — немного мудрёно 🙂

Ваш код будет вызываться каждый раз, когда for обращается к генератору.

Теперь трудная часть:

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

Генератор считается пустым, как только при исполнении кода функции не встречается yield. Это может случиться из-за конца цикла, или же если не выполняется какое-то из условий «if/else».

Объяснение кода из исходного вопроса

Читатель может остановиться здесь, или же прочитать ещё немного о продвинутом использовании генераторов:

Контроль за исчерпанием генератора

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

Ваш лучший друг Itertools

Модуль itertools содержит специальные функции для работы с итерируемыми объектами. Желаете продублировать генератор? Соединить два генератора последовательно? Сгруппировать значения вложенных списков в одну строчку? Применить map или zip без создания ещё одного списка?

Просто добавьте import itertools.

Хотите пример? Давайте посмотрим на возможные порядки финиширования на скачках (4 лошади):

Понимание внутреннего механизма итерации

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

Больше информации по данному вопросу доступно в статье про то, как работает цикл for.

Источник

Ключевое слово yield в Python

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

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

Что такое yield и как это работает

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

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

Но перед этим рассмотрим пример:

Тип полученного значения при вызове функции — это генератор. Один из способов получения значений из генератора — это их перебрать в цикле for. Им мы и воспользовались. Но можно его легко привести к списку, как мы сделали в статье про числа Фибоначчи.

Теперь разберемся, как это всё работает.

Что такое итерации

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

Цикл — это повторяющаяся последовательность команд, каждый цикл состоит из итераций. То есть, одно выполнение цикла — это итерация. Например, если тело цикла выполнилось 5 раз, это значит, что прошло 5 итераций.

Итератор — это объект, позволяющий «обходить» элементы последовательностей. Программист может создать свой итератор, однако в этом нет необходимости, интерпретатор Python делает это сам.

Что такое генераторы

Генератор — это обычная функция, которая при каждом своём вызове возвращает объект. При этом в функции-генераторе вызывается next.

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

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

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

Функция next()

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

На самом деле каждый объект имеет встроенный метод __next__, который и обеспечивает обход элементов в цикле, а функция next() просто вызывает его.

Вот пример использования next:

Преимущества использования yield

yield используют не потому, что это определено синтаксисом Python, ведь всё, что можно реализовать с его помощью, можно реализовать и с помощью обычного return.

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

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

Сравнение производительности return и yield

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

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

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

yield from

Многие считают, что yield from был добавлен в язык Python 3, чтобы объединить две конструкции: yield и цикл for, потому что они часто используются совместно, как в следующем примере:

Однако истинное предназначение нововведения немного в другом. Конструкция позволяет «вкладывать» один генератор в другой, то есть создавать субгенераторы.

yield from позволяет программисту легко управлять сразу несколькими генераторами, настраивать их взаимодействие и, конечно, заменить более длинную конструкцию for+yield, например:

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

Заключение

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

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

Источник