Для чего вы можете использовать функции генератора Python?
Я начинаю изучать Python, и я наткнулся на функции-генераторы, в которых есть оператор yield. Я хочу знать, какие проблемы эти функции действительно хорошо решают.
16 ответов
Генераторы дают вам ленивую оценку. Вы используете их, перебирая их, явно с помощью 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 элементов не будет создан вообще, только одно значение за раз. Это не будет иметь место при использовании версии списка, где список будет создан первым.
Пример из реального мира
Допустим, у вас есть 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()
Я нахожу это объяснение, которое очищает мои сомнения. Потому что есть вероятность того, что человек, который не знает, 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 заявление, когда они хотят вернуть данные. Каждый раз, когда вызывается next(), генератор возобновляет работу с того места, где он остановился (он запоминает все значения данных и какой оператор был выполнен в последний раз).
См. Раздел "Мотивация" в PEP 255.
Неочевидное использование генераторов - это создание прерываемых функций, которые позволяют вам выполнять такие вещи, как обновление пользовательского интерфейса или запускать несколько заданий "одновременно" (фактически с чередованием), не используя потоки.
Буферизация. Когда эффективно извлекать данные большими порциями, но обрабатывать их небольшими порциями, тогда может помочь генератор:
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 - что это? и с небольшим воображением, вы можете придумать множество других ситуаций, когда генераторы делают отличную альтернативу 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 выражение.
Так как метод отправки генератора не был упомянут, вот пример:
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 от объяснения, генераторы для параллельной обработки, выход за пределы рекурсии и т. д.)
Однако здесь есть несколько хороших ответов, и я бы также рекомендовал прочитать полное руководство по функциональному программированию на Python, которое поможет объяснить некоторые из наиболее эффективных сценариев использования генераторов.
- Особенно интересно то, что теперь можно обновлять переменную yield вне функции генератора, что позволяет создавать динамические и переплетенные сопрограммы с относительно небольшими усилиями.
- Также см. PEP 342: сопрограммы через расширенные генераторы для получения дополнительной информации.
Я использую генераторы, когда наш веб-сервер действует как прокси:
- Клиент запрашивает прокси-URL с сервера
- Сервер начинает загружать целевой URL
- Сервер возвращает результаты клиенту, как только он их получает.
Кучи вещей. Каждый раз, когда вы хотите сгенерировать последовательность элементов, но не хотите "материализовать" их все в список сразу. Например, у вас может быть простой генератор, который возвращает простые числа:
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)