为什么重写iter会抛出递归错误？

Question

我想重写在外部库中定义的ExternalIter的__iter__方法，因此无法更改ExternalIter类的源代码。我在MyIter2和MyIter3中实现了两种不同的重写方式

class ExternalIter:
    
    def __init__(self):
        self.x = iter([
            (1, 2),
            (3, 4),
            (5, 6),
            (7, 8),
            (9, 10)
        ])
        
    def __iter__(self):
        return self
        
    def __next__(self):
        return next(self.x)
    
class MyIter2(ExternalIter):
    
    def __iter__(self):
        while True:
            try:
                i, j = super().__next__()
                yield i
                yield j
            except StopIteration:
                break
    
class MyIter3(ExternalIter):
    
    def __iter__(self):
        for i, j in super().__iter__():
            yield i
            yield j

ExternalIter的原始行为如下：

for i in ExternalIter():
    print(i)
# (1, 2)
# (3, 4)
# (5, 6)
# (7, 8)
# (9, 10)

我希望覆盖__iter__的行为，如以下示例所示：

for i in MyIter2():
    print(i)
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10

MyIter2除外。然而，我在MyIter3中所做的另一种重写方式是抛出RecursionError

for i in MyIter3():
    print(i)
---------------------------------------------------------------------------
RecursionError                            Traceback (most recent call last)
<ipython-input-8-4e1114201cac> in <module>
----> 1 for i in MyIter3():
      2     print(i)

<ipython-input-5-82da3324a8a3> in __iter__(self)
     30 
     31     def __iter__(self):
---> 32         for i, j in super().__iter__():
     33             yield i
     34             yield j

... last 1 frames repeated, from the frame below ...

<ipython-input-5-82da3324a8a3> in __iter__(self)
     30 
     31     def __iter__(self):
---> 32         for i, j in super().__iter__():
     33             yield i
     34             yield j

RecursionError: maximum recursion depth exceeded while calling a Python object

你能解释一下为什么重写的第二个实现在第一个方法工作时抛出错误吗？如何使用super().__iter__()覆盖__iter__，而不获取RecursionError

您能否解释一下__iter__在这个继承上下文中是如何工作的，以理解为什么super().__iter__()指的是self，而不是父级

Answer 1

super().__iter__()在^{之前返回self，for循环自己隐式调用iter(self)，从而启动无限递归

由于for循环是如何工作的，我在这里没有看到任何使用它的方法。您可以使用显式的while循环来避免调用__iter__

def __iter__(self):

    while True:
        try:
            i, j = next(self)
        except StopIteration:
            break
        yield i
        yield j

这并不是将self视为一个iterable，而是一个迭代器