next(iterable) 有效，但“for”循环只会创建一个无限循环

Question

我正在尝试递归遍历我的所有节点，但是我得到了一个无限循环。

class Dictionary:
    
    # STARTS CLASS NODE ################################################
    class Node:
        def __init__(self, key, value):
            self.key = key
            self.value = value
            self.nextNode = None

        def insert(self, key, value):
            if self.nextNode is None or key < self.nextNode.key:
                new = Dictionary.Node(key, value)
                new.nextNode = self.nextNode
                self.nextNode = new
            elif key > self.nextNode.key:
                self.nextNode.insert(key, value)
            else:
                pass

        def __iter__(self):
            if self.nextNode is None:
                return self
            else:
                return self.__next__().__iter__()

        def __next__(self):
            return self.nextNode

        def __str__(self):
            return f'{self.key} : {self.value}'
    # ENDS CLASS NODE ################################################

    def __init__(self):
        self.__head = None

    def insert(self, key, value):
        if self.__head is None or key < self.__head.key:
            new = self.Node(key, value)
            new.nextNode = self.__head
            self.__head = new
        elif key > self.__head.key:
            self.__head.insert(key, value)
        else:
            pass

    def __iter__(self):
        return self.__head

    def __str__(self):
        return str(self.__head)


d = Dictionary()
d.insert(2, 2)
d.insert(3, 3)
d.insert(4, 4)
d.insert(5, 5)

当我这样做时：

p = iter(d)
print(p)
print(next(p))
print(next(next(p))

它有效，但当我这样做时

for i in p:
    print(i)

我得到一个打印 3s 的无限循环。它甚至不跳转节点。

for 循环与执行 iter() 然后多次使用 next() 直到遇到条件（无）不一样吗？我不应该得到同样的东西吗？我做错了什么？

Answer 1

您的测试代码：

p = iter(d)
print(p)
print(next(p))
print(next(next(p)))

不是在 for 循环中发生的。

应该是这样的：

it = iter(d)
print(next(it))
print(next(it))
... 

使用你的类，这只会一遍又一遍地给你同样的元素。

迭代器是您反复调用next 的对象，它为您提供一系列元素，直到它引发异常以表明它已完成。您的 __next__ 实现只会在每次调用时返回 self.nextNode。它永远不会引发异常，因此没有信号表明迭代已完成。

如果您想显式编写迭代器，则需要创建和更新一个对象，以跟踪您通过迭代完成了多远，可能是这样的：

class NodeIter:
    def __init__(self, start):
        self.cur = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur is None:
            raise StopIteration()
        x = self.cur
        self.cur = x.nextNode
        return x

然后在你的字典中你会有：

    def __iter__(self):
        return NodeIter(self.__head)

---

或者，这里有一个快速编写 __iter__ 的方法，它将遍历所有节点：

def __iter__(self):
    cur = self.__head
    while cur is not None:
        yield cur
        cur = cur.nextNode

这是generator function，这是一种使用 yield 语句生成序列的简单方法。