Comment fonctionnent les générateurs en Python ?

Qu'est-ce qu'un générateur Python ?

Un générateur est un itérateur spécial. Il possède également les méthodes __iter__ et __next__ en interne. Lors de la terminaison du générateur, il lancera toujours StopIteration pour quitter la boucle, mais par rapport aux itérateurs, les générateurs ont également la fonctionnalité de sauvegarder des "valeurs intermédiaires", et utiliseront cette "valeur intermédiaire" lors de leur prochaine exécution pour fonctionner. Le mot-clé du générateur est <code>yield. Écrivons ci-dessous le générateur le plus simple. __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

En regardant le code, vous vous demandez peut-être ce que c'est, pourquoi ne pas simplement utiliser range pour le générer, mais utiliser yield, hé, ne vous inquiétez pas, nous Voyons ensuite pourquoi un générateur est nécessaire, ou en d'autres termes, quel problème le générateur résout.

Pourquoi avons-nous besoin d'un générateur Python

Avant d'expliquer ce problème, écrivons d'abord une exigence de sortie de données comprise entre 0 et 1 000 000, puis exécutons-la pour afficher la capture d'écran de l'opération de mémoire exportée.

Instructions auxiliaires pour appeler les informations sur la mémoire du programme Python

🎜Ici, vous pouvez utiliser le module memory_profiler de python pour détecter l'utilisation de la mémoire du programme. 🎜🎜Installez la bibliothèque memory_profiler : 🎜rrreee🎜L'utilisation est très simple, il suffit d'ajouter le décorateur @profile avant la fonction ou le code qui doit être détecté, par exemple : 🎜rrreee🎜 Générez le fichier .dat 🎜

🎜mprof run 🎜

🎜Pour exporter le diagramme, vous pouvez utiliser 🎜

🎜mprof plot --output= filename🎜

code de cas python

🎜Les deux programmes suivants génèrent tous deux des données comprises entre 0 et 9999999. La différence est que le premier programme utilise range et donne ensuite ajouter dans <code>list, et le second utilise un itérateur pour générer les données. 🎜🎜main.pyProgram🎜rrreee🎜main_2.pyProgram🎜rrreee

Exécutez le programme

🎜Maintenant que vous avez le code, vous pouvez l'exécuter comme le programme ci-dessus et exportez les informations sur la mémoire🎜🎜🎜

Afficher les informations sur la mémoire après l'exécution

🎜main.py Exécution du graphique de mémoire🎜🎜🎜🎜main_2.py Exécution du graphe de mémoire🎜🎜🎜🎜Comme le montrent les deux images de comparaison ci-dessus, lorsque l'on superpose les données dans la liste, puis lors de la sortie, cela occupe près de 400 Mo de mémoire, tandis que l'utilisation d'un itérateur pour calculer la valeur suivante n'utilise que 16 Mo de mémoire. 🎜🎜A travers les cas ci-dessus, nous devrions savoir pourquoi nous utilisons des générateurs. 🎜🎜Principe du générateur Python🎜🎜Étant donné que l'instruction yield de l'expression du générateur implique le mécanisme interne du pouvoir d'interprétation de python, il est difficile de visualiser son code source et d'obtenir son principe. , nous pouvons utiliser le mécanisme de pause de yield pour explorer le générateur. 🎜🎜Vous pouvez écrire le code suivant : 🎜rrreee🎜L'effet après l'exécution est le suivant🎜🎜🎜🎜Grâce aux exemples ci-dessus, combinés au processus de fonctionnement du générateur suivant, vous approfondirez votre compréhension du générateur. 🎜🎜Lorsque python rencontre l'instruction yield, il enregistre l'état d'exécution de la fonction actuelle, suspend l'exécution et renvoie le résultat. Il continuera d'attendre le prochain appel à la méthode __next__. Une fois cette méthode appelée, la fonction reprendra son exécution jusqu'à la prochaine instruction yield ou la fin de la fonction. . Il n'y aura pas de à la fin de l'exécution. Lorsque la fonction rendement est exécutable, StopIteration sera lancé pour marquer la fin du générateur. 🎜🎜Expression du générateur🎜🎜En python, en plus d'écrire le générateur dans une fonction et de le renvoyer en utilisant yield, vous pouvez également utiliser directement l'expression du générateur, euh. . . Cela peut paraître très abstrait, mais si vous regardez le code ci-dessous, vous comprendrez. 🎜rrreee🎜Parmi eux, le code (i for i in [1,2,3,4,5]) est équivalent à la fonction printNums, et ses types sont générateurs. Nous pouvons utiliser type pour l'imprimer et y jeter un œil. 🎜🎜Changez le code et le résultat de sortie est le suivant :🎜🎜🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!