Wie funktionieren Generatoren in Python?

Was ist ein Python-Generator?

Ein Generator ist ein spezieller Iterator. Er verfügt auch intern über die Methoden __iter__. Beim Beenden des Generators wird immer noch StopIteration-Ausnahme, um die Schleife zu verlassen, aber im Vergleich zu Iteratoren verfügen Generatoren auch über die Funktion, „Zwischenwerte“ zu speichern und verwenden diesen „Zwischenwert“, wenn sie das nächste Mal ausgeführt werden. Das Schlüsselwort des Generators ist yield. Schreiben wir unten den einfachsten Generator. __iter__方法和__next__方法，在终止生成器的时候，还是会抛StopIteration异常以此来退出循环，只不过相比于迭代器，生成器还有特性会保存“中间值”，下次运行的时候，还会借助这个“中间值”来操作。生成器的关键字是yield，我们下面来写一个最简单的生成器。

#!/usr/bin/env python

def printNums():
    i = 0
    while i<10:
        yield i
        i = i + 1


def main():
    for i in printNums():
        print(i)

if __name__ == &#39;__main__&#39;:
    main()

粗看代码，可能会觉着这个是个啥啊，为啥不直接用range来生成，偏偏要用yield，哎，不急，我们接着往下看为什么需要生成器，或者说，生成器解决了什么问题。

为什么需要python生成器

在说明这个问题之前，我们先来写一个需求，输出 0——10000000 以内的数据，而后运行查看导出内存运行截图。

调用python程序内存信息辅助说明

这里可以借助python的memory_profiler模块来检测程序内存的占用情况。

安装memory_profiler库:

pip3 install memory_profiler

使用方法很简单，在需要检测的函数或者是代码前添加@profile装饰器即可，例如:

@profile
def main():
    pass

生成.dat文件

mprof run

导出图示，可以使用

mprof plot --output=filename

python案例代码

以下2个程序，都是输出0—9999999之间的数据，不同的是，第一个程序是使用range而后给append进list中，第二个则是使用迭代器来生成该数据。

main.py程序

@profile
def main():
    data = list(range(10000000))
    for i in data:
        pass

if __name__ == '__main__':
    main()

main_2.py程序

def printNum():
    i = 0 
    while i < 10000000:
        yield i
        i = i + 1

@profile
def main():
    for i in printNum():
        pass

if __name__ == &#39;__main__&#39;:
    main()

运行程序

代码也有了，就可以按照上述来运行一下程序，并且导出内存信息

运行后内存信息查看

main.py 运行内存图

main_2.py 运行内存图

如上2张对比图，当我们将数据叠加进列表，再输出的时候，占用内存接近400M，而使用迭代器来计算下一个值内存仅使用16M。

通过上述案例，我们应该知道为什么要使用生成器了吧。

python生成器原理

由于生成器表达式yield语句涉及到了python解释权内部机制，所以很难查看其源码，很难获取其原理，不过我们可以利用yield的暂停机制，来探寻一下生成器。

可以编写如下代码：

def testGenerator():
    print("进入生成器")
    yield "pdudo"
    print("第一次输出")
    yield "juejin"
    print("第二次输出")

def main():
    xx = testGenerator()
    print(next(xx))
    print(next(xx))

if __name__ == '__main__':
    main()

运行后效果如下

通过上述实例，再结合下面这段生成器的运行过程，会加深对生成器的感触。

当python遇到yield语句时，会记录当前函数的运行状态，并且暂停执行，将结果抛出。会持续等待下一次调用__next__方法，该方法调用后，会恢复函数的运行，直至下一个yield语句或者函数结束，执行到最后没有yield函数可执行的时候，会抛StopIteration来标志生成器的结束。

生成器表达式

在python中，生成器除了写在函数中，使用yield返回之外，还可以直接使用生成器表达式，额。。。可能很抽象，但是你看下面这段代码，你就明白了。

def printNums():
    for i in [1,2,3,4,5]:
        yield i

def main():
    for i in printNums():
        print(i)

    gener = (i for i in [1,2,3,4,5])
    for i in gener:
        print(i)

if __name__ == '__main__':
    main()

其中，代码(i for i in [1,2,3,4,5])就等同于printNums函数，其类型都是生成器，我们可以使用typerrreee

Wenn Sie sich den Code ansehen, fragen Sie sich vielleicht, was das ist. Warum nicht einfach range verwenden, um ihn zu generieren, sondern yield, hey, keine Sorge, wir Schauen wir uns dann an, warum ein Generator benötigt wird, oder mit anderen Worten, welches Problem der Generator löst.

Warum brauchen wir einen Python-Generator?

Bevor wir dieses Problem erklären, schreiben wir zunächst eine Anforderung zur Ausgabe von Daten im Bereich von 0-10000000 und führen diese dann aus, um den Screenshot des exportierten Speichervorgangs anzuzeigen.

Hilfsanweisungen zum Aufrufen von Speicherinformationen für Python-Programme

🎜Hier können Sie das Modul memory_profiler von python verwenden, um die Speichernutzung des Programms zu ermitteln. 🎜🎜Installieren Sie die memory_profiler-Bibliothek: 🎜rrreee🎜Die Verwendung ist sehr einfach. Fügen Sie einfach den @profile-Dekorator vor der Funktion oder dem Code hinzu, der erkannt werden muss, zum Beispiel: 🎜rrreee🎜 .dat-Datei generieren 🎜

🎜mprof run 🎜

🎜Um das Diagramm zu exportieren, können Sie 🎜

🎜mprof plot --output= verwenden Dateiname🎜

Python-Fallcode

🎜Die folgenden beiden Programme geben beide Daten zwischen 0 und 9999999 aus. Der Unterschied besteht darin, dass das erste Programm range verwendet und dann append in list, und der zweite verwendet einen Iterator, um die Daten zu generieren. 🎜🎜main.pyProgram🎜rrreee🎜main_2.pyProgram🎜rrreee

Führen Sie das Programm aus

🎜Jetzt, da Sie den Code haben, können Sie es ausführen Es wie oben beschrieben ausführen und Speicherinformationen exportieren Python" / >🎜

Speicherinformationen nach dem Ausführen anzeigen

🎜main.py Speicherdiagramm ausführen🎜🎜🎜🎜main_2.py Speicherdiagramm ausführen🎜🎜🎜🎜Wie in den beiden Vergleichsbildern oben gezeigt, wenn wir sie überlagern Fügen Sie die Daten in die Liste ein und nehmen Sie dann bei der Ausgabe fast 400 MB Speicher in Anspruch, während die Verwendung eines Iterators zum Berechnen des nächsten Werts nur 16 MB Speicher beansprucht. 🎜🎜Durch die oben genannten Fälle sollten wir wissen, warum wir Generatoren verwenden. 🎜🎜Python-Generatorprinzip🎜🎜Da die yield-Anweisung des Generatorausdrucks den internen Mechanismus der python-Interpretationsleistung beinhaltet, ist es jedoch schwierig, ihren Quellcode anzuzeigen und ihr Prinzip zu erhalten können wir den Pausenmechanismus von yield verwenden, um den Generator zu erkunden. 🎜🎜Sie können den folgenden Code schreiben: 🎜rrreee🎜Der Effekt nach dem Ausführen ist wie folgt🎜🎜🎜🎜Durch die obigen Beispiele in Kombination mit dem folgenden Generatorbetriebsprozess werden Sie Ihr Verständnis des Generators vertiefen. 🎜🎜Wenn python auf die yield-Anweisung stößt, zeichnet es den Ausführungsstatus der aktuellen Funktion auf, unterbricht die Ausführung und gibt das Ergebnis aus. Es wartet weiterhin auf den nächsten Aufruf der Methode __next__. Nach dem Aufruf dieser Methode wird die Funktion bis zur nächsten yield-Anweisung oder bis zum Ende der Funktion weiter ausgeführt . Am Ende der Ausführung wird kein angezeigt. Wenn die Funktion yield ausführbar ist, wird StopIteration ausgelöst, um das Ende des Generators zu markieren. 🎜🎜Generatorausdruck🎜🎜In Python können Sie nicht nur den Generator in eine Funktion schreiben und ihn mit yield zurückgeben, sondern auch den Generatorausdruck direkt verwenden, ähm. . . Es mag abstrakt sein, aber wenn Sie sich den Code unten ansehen, werden Sie es verstehen. 🎜rrreee🎜Unter diesen entspricht der Code (i for i in [1,2,3,4,5]) der Funktion printNums und seine Typen sind Generatoren können wir mit type ausdrucken und einen Blick darauf werfen. 🎜🎜Ändern Sie den Code und das Ausgabeergebnis ist wie folgt:🎜🎜🎜🎜

Das obige ist der detaillierte Inhalt vonWie funktionieren Generatoren in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!