Qu'est-ce qu'un itérateur python
? Prenons l'exemple le plus simple : python
迭代器呢? 举一个最简单的例子:
list1 = ["pdudo","juejin","hello"] tuple1 = ("pdudo","juejin","hello") dict1 = {"name":"pdudo"} for i in list1: print(i) for i in tuple1: print(i) for i in dict1: print(i)
这就是python
迭代器,好了,讲完了,手工。
是的,使用for...in
的方式,底层都是使用的是迭代器,你是不是之前写的时候,从来没有好奇过,为什么遍历不同的数据类型,都可以使用for...in
通用呢?
弟弟我也是一样的,没有想过,为什么可以这样写。迭代器语法我们已经讲了,接下来,我们来剥开迭代器的面纱吧。
只要符合python
迭代器条件的,都可以使用for...in
来遍历元素,即: 使用相同的代码,遍历不同的数据容器。 我认为这是根本原因。
如果上述描述还不清晰的话,我们可以使用c
和python
来遍历一下数组 和 字符串,就能清晰的了解了。
如上代码,是c
语言遍历数组"pdudo","hello","juejin"
和字符串pdudohellojuejin
,我们需要自己写遍历条件的临界值。
而如何使用python
来写呢? 来看下呢。
list1 = ["pdudo","hello","juejin"] char1 = "pdudohellojuejin" for v in list1: print(v) for c in char1: print(c)
只需要定义数组和字符串,而后使用for...in
便结束了。
我想,如上例子,就足以证明为什么要使用迭代器的原因了,因为真的很爽。
在经历了前2个段落的铺垫,我猜你肯定很想知道迭代器是如何工作的吧?现在它来了。
在使用for...in
语句时,它会调用inter()
对象,该函数会返回一个迭代器对象。该对象又定义了__next__()
方法,该方法一次返回一个容器元素,当没有更多元素可以返回的时候,会抛一个StopIteration
异常来表明for
终止循环。
是不是还是不懂?没关系,我们再写一个案例来说明一下。
list1 = ["pdudo","hello","juejin"] it = iter(list1) print(next(it)) print(next(it)) print(next(it)) print(next(it))
如上代码,定义了一个列表,其值为: "pdudo","hello","juejin",而后调用iter
方法,它将返回一个迭代器,而后调用next
方法来返回下一个元素,但是我们定义的列表长度为3,而调用了4次next
方法,可见,最后一次会抛异常。
我们执行后,效果如下:
可见,和我们上述猜想的一致,在for...in
语句中,也是调用inter()
容器对象,使用__next__
返回后续可迭代的对象,如此类推,直至遇到异常StopIteration
,循环结束。
好了,知道迭代器是如何工作了吧? 那么,我们再抛出一个问题,看你能否接住呢? 如何判断一个数据类型是能够被迭代的呢?
我们已经学会了如何使用迭代器,以及知晓了迭代器是如何工作的,本段落将介绍如何创建一个迭代器,在看这个之前,我们思考一个问题,如下代码是否会报错呢?
a = 9527 for i in a: print(i)
我们使用for...in
来遍历一个int
类型的数据。
如上代码,当然会报错,借此引出我们的知识点:什么样的数据类型才能被迭代呢?
是这样的,能否被迭代,取决于该方法是否有__iter__
方法。
可以看下如下例子,我们自定义了一个迭代器,用于倒叙输出数据。
#!/bin/env python class flashBack: def __init__(self,list1): self.data = list1 self.index = len(list1)-1 def __iter__(self): return self def __next__(self): if self.index < 0: raise StopIteration val = self.data[self.index] self.index = self.index - 1 return val def main(): list1 = [1,2,3,4,5] tuble1 = ("pdudo","juejin","hello") for i in flashBack(list1): print(i) for i in flashBack(tuble1): print(i) if __name__ == '__main__': main()
执行后,结果为:
可见,创建一个迭代器,至少需要 __iter__
方法 和 有__next__
方法。
好了,有了这个基础案例,我们来写一个链表?
#!/bin/env python class Node: def __init__(self,val): self.val = val self.nextNode = None class Lists: def __init__(self,currentNodes): self.currentNode = currentNodes def __iter__(self): return self def __next__(self): if self.currentNode is None: raise StopIteration v = self.currentNode.val self.currentNode = self.currentNode.nextNode return v def main() : node1 = Node(1) node2 = Node(2) node3 = Node(3) node1.nextNode = node2 node2.nextNode = node3 for i in Lists(node1): print(i) if __name__ == '__main__': main()
如上代码,我们先创建节点Node
,它有2个值,val
是记录的值,而nextNode
是记录下一个Node
的指针,而后定义了类Lists
,调用时候,需要传入一个Node
,它会将currentNodes
来记录当前的Node
重点看__next__
,当当前节点为空的时候,则返回StopIteration
告知for
迭代器结束了,否则的话,取出当前节点的val
rrreee
python
. Bon, c'est tout, faisons-le manuellement. Oui, en utilisant la méthode for...in
, la couche inférieure utilise des itérateurs. Avez-vous déjà été curieux de savoir pourquoi vous parcourez différents types de données lorsque vous avez écrit auparavant ? ...dans universellement ? Mon frère, je suis pareil, je n'ai jamais réfléchi à la raison pour laquelle je peux l'écrire comme ça. Nous avons déjà parlé de la syntaxe des itérateurs. Ensuite, levons le voile des itérateurs.
🎜Pourquoi avez-vous besoin d'un itérateur🎜🎜Tant qu'il remplit les conditions de l'itérateurpython
, vous pouvez utiliser for...in
pour parcourir les éléments, c'est-à-dire : Utilisez le même code qui traverse différents conteneurs de données. Je pense que c'est la cause profonde. 🎜🎜Si la description ci-dessus n'est pas encore claire, nous pouvons utiliser c
et python
pour parcourir le tableau et la chaîne, et nous aurons une compréhension claire. 🎜🎜🎜🎜Le code ci-dessus est Le langage c
traverse les tableaux "pdudo", "hello", "juejin"
et les chaînes pdudohellojuejin
, nous devons écrire les valeurs critiques de la traversée nous conditionne nous-mêmes. 🎜🎜Et comment utiliser python
pour écrire ? Jetons un coup d'oeil. 🎜rrreee🎜Définissez simplement le tableau et la chaîne, puis utilisez for...in
et vous avez terminé. 🎜🎜Je pense que l'exemple ci-dessus est suffisant pour prouver pourquoi vous devriez utiliser des itérateurs, car c'est vraiment cool. 🎜🎜Comment fonctionnent les itérateurs🎜🎜Après avoir parcouru la préparation des deux premiers paragraphes, je suppose que vous devez vouloir savoir comment fonctionnent les itérateurs, n'est-ce pas ? Maintenant, c'est ici. 🎜🎜Lors de l'utilisation de l'instruction for...in
, elle appellera l'objet inter()
, qui renverra un objet itérateur. L'objet définit également la méthode __next__()
, qui renvoie un élément conteneur à la fois. Lorsqu'aucun élément supplémentaire ne peut être renvoyé, une exception StopIteration
sera levée pour indiquer <. code>for termine la boucle. 🎜🎜Vous ne comprenez toujours pas ? Ce n’est pas grave, écrivons un autre cas pour illustrer. 🎜rrreee🎜Le code ci-dessus définit une liste dont les valeurs sont : "pdudo", "hello", "juejin", puis appelle la méthode iter
, qui renverra un itérateur, puis appelle next
pour renvoyer l'élément suivant, mais la longueur de la liste que nous avons définie est de 3, et la méthode next
est appelée 4 fois. une exception sera levée. 🎜🎜Après l'exécution, l'effet est le suivant :🎜🎜🎜🎜On peut voir que, conformément à notre conjecture ci-dessus, dans l'instruction for...in
, l'objet conteneur inter()
est également appelé, en utilisant __next__
Renvoyer les objets itérables suivants, et ainsi de suite, jusqu'à ce qu'une exception StopIteration
soit rencontrée et que la boucle se termine. 🎜🎜D'accord, savez-vous comment fonctionnent les itérateurs ? Alors, posons une autre question pour voir si vous pouvez y répondre ? Comment déterminer si un type de données peut être itéré ? 🎜🎜Comment créer un itérateur🎜🎜Nous avons appris à utiliser les itérateurs et savons comment fonctionnent les itérateurs. Ce paragraphe présentera comment créer un itérateur. Avant d'examiner cela, réfléchissons à une question, le code suivant générera une erreur. être signalé ? 🎜rrreee🎜Nous utilisons for...in
pour parcourir un type de données int
. 🎜🎜Le code ci-dessus signalera bien sûr une erreur, ce qui nous amène à notre point de connaissance : quel type de type de données peut être itéré ? 🎜🎜C'est tout, le fait qu'il puisse être itéré dépend du fait que la méthode ait ou non une méthode __iter__
. 🎜🎜Vous pouvez jeter un œil à l'exemple suivant. Nous avons personnalisé un itérateur pour les données de sortie flashback. 🎜rrreee🎜Après exécution, le résultat est :🎜🎜🎜🎜On voit que pour créer un itérateur, au moins la méthode __iter__
et la méthode __next__
sont requises. 🎜🎜D'accord, avec ce cas basique, écrivons une liste chaînée ? 🎜rrreee🎜Comme le montre le code ci-dessus, nous créons d'abord le nœud Node
, qui a 2 valeurs, val
est la valeur enregistrée et nextNode
est enregistré Un pointeur vers Node
, puis définit la classe Lists
Lors de l'appel, vous devez passer un Node
, qui passera. currentNodes
code> pour enregistrer le Node
actuel. Focus sur __next__
Lorsque le nœud actuel est vide, StopIteration
est. renvoyé pour informer for code>L'itérateur est terminé, sinon, prenez le <code>val
du nœud actuel et renvoyez-le, et faites-le glisser vers le nœud suivant. 🎜🎜Le code ci-dessus, après exécution, les résultats sont les suivants :🎜🎜🎜🎜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!