Для чего вы можете использовать функции генератора Python?

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

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

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

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

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

Если вы хотите увидеть пример двух последних подходов, смотрите os.path.walk () (старая функция обхода файловой системы с обратным вызовом) и os.walk () (новый генератор обхода файловой системы.) Конечно, если Вы действительно хотели собрать все результаты в список, подход с генератором тривиален для преобразования в подход с большим списком:

big_list = list(the_generator)

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

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

Если у вас есть функция Фибоначчи до n, как эта:

# function version
def fibon(n):
    a = b = 1
    result = []
    for i in xrange(n):
        result.append(a)
        a, b = b, a + b
    return result

Вы можете легче написать функцию как это:

# generator version
def fibon(n):
    a = b = 1
    for i in xrange(n):
        yield a
        a, b = b, a + b

Функция понятнее. И если вы используете функцию, как это:

for x in fibon(1000000):
    print x,

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

См. Раздел «Мотивация» в PEP 255 .

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

Я нахожу это объяснение, которое очищает мои сомнения. Потому что есть вероятность, что человек, который не знает, Generatorsтакже не знает оyield

Возвращение

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

Уступать

Но что, если локальные переменные не выбрасываются при выходе из функции? Это означает, что мы можем, resume the functionгде мы остановились. Это где понятие generatorsвводится и yieldзаявление возобновляется там, где functionостановился.

  def generate_integers(N):
    for i in xrange(N):
    yield i

    In [1]: gen = generate_integers(3)
    In [2]: gen
    <generator object at 0x8117f90>
    In [3]: gen.next()
    0
    In [4]: gen.next()
    1
    In [5]: gen.next()

Так вот в чем разница между returnи yieldутверждениями в Python.

Оператор Yield - это то, что делает функцию функцией-генератором.

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

Пример из реального мира

Предположим, у вас есть 100 миллионов доменов в вашей таблице MySQL, и вы хотели бы обновить Alexa рейтинг для каждого домена.

Первое, что вам нужно, это выбрать ваши доменные имена из базы данных.

Допустим, ваша таблица называется, domainsа имя столбца domain.

Если вы используете, SELECT domain FROM domainsон вернет 100 миллионов строк, которые будут занимать много памяти. Таким образом, ваш сервер может произойти сбой.

Итак, вы решили запустить программу в пакетном режиме. Допустим, размер нашей партии составляет 1000.

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

В нашей второй партии мы будем работать над следующими 1000 рядами. В нашей третьей партии это будет с 2001 по 3000 и так далее.

Теперь нам нужна функция генератора, которая генерирует наши пакеты.

Вот наша функция генератора:

def ResultGenerator(cursor, batchsize=1000):
    while True:
        results = cursor.fetchmany(batchsize)
        if not results:
            break
        for result in results:
            yield result

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

return - returns only once
yield - returns multiple times

Если функция использует ключевое слово, yieldто это генератор.

Теперь вы можете выполнять итерации следующим образом:

db = MySQLdb.connect(host="localhost", user="root", passwd="root", db="domains")
cursor = db.cursor()
cursor.execute("SELECT domain FROM domains")
for result in ResultGenerator(cursor):
    doSomethingWith(result)
db.close()

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

def bufferedFetch():
  while True:
     buffer = getBigChunkOfData()
     # insert some code to break on 'end of data'
     for i in buffer:    
          yield i

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

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

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

def fib():
    first = 0
    second = 1
    yield first
    yield second

    while 1:
        next = first + second
        yield next
        first = second
        second = next

fibgen1 = fib()
fibgen2 = fib()

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

>>> fibgen1.next(); fibgen1.next(); fibgen1.next(); fibgen1.next()
0
1
1
2
>>> fibgen2.next(); fibgen2.next()
0
1
>>> fibgen1.next(); fibgen1.next()
3
5

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

Я получил пример Фибоначчи от Python Generators. Что это? и с небольшим воображением вы можете придумать множество других ситуаций, когда генераторы создают отличную альтернативу forциклам и другим традиционным итерационным конструкциям.

Простое объяснение: рассмотрим forутверждение

for item in iterable:
   do_stuff()

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

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

В других случаях вы даже не знаете все предметы заранее. Например:

for command in user_input():
   do_stuff_with(command)

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

def user_input():
    while True:
        wait_for_command()
        cmd = get_command()
        yield cmd

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

Мое любимое использование - операции «фильтра» и «сокращения».

Допустим, мы читаем файл и хотим только строки, начинающиеся с «##».

def filter2sharps( aSequence ):
    for l in aSequence:
        if l.startswith("##"):
            yield l

Затем мы можем использовать функцию генератора в правильном цикле

source= file( ... )
for line in filter2sharps( source.readlines() ):
    print line
source.close()

Пример сокращения аналогичен. Допустим, у нас есть файл, в котором нам нужно найти блоки <Location>...</Location>строк. [Не теги HTML, а строки, которые выглядят как теги.]

def reduceLocation( aSequence ):
    keep= False
    block= None
    for line in aSequence:
        if line.startswith("</Location"):
            block.append( line )
            yield block
            block= None
            keep= False
        elif line.startsWith("<Location"):
            block= [ line ]
            keep= True
        elif keep:
            block.append( line )
        else:
            pass
    if block is not None:
        yield block # A partial block, icky

Опять же, мы можем использовать этот генератор в правильном цикле for.

source = file( ... )
for b in reduceLocation( source.readlines() ):
    print b
source.close()

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

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

class Rect():

    def __init__(self, x, y, width, height):
        self.l_top  = (x, y)
        self.r_top  = (x+width, y)
        self.r_bot  = (x+width, y+height)
        self.l_bot  = (x, y+height)

    def __iter__(self):
        yield self.l_top
        yield self.r_top
        yield self.r_bot
        yield self.l_bot

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

myrect=Rect(50, 50, 100, 100)
for corner in myrect:
    print(corner)

Вместо этого __iter__вы можете иметь метод iter_cornersи вызывать его с помощью for corner in myrect.iter_corners(). Это более элегантно использовать, __iter__поскольку мы можем использовать имя экземпляра класса непосредственно в forвыражении.

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

Смотрите здесь и здесь для обзора того, что можно сделать с помощью генераторов.

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

• Особенно интересно то, что теперь можно обновлять переменную yield вне функции генератора , что позволяет создавать динамические и переплетенные сопрограммы с относительно небольшими усилиями.
• Также см. PEP 342: сопрограммы через расширенные генераторы для получения дополнительной информации.

Так как метод отправки генератора не был упомянут, вот пример:

def test():
    for i in xrange(5):
        val = yield
        print(val)

t = test()

# Proceed to 'yield' statement
next(t)

# Send value to yield
t.send(1)
t.send('2')
t.send([3])

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

Дэвид Бизли о генераторах на PyCon 2014

Я использую генераторы, когда наш веб-сервер действует как прокси:

1. Клиент запрашивает прокси-URL с сервера
2. Сервер начинает загружать целевой URL
3. Сервер возвращает результаты клиенту, как только он их получает.

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

def primes():
    primes_found = set()
    primes_found.add(2)
    yield 2
    for i in itertools.count(1):
        candidate = i * 2 + 1
        if not all(candidate % prime for prime in primes_found):
            primes_found.add(candidate)
            yield candidate

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

def prime_products():
    primeiter = primes()
    prev = primeiter.next()
    for prime in primeiter:
        yield prime * prev
        prev = prime

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

Также хорошо для печати простых чисел до n:

def genprime(n=10):
    for num in range(3, n+1):
        for factor in range(2, num):
            if num%factor == 0:
                break
        else:
            yield(num)

for prime_num in genprime(100):
    print(prime_num)