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 __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__ == '__main__': main()
粗看代码,可能会觉着这个是个啥啊,为啥不直接用range
来生成,偏偏要用yield
,哎,不急,我们接着往下看为什么需要生成器,或者说,生成器解决了什么问题。
在说明这个问题之前,我们先来写一个需求,输出 0——10000000 以内的数据,而后运行查看导出内存运行截图。
这里可以借助python
的memory_profiler
模块来检测程序内存的占用情况。
安装memory_profiler
库:
pip3 install memory_profiler
使用方法很简单,在需要检测的函数或者是代码前添加@profile
装饰器即可,例如:
@profile def main(): pass
生成.dat
文件
mprof run
导出图示,可以使用
mprof plot --output=filename
以下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__ == '__main__': main()
代码也有了,就可以按照上述来运行一下程序,并且导出内存信息
main.py
运行内存图
main_2.py
运行内存图
如上2张对比图,当我们将数据叠加进列表,再输出的时候,占用内存接近400M,而使用迭代器来计算下一个值内存仅使用16M。
通过上述案例,我们应该知道为什么要使用生成器了吧。
由于生成器表达式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
函数,其类型都是生成器,我们可以使用type
rrreee
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 PythonAvant 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.
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🎜
range
et donne ensuite main.py
Program🎜rrreee🎜main_2.py
Program🎜rrreeemain.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!