Wie erstelle ich einen Iterator in Python?

Was ist ein Iterator?

Was ist ein Python-Iterator? Nehmen wir das einfachste Beispiel: 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__ == &#39;__main__&#39;:
    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迭代器结束了，否则的话，取出当前节点的valrrreee

Das ist der python-Iterator. Okay, das ist alles, machen wir es manuell.

Ja, bei Verwendung der for...in-Methode verwendet die unterste Ebene Iteratoren. Haben Sie sich jemals gefragt, warum Sie beim Schreiben verschiedene Datentypen durchlaufen? ...in allgemein?

Mein Bruder, mir geht es genauso. Ich habe nie darüber nachgedacht, warum ich es so schreiben kann. Wir haben bereits über die Iteratorsyntax gesprochen. Als nächstes wollen wir den Schleier der Iteratoren lüften.

🎜Warum brauchen Sie einen Iterator?🎜🎜Solange er die Bedingungen des python-Iterators erfüllt, können Sie for...in verwenden, um Elemente zu durchlaufen, das heißt: Verwenden Sie denselben Code, der verschiedene Datencontainer durchläuft. Ich denke, das ist die Hauptursache. 🎜🎜Wenn die obige Beschreibung noch nicht klar ist, können wir c und python verwenden, um das Array und die Zeichenfolge zu durchlaufen, und wir erhalten ein klares Verständnis. 🎜🎜🎜🎜Der obige Code ist Die c-Sprache durchläuft Arrays "pdudo", "hello", "juejin" und Zeichenfolgen pdudohellojuejin, wir müssen die kritischen Werte von schreiben die Durchquerungsbedingungen selbst. 🎜🎜Und wie verwende ich python zum Schreiben? Werfen wir einen Blick darauf. 🎜rrreee🎜Definieren Sie einfach das Array und die Zeichenfolge und verwenden Sie dann for...in und schon sind Sie fertig. 🎜🎜Ich denke, das obige Beispiel reicht aus, um zu beweisen, warum man Iteratoren verwenden sollte, denn es ist wirklich cool. 🎜🎜Wie Iteratoren funktionieren🎜🎜Nachdem Sie die Vorbereitungen in den ersten beiden Absätzen durchgearbeitet haben, werden Sie bestimmt wissen wollen, wie Iteratoren funktionieren, oder? Jetzt ist es da. 🎜🎜Bei Verwendung der for...in-Anweisung wird das inter()-Objekt aufgerufen, das ein Iteratorobjekt zurückgibt. Das Objekt definiert auch die Methode __next__(), die jeweils ein Containerelement zurückgibt. Wenn keine weiteren Elemente zurückgegeben werden können, wird eine StopIteration-Ausnahme ausgelöst, um for beendet die Schleife. 🎜🎜Verstehst du immer noch nicht? Es spielt keine Rolle, schreiben wir zur Veranschaulichung einen anderen Fall. 🎜rrreee🎜Der obige Code definiert eine Liste mit den Werten „pdudo“, „hello“, „juejin“ und ruft dann die Methode iter auf, die einen Iterator zurückgibt, und ruft dann auf Die Methode next gibt das nächste Element zurück, aber die Länge der von uns definierten Liste beträgt 3, und die Methode next wird viermal aufgerufen Es wird eine Ausnahme ausgelöst. 🎜🎜Nachdem wir es ausgeführt haben, ist der Effekt wie folgt:🎜🎜🎜🎜Es ist ersichtlich, dass in Übereinstimmung mit unserer obigen Vermutung in der for...in-Anweisung das Containerobjekt inter() vorhanden ist Wird auch aufgerufen und verwendet __next__ . Gibt nachfolgende iterierbare Objekte zurück usw., bis eine Ausnahme StopIteration auftritt und die Schleife endet. 🎜🎜Okay, wissen Sie, wie Iteratoren funktionieren? Also, lass uns noch eine Frage stellen, um zu sehen, ob du sie beantworten kannst? Wie kann festgestellt werden, ob ein Datentyp iteriert werden kann? 🎜🎜So erstellen Sie einen Iterator🎜🎜Wir haben gelernt, wie man Iteratoren verwendet und wissen, wie Iteratoren funktionieren. Bevor wir uns das ansehen, denken wir über eine Frage nach: Der folgende Code wird ein Fehler sein gemeldet werden? 🎜rrreee🎜Wir verwenden for...in, um einen Datentyp int zu durchlaufen. 🎜🎜Der obige Code meldet natürlich einen Fehler, der zu unserem Wissenspunkt führt: Welche Art von Datentyp kann iteriert werden? 🎜🎜Das ist alles, ob es iteriert werden kann, hängt davon ab, ob die Methode eine __iter__-Methode hat. 🎜🎜Sie können sich das folgende Beispiel ansehen. Wir haben einen Iterator für Flashback-Ausgabedaten angepasst. 🎜rrreee🎜Nach der Ausführung ist das Ergebnis:🎜🎜🎜🎜Es ist ersichtlich, dass zum Erstellen eines Iterators mindestens die Methode __iter__ und die Methode __next__ erforderlich sind. 🎜🎜Okay, schreiben wir in diesem Grundfall eine verknüpfte Liste? 🎜rrreee🎜Wie im obigen Code gezeigt, erstellen wir zuerst den Knoten Node, der zwei Werte hat, val ist der aufgezeichnete Wert und nextNode wird als Zeiger auf Node aufgezeichnet und definiert dann die Klasse Lists. Beim Aufruf müssen Sie einen Node übergeben, der übergeben wird currentNodes code> zum Aufzeichnen des aktuellen Node. Wenn der aktuelle Knoten leer ist, ist StopIteration wird zurückgegeben, um for code> zu informieren. Der Iterator ist beendet. Andernfalls nehmen Sie den <code>val des aktuellen Knotens, geben ihn zurück und schieben ihn nach unten zum nächsten Knoten. 🎜🎜Nach dem Ausführen des obigen Codes sind die Ergebnisse wie folgt:🎜🎜🎜🎜

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