Detaillierte Einführung in Yield und Generator in Python

In diesem Artikel werden hauptsächlich die zugehörigen Informationen zu Ertrag und Generator in Python erläutert. Die Einführung im Artikel ist sehr detailliert und hat einen gewissen Referenzwert für alle Freunde, die einen Blick darauf werfen möchten.

Vorwort

In diesem Artikel werden Ertrag und Generator im Detail von einfach bis tiefgehend vorgestellt, einschließlich des folgenden Inhalts: Welcher Generator, wie wird er generiert? Generator und Generatorfunktionen, grundlegende und erweiterte Anwendungsszenarien des Generators und Vorsichtsmaßnahmen bei der Verwendung des Generators. Dieser Artikel enthält weder den erweiterten Generator noch pep342-bezogene Inhalte. Dieser Teil wird später vorgestellt.

Generator-Grundlagen

Solange in der Funktionsdefinition von Python der Yield-Ausdruck erscheint, ist tatsächlich ein Generator definiert Funktion, und der Rückgabewert dieses Aufrufs generator function ist ein Generator. Dieser gewöhnliche Funktionsaufruf ist anders. Zum Beispiel:

def gen_generator():
 yield 1
def gen_value():
 return 1
 
if __name__ == '__main__':
 ret = gen_generator()
 print ret, type(ret) #<generator object gen_generator at 0x02645648> <type &#39;generator&#39;>
 ret = gen_value()
 print ret, type(ret) # 1 <type &#39;int&#39;>

Wie aus dem obigen Code ersichtlich ist, gibt die Funktion gen_generator eine Generatorinstanz

generator zurück Folgende Besonderheiten:

•Folgen Sie dem Iteratorprotokoll, das implementiert werden muss __iter__ , nächste Schnittstelle

•Kann mehrfach übergeben werden. Mehrere Eingaben und Rückgaben Zeiten können die Ausführung des Codes im Funktionskörper anhalten

Schauen wir uns den Testcode an:

>>> def gen_example():
... print 'before any yield'
... yield 'first yield'
... print 'between yields'
... yield 'second yield'
... print 'no yield anymore'
... 
>>> gen = gen_example()
>>> gen.next()　　　　＃ 第一次调用next
before any yield
'first yield'
>>> gen.next()　　　　＃ 第二次调用next
between yields
'second yield'
>>> gen.next()　　　　＃ 第三次调用next
no yield anymore
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
StopIteratio

Der Aufruf der Gen-Beispielmethode führt nicht zu einer Ausgabe irgendetwas, was darauf hinweist, dass der Code des Funktionskörpers noch nicht mit der Ausführung begonnen hat. Wenn die nächste Methode des Generators aufgerufen wird, führt der Generator den Yield-Ausdruck aus, gibt den Inhalt des Yield-Ausdrucks zurück und hält dann an dieser Stelle an (hängt), sodass beim ersten Aufruf von next der erste Satz gedruckt und zurückgegeben wird. erste Ausbeute". Anhalten bedeutet, dass die lokalen Variablen, Zeigerinformationen und die Ausführungsumgebung der Methode gespeichert werden, bis der nächste Aufruf der nächsten Methode fortgesetzt wird. Nach dem zweiten Aufruf von next wird bei der letzten Ausbeute angehalten. Wenn die Methode next() erneut aufgerufen wird, wird eine StopIteration-Ausnahme ausgelöst.

Da die for-Anweisung die StopIteration-Ausnahme automatisch abfangen kann, besteht die häufigere Methode des Generators (im Wesentlichen jedes Iterators) darin, ihn in einer Schleife zu verwenden:

def generator_example():
 yield 1
 yield 2

if __name__ == '__main__':
 for e in generator_example():
 print e
 # output 1 2

generiert von Generatorfunktion Was ist der Unterschied zwischen einem Generator und einer normalen Funktion?

(1) Die Funktion beginnt jedes Mal ab der ersten Zeile, während der Generator ab dem Anfang der letzten Ausbeute läuft

(2) Ein Funktionsaufruf gibt jeweils einen (eine Menge) Werte zurück, und ein Generator kann

mehrmals zurückgeben. (3) Eine Funktion kann unzählige Male wiederholt aufgerufen werden. aber eine Generatorinstanz kann nicht den letzten Wert liefern oder danach zurückkehren, um

weiter aufzurufen, um Yield in der Funktion zu verwenden, und das anschließende Aufrufen der Funktion ist eine Möglichkeit, einen Generator zu generieren. Eine andere übliche Methode ist die Verwendung von generator expression, zum Beispiel:

　　>>> gen = (x * x for x in xrange(5))
　　>>> print gen
　　<generator object <genexpr> at 0x02655710>

Generator-App

Generator-Basis-App

Warum den Generator verwenden? Der wichtigste Grund ist, dass er bei Bedarf Ergebnisse generieren und „zurückgeben“ kann, anstatt alle Rückgabewerte auf einmal zu generieren. überhaupt. Wert".

Zum Beispiel für den folgenden Code　

RANGE_NUM = 100
 for i in [x*x for x in range(RANGE_NUM)]: # 第一种方法：对列表进行迭代
 # do sth for example
 print i

 for i in (x*x for x in range(RANGE_NUM)): # 第二种方法：对generator进行迭代
 # do sth for example
 print i

Im obigen Code ist die Ausgabe der beiden for-Anweisungen dieselbe, und der Code bedeutet wörtlich Quadrat Klammern Der Unterschied zu Klammern. Dieser Unterschied ist jedoch sehr unterschiedlich. Die erste Methode gibt eine Liste zurück und die zweite Methode gibt ein Generatorobjekt zurück. Wenn RANGE_NUM größer wird, wird die von der ersten Methode zurückgegebene Liste größer und der belegte Speicher wird größer. Bei der zweiten Methode gibt es jedoch keinen Unterschied.

Sehen wir uns ein weiteres Beispiel an, das unendlich oft „zurückgeben“ kann:

def fib():
 a, b = 1, 1
 while True:
 yield a
 a, b = b, a+b

Dieser Generator hat die Fähigkeit, unzählige „Rückgabewerte“ zu generieren, und der Benutzer kann entscheiden, wann zu stoppen. Iteration

Erweiterte Anwendung des Generators

Verwendungsszenario eins:

Generator kann Wird zum Generieren von Datenströmen verwendet, generiert der Generator nicht sofort einen Rückgabewert, sondern wartet, bis er benötigt wird. Dies entspricht beispielsweise einem aktiven Pull-Prozess (Pull), und jede Zeile generiert einen Mit jedem Datensatz können die Mitarbeiter in verschiedenen Abteilungen unterschiedlich umgehen, wir können jedoch einen gemeinsamen, bedarfsgesteuerten Datenfluss bereitstellen.

def gen_data_from_file(file_name):
 for line in file(file_name):
 yield line

def gen_words(line):
 for word in (w for w in line.split() if w.strip()):
 yield word

def count_words(file_name):
 word_map = {}
 for line in gen_data_from_file(file_name):
 for word in gen_words(line):
  if word not in word_map:
  word_map[word] = 0
  word_map[word] += 1
 return word_map

def count_total_chars(file_name):
 total = 0
 for line in gen_data_from_file(file_name):
 total += len(line)
 return total
 
if __name__ == '__main__':
 print count_words('test.txt'), count_total_chars('test.txt')

Das obige Beispiel stammt aus einem Vortrag auf der PyCon im Jahr 2008. gen_words gen_data_from_file ist der Datenproduzent und count_words count_total_chars ist der Datenkonsument. Wie Sie sehen, werden Daten nur bei Bedarf abgerufen und nicht im Voraus vorbereitet. Darüber hinaus generiert (w for w in line.split() if w.strip()) in gen_words auch einen Generator

Verwendungsszenario zwei:

一些编程场景中，一件事情可能需要执行一部分逻辑，然后等待一段时间、或者等待某个异步的结果、或者等待某个状态，然后继续执行另一部分逻辑。比如微服务架构中，服务A执行了一段逻辑之后，去服务B请求一些数据，然后在服务A上继续执行。或者在游戏编程中，一个技能分成分多段，先执行一部分动作（效果），然后等待一段时间，然后再继续。对于这种需要等待、而又不希望阻塞的情况，我们一般使用回调（callback）的方式。下面举一个简单的例子：

 def do(a):
 print 'do', a
 CallBackMgr.callback(5, lambda a = a: post_do(a))
 
 def post_do(a):
 print 'post_do', a

这里的CallBackMgr注册了一个5s后的时间，5s之后再调用lambda函数，可见一段逻辑被分裂到两个函数，而且还需要上下文的传递（如这里的参数a）。我们用yield来修改一下这个例子，yield返回值代表等待的时间。

 @yield_dec
 def do(a):
 print 'do', a
 yield 5
 print 'post_do', a

这里需要实现一个YieldManager， 通过yield_dec这个decrator将do这个generator注册到YieldManager，并在5s后调用next方法。Yield版本实现了和回调一样的功能，但是看起来要清晰许多。

下面给出一个简单的实现以供参考：

# -*- coding:utf-8 -*-
import sys
# import Timer
import types
import time

class YieldManager(object):
 def __init__(self, tick_delta = 0.01):
 self.generator_dict = {}
 # self._tick_timer = Timer.addRepeatTimer(tick_delta, lambda: self.tick())

 def tick(self):
 cur = time.time()
 for gene, t in self.generator_dict.items():
  if cur >= t:
  self._do_resume_genetator(gene,cur)

 def _do_resume_genetator(self,gene, cur ):
 try:
  self.on_generator_excute(gene, cur)
 except StopIteration,e:
  self.remove_generator(gene)
 except Exception, e:
  print 'unexcepet error', type(e)
  self.remove_generator(gene)

 def add_generator(self, gen, deadline):
 self.generator_dict[gen] = deadline

 def remove_generator(self, gene):
 del self.generator_dict[gene]

 def on_generator_excute(self, gen, cur_time = None):
 t = gen.next()
 cur_time = cur_time or time.time()
 self.add_generator(gen, t + cur_time)

g_yield_mgr = YieldManager()

def yield_dec(func):
 def _inner_func(*args, **kwargs):
 gen = func(*args, **kwargs)
 if type(gen) is types.GeneratorType:
  g_yield_mgr.on_generator_excute(gen)

 return gen
 return _inner_func

@yield_dec
def do(a):
 print 'do', a
 yield 2.5
 print 'post_do', a
 yield 3
 print 'post_do again', a

if __name__ == '__main__':
 do(1)
 for i in range(1, 10):
 print 'simulate a timer, %s seconds passed' % i
 time.sleep(1)
 g_yield_mgr.tick()

注意事项：

（1）Yield是不能嵌套的！

def visit(data):
 for elem in data:
 if isinstance(elem, tuple) or isinstance(elem, list):
  visit(elem) # here value retuened is generator
 else:
  yield elem
  
if __name__ == '__main__':
 for e in visit([1, 2, (3, 4), 5]):
 print e

上面的代码访问嵌套序列里面的每一个元素，我们期望的输出是1 2 3 4 5，而实际输出是1 2 5 。为什么呢，如注释所示，visit是一个generator function，所以第4行返回的是generator object，而代码也没这个generator实例迭代。那么改改代码，对这个临时的generator 进行迭代就行了。

def visit(data):
 for elem in data:
 if isinstance(elem, tuple) or isinstance(elem, list):
  for e in visit(elem):
  yield e
 else:
  yield elem

或者在python3.3中 可以使用yield from，这个语法是在pep380加入的

 def visit(data):
 for elem in data:
  if isinstance(elem, tuple) or isinstance(elem, list):
  yield from visit(elem)
  else:
  yield elem

（2）generator function中使用return

在python doc中，明确提到是可以使用return的，当generator执行到这里的时候抛出StopIteration异常。

def gen_with_return(range_num):
 if range_num < 0:
 return
 else:
 for i in xrange(range_num):
  yield i

if __name__ == &#39;__main__&#39;:
 print list(gen_with_return(-1))
 print list(gen_with_return(1))

但是，generator function中的return是不能带任何返回值的

 def gen_with_return(range_num):
 if range_num < 0:
  return 0
 else:
  for i in xrange(range_num):
  yield i

上面的代码会报错：SyntaxError: 'return' with argument inside generator

总结

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Yield und Generator in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!