Einführung in die Verwendung von yield in Python

Dieser Artikel führt hauptsächlich eine kurze Analyse der Verwendung von Python ein. Der Herausgeber findet ihn recht gut, daher werde ich ihn jetzt mit Ihnen teilen und als Referenz geben. Folgen wir dem Editor, um zu sehen, wie man die Fibonacci-Folge generiert

Die Fibonacci-Folge ist eine sehr einfacheRekursiveFolge, außer Für die erste und zweite Zahl kann jede beliebige Zahl durch Addition der ersten beiden Zahlen erhalten werden. Die Verwendung eines Computerprogramms zur Ausgabe der ersten N Zahlen der Fibonacci-Folge ist ein sehr einfaches Problem. Viele Anfänger können leicht die folgende Funktion schreiben:

Listing 1. Einfache Ausgabe der ersten N Zahlen der Fibonacci-Folge

 def fab(max): 
  n, a, b = 0, 0, 1 
  while n < max: 
    print b 
    a, b = b, a + b 
    n = n + 1

Beim Ausführen von fab(5) können wir die folgende Ausgabe erhalten:

>> ;> ; fab(5)
1
1
2
3
5

Das Ergebnis ist kein Problem, aber erfahrene Entwickler werden darauf hinweisen, dass direkt gedruckt wird Das Drucken von Zahlen in der Fab-Funktion macht die Funktion weniger wiederverwendbar, da die Fab-Funktion None zurückgibt und andere Funktionen die von der Funktion generierte Sequenz nicht erhalten können.

Um die Wiederverwendbarkeit der Fab-Funktion zu verbessern, ist es am besten, die Sequenz nicht direkt auszudrucken, sondern eine Liste zurückzugeben. Das Folgende ist die umgeschriebene zweite Version der Fab-Funktion:

Listing 2. Geben Sie die ersten N Zahlen der Fibonacci-Folge aus. Zweite Version

 def fab(max): 
  n, a, b = 0, 0, 1 
  L = [] 
  while n < max: 
    L.append(b) 
    a, b = b, a + b 
    n = n + 1 
  return L

Sie können die folgende Methode verwenden, um die von der Fab-Funktion zurückgegebene Liste auszudrucken:

>>> 
for
 n in fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

Die neu geschriebene Fab-Funktion kann die Wiederverwendbarkeitsanforderungen erfüllen, indem sie eine Liste zurückgibt, erfahrenere Entwickler werden dies jedoch tun Wies darauf hin, dass der von dieser Funktion während des Betriebs belegte Speicher mit zunehmendem Parameter max zunimmt. Wenn Sie die Speicherbelegung steuern möchten, verwenden Sie am besten nicht die Liste zum Speichern der Zwischenergebnisse, sondern das iterierbare Objekt Iterieren. Beispielsweise führt //m.sbmmt.com/wiki/1078.html" target="_blank">range
(1000): pass dazu, dass eine Liste mit 1000 Elementen erstellt wird generiert, und der Code:

generiert keine Liste mit 1000 Elementen, sondern gibt in jeder Iteration den nächsten Wert zurück und belegt nur sehr wenig Speicherplatz. Weil xrange keine Liste zurückgibt, sondern ein iterierbares Objekt.

Mit iterable können wir die Fab-Funktion in eine for i in <a href="//m.sbmmt.com/wiki/1078.html" target="_blank">range</a>(1000): passKlasse

for i in xrange(1000): pass

Die Fab-Klasse gibt über next() kontinuierlich die nächste Zahl in der Sequenz zurück und die Speichernutzung ist immer konstant:

Allerdings ist der mit class umgeschriebene Code dieser Version weitaus weniger prägnant als der der ersten Version der Fab-Funktion. Yield ist praktisch, wenn wir die Einfachheit der ersten Version der Fab-Funktion beibehalten und dennoch iterierbare Effekte erzielen möchten:

class Fab(object): 

  def init(self, max): 
    self.max = max 
    self.n, self.a, self.b = 0, 0, 1 

  def iter(self): 
    return self 

  def next(self): 
    if self.n < self.max: 
      r = self.b 
      self.a, self.b = self.b, self.a + self.b 
      self.n = self.n + 1 
      return r 
    raise StopIteration()

Listing 5. Die vierte Version mit Yield

 >>> for n in Fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

Im Vergleich zur ersten Version ändert die vierte Version von fab nur print b in yield b, wodurch der iterierbare Effekt erzielt und gleichzeitig die Einfachheit beibehalten wird.

Der Aufruf der vierten Version von Fab ist genau derselbe wie der der zweiten Version von Fab:

 def fab(max): 
  n, a, b = 0, 0, 1 
  while n < max: 
    yield b 
    # print b 
    a, b = b, a + b 
    n = n + 1 

&#39;&#39;&#39;

Einfach ausgedrückt besteht die Funktion von yield darin, sich zu drehen Wenn Sie eine Funktion in einen Generator umwandeln, ist die Funktion mit yield keine gewöhnliche Funktion mehr. Der Aufruf von fab(5) führt die Funktion fab nicht aus, sondern gibt ein iterierbares Objekt zurück. Wenn die for
-Schleife

-Variable
der Funktion sieht genauso aus wie vor der letzten Unterbrechung, sodass die Funktion weiter ausgeführt wird, bis sie erneut auf yield trifft.

 >>> for n in fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

Sie können die next()-Methode von fab(5) auch manuell aufrufen (da fab(5) ein Generatorobjekt ist, das über eine next()-Methode verfügt), damit wir mehr sehen können klarer Ausführungsprozess für Fab: Listing 6. Ausführungsprozess

Wenn die Funktionsausführung endet, löst der Generator automatisch eine StopIteration-Ausnahme aus, was darauf hinweist Iteration Fertig. In der for-Schleife muss die StopIteration-Ausnahme nicht behandelt werden und die Schleife endet normal.

Wir können folgende Schlussfolgerungen ziehen:

一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

yield 的好处是显而易见的，把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。

如何判断一个函数是否是一个特殊的 generator 函数？可以利用 isgeneratorfunction 判断：

清单 7. 使用 isgeneratorfunction 判断

 >>> from inspect import isgeneratorfunction 
 >>> isgeneratorfunction(fab) 
 True

要注意区分 fab 和 fab(5)，fab 是一个 generator function，而 fab(5) 是调用 fab 返回的一个 generator，好比类的定义和类的实例的区别：

清单 8. 类的定义和类的实例

 >>> import types 
 >>> isinstance(fab, types.GeneratorType) 
 False 
 >>> isinstance(fab(5), types.GeneratorType) 
 True
fab 是无法迭代的，而 fab(5) 是可迭代的：
 >>> from collections import Iterable 
 >>> isinstance(fab, Iterable) 
 False 
 >>> isinstance(fab(5), Iterable) 
 True

每次调用 fab 函数都会生成一个新的 generator 实例，各实例互不影响：

>>> f1 = fab(3) 
 >>> f2 = fab(5) 
 >>> print 'f1:', f1.next() 
 f1: 1 
 >>> print 'f2:', f2.next() 
 f2: 1 
 >>> print 'f1:', f1.next() 
 f1: 1 
 >>> print 'f2:', f2.next() 
 f2: 1 
 >>> print 'f1:', f1.next() 
 f1: 2 
 >>> print 'f2:', f2.next() 
 f2: 2 
 >>> print 'f2:', f2.next() 
 f2: 3 
 >>> print 'f2:', f2.next() 
 f2: 5

return 的作用

在一个 generator function 中，如果没有 return，则默认执行至函数完毕，如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

另一个例子

另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取：

清单 9. 另一个 yield 的例子

 def read_file(fpath): 
  BLOCK_SIZE = 1024 
  with open(fpath, 'rb') as f: 
    while True: 
      block = f.read(BLOCK_SIZE) 
      if block: 
        yield block 
      else: 
        return

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung von yield in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!