La différence entre les générateurs Python et les itérateurs

Pour les objets conteneurs tels que liste, chaîne, tuple, dict, etc., il est très pratique d'utiliser une boucle for pour parcourir. La fonction iter() est appelée sur l'objet conteneur en arrière-plan pour l'instruction. iter() est une fonction intégrée à Python. La fonction iter() renvoie un objet itérateur qui définit la méthode next(), qui accède aux éléments du conteneur un par un. next() est également une fonction intégrée de python. Lorsqu'il n'y a aucun élément suivant, next() lèvera une exception StopIteration pour notifier l'instruction for de la fin de la boucle.

Itérateur

Itérateur est utilisé pour nous aider à enregistrer la position visitée par chaque itération. Lorsque nous utilisons la fonction next() sur l'itérateur, l'itérateur nous renverra les données à la position suivante de la position enregistrée. En fait, lors de l'utilisation de la fonction next(), la méthode _next_ de l'objet itérateur est appelée (la méthode _next_ de l'objet en Python3, et la méthode next() de l'objet en Python2). Par conséquent, si nous voulons construire un itérateur, nous devons implémenter sa méthode _next_. Mais cela ne suffit pas. Python exige que l'itérateur lui-même soit itérable, nous devons donc également implémenter la méthode _iter_ pour l'itérateur, et la méthode _iter_ renvoie un itérateur. L'itérateur lui-même est un itérateur, donc itération La méthode _iter_ du. l'appareil peut revenir tout seul.

Explication de certains termes :

1. Protocole itérateur : l'objet doit fournir la méthode next(), qui renvoie l'élément suivant dans l'itération ou provoque Une exception StopIteration pour terminer l’itération.
2. Objet itérable : implémente l'objet de protocole itérateur. List, tuple et dict sont tous Iterable (objets itérables), mais pas Iterator (objets itérateurs). Mais vous pouvez utiliser la fonction intégrée iter() pour les transformer en Iterable (objets itérables).
3. L'essence de l'élément for dans la boucle Iterable est d'obtenir d'abord l'itérateur de l'objet itérable Iterable via la fonction iter(), puis d'appeler en continu la méthode next() sur l'itérateur obtenu pour obtenir la valeur suivante. et attribuez-le à l'élément For, la boucle se termine lorsqu'une exception StopIteration est rencontrée.

Recommandations associées : "Tutoriel vidéo Python"

Le propre cas d'objet conteneur de Python :

# 随便定义一个list
listArray=[1,2,3]
# 使用iter()函数
iterName=iter(listArray)
print(iterName)
# 结果如下：是一个列表list的迭代器
# <list_iterator object at 0x0000017B0D984278>
 
print(next(iterName))
print(next(iterName))
print(next(iterName))
print(next(iterName))#没有迭代到下一个元素，直接抛出异常
# 1
# 2
# 3
# Traceback (most recent call last):
# File "Test07.py", line 32, in <module>
# StopIteration

L'une des implémentations Python de la méthode _iter_ et de The L'objet de classe de la méthode _next_ est un itérateur. Le cas suivant est un cas de calcul de la séquence de Fibonacci

class Fib(object):
 def __init__(self, max):
  super(Fib, self).__init__()
  self.max = max
 
 def __iter__(self):
  self.a = 0
  self.b = 1
  return self
 
 def __next__(self):
  fib = self.a
  if fib > self.max:
   raise StopIteration
  self.a, self.b = self.b, self.a + self.b
  return fib
 
# 定义一个main函数，循环遍历每一个菲波那切数
def main():
 # 20以内的数
 fib = Fib(20)
 for i in fib:
  print(i)
 
# 测试
if __name__ == '__main__':
 main()

Explication :

est implémenté dans cette classe, définit un _iter_. (self), qui est appelée par iter() lorsque la boucle for parcourt et renvoie un itérateur. Parce que lors du parcours, la fonction intégrée python iter() est directement appelée, et iter() obtient l'itérateur de l'objet en appelant _iter_(self). Avec un itérateur, vous pouvez parcourir les éléments un par un. Lors du parcours un par un, la fonction intégrée next() est également utilisée pour parcourir l'objet itérateur en appelant la méthode _next_(self) de l'objet. Nous devons donc implémenter les deux méthodes _iter_(self) et _next_(self).

Et parce que la méthode _next_(self) est implémentée, lors de l'implémentation de _iter_(self), retournez simplement self directement.

Pour résumer en une phrase :

Lors d'une boucle sur l'objet conteneur personnalisé, la fonction intégrée de python iter() sera utilisée pour appeler le _iter_(self ) de l'objet parcouru pour obtenir un itérateur, puis la boucle utilise next() sur cet itérateur pour appeler _next_(self) de l'objet itérateur.

Remarque : _iter_(self) ne sera appelé qu'une seule fois, tandis que _next_(self) sera appelé n fois jusqu'à ce qu'une exception StopIteration se produise.

Générateur

Fonction :

Fonctionnement différé. Autrement dit, les résultats sont produits lorsque cela est nécessaire, et non immédiatement.

Remarque :

Le générateur ne peut être traversé qu'une seule fois.
Les générateurs sont un type spécial d'itérateur.

Catégorie :

第一类：生成器函数：还是使用 def 定义函数，但是，使用yield而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行。

# 菲波那切数列
def Fib(max):
 n, a, b = 0, 0, 1
 while n < max:
  yield b
  a, b = b, a + b
  n = n + 1
 return &#39;亲！没有数据了...&#39;
# 调用方法，生成出10个数来
f=Fib(10)
# 使用一个循环捕获最后return 返回的值，保存在异常StopIteration的value中
while True:
 try:
  x=next(f)
  print("f:",x)
 except StopIteration as e:
  print("生成器最后的返回值是：",e.value)
  break

第二类：生成器表达式：类似于列表推导，只不过是把一对大括号[]变换为一对小括号()。但是，生成器表达式是按需产生一个生成器结果对象，要想拿到每一个元素，就需要循环遍历。

如下案例加以说明：   

# 一个列表
xiaoke=[2,3,4,5]
# 生成器generator，类似于list，但是是把[]改为()
gen=(a for a in xiaoke)
for i in gen:
 print(i)
#结果是：
2
3
4
5
# 为什么要使用生成器？因为效率。
# 使用生成器表达式取代列表推导式可以同时节省 cpu 和 内存(RAM)。
# 如果你构造一个列表(list)的目的仅仅是传递给别的函数,
# 比如 传递给tuple()或者set(), 那就用生成器表达式替代吧! 
#本案例是直接把列表转化为元组
kk=tuple(a for a in xiaoke)
print(kk)
#结果是：
(2, 3, 4, 5) 
# python内置的一些函数，可以识别这是生成器表达式，外面有一对小括号，就是生成器
result1=sum(a for a in range(3))
print(result1)
# 列表推导式
result2=sum([a for a in range(3)])
print(result2)

区别：

生成器能做到迭代器能做的所有事,而且因为自动创建了 iter()和 next()方法,生成器显得特别简洁,而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法,当发生器终结时,还会自动抛出 StopIteration 异常。

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!