如何使一个类可迭代，但不修改迭代器，如果你修改了类？

Question

我对python和编程都是新手，所以我很迷茫。我已经编写了一个“Node”类（如下文底部所示），它实例化了一个二叉搜索树和几个方法，如insert（）和elements（）（通过按顺序横切树返回元素列表）。我应该使这个类是可迭代的：“iter__(self)应该返回一个NodeIterator，它按照排序顺序从树中返回元素。修改树不应该修改现有的迭代器。”我现在正试图通过在类中插入以下代码来实现这一点：

 def __iter__(self):
    x=self.copy()
    x.i=0
    return x

def next(self):
    lst=x.elements()
    #??? No idea what to do from here.  

我定义了x=self.copy()以试图覆盖修改树不应该修改迭代器的事实，但我不知道这是不是正确的想法。下面是我的节点类，其中一个方法使用了装饰器：

def depth(old_f):
''' Write a decorator that overrides the standard behavior of
a function that returns True or False and instead returns
0 for False or n for number of recursive calls needed to
return True.
'''
    def new_f(*args):
        res = old_f(*args)
        if res is True:
            return 1
        elif res:
            return 1 + res
        else:
            return 0
    return new_f


Class Node(object):
'''
Modify your Node class from homework 4 as follows:

Two elements that compare equal shouldn't be allowed in the Tree. If a
copy is inserted, throw an AlreadyExistsException with the error
message "Element [x] is already in the tree".

__iter__(self) should return a NodeIterator, which returns elements from
the tree in sorted order. Modifying the tree should not modify
existing iterators.
'''
count = 0

def __init__(self, val, left=None, right=None):
    self.Val = val
    self.Left = left
    self.Right = right
    Node.count += 1

def __repr__(self):
    '''If the node has neither a left nor right child,
    simply return Node(val). Else, return Node(x, val, y),
    where x and y are recursive calls that return the
    left and right children, respectively.
    '''
    if self.Left is None and self.Right is None:
        return "Node({})".format(self.Val)
    else:
        return "Node({}, {}, {})".format(self.Left, self.Val, self.Right)

@depth
def search(self, element):
    ''' Finds whether a given element is in the tree.
    Returns True if the element is found, else returns False.

    Give it the depth decorator you defined earlier.
    '''
    if element == self.Val:
        return True
    elif self.Val > element and self.Left is not None:
        return self.Left.search(element)
    elif self.Val < element and self.Right is not None:
        return self.Right.search(element)
    else:
        return False

def insert(self, element):
    ''' Insert an element into a binary search tree rooted
    at this Node. After insertion, return the modified node.

    Our implementation will allow duplicate nodes. The left subtree
    should contain all elements <= to the current element, and the
    right subtree will contain all elements > the current element.
    '''
    if element <= self.Val:
        if self.Left is not None:
            self.Left.insert(element)
        else:
            self.Left = Node(element)
    else:
        if self.Right is not None:
            self.Right.insert(element)
        else:
            self.Right = Node(element)
    return self

def elements(self):
    ''' Return a list of the elements visited in an inorder traversal:
    http://en.wikipedia.org/wiki/Tree_traversal
    Note that this should be the sorted order if you've inserted all
    elements using your previously defined insert function.
    '''
    if self.Left is None and self.Right is None:
        return [self.Val]
    elif self.Left is None and self.Right is not None:
        return [self.Val] + self.Right.elements()
    elif self.Left is not None and self.Right is None:
        return self.Left.elements() + [self.Val]
    else:
        return self.Left.elements() + [self.Val] + self.Right.elements()

Answer 1

不要在类上定义next；这使得实例成为迭代器（它必须直接迭代对象），而您想要的是一个不是迭代器的iterable。为此，定义__iter__并让它在对象的副本上返回一个全新的迭代器。

由于您已经有了一个elements方法，可以有效地快照您的节点，因此使用它来创建快照迭代器并不难；复制结构是没有意义的，因为您只是按顺序迭代，而elements可以为您完成这项工作（并且在启动快照时使用更少的内存）。通常，我只需要使__iter__成为生成器函数，例如：

 def __iter__(self):
     # Python 3 simple version
     yield from self.elements()
     # Python 2 or 3 version
     for x in self.elements():
         yield x

但是由于您的分配调用了一个特殊的NodeIterator类，所以这是不行的。为此，您需要创建一个新类（可能在现有的node类中定义，以便为其命名）：

class Node(object):
    ...
    class NodeIterator(object):
        def __init__(self, node):
            self.it = iter(node.elements())

        def __iter__(self):
            return self

        def next(self):
            return next(self.it)
        __next__ = next  # Makes code work on Py2 and Py3 without modification

    def __iter__(self):
        return NodeIterator(self)

您可以理解为什么我通常不需要使用特殊类，因为__iter__的生成器函数（使用yield魔术的函数）要简单得多，但这是基本结构。您可以在Python wiki上了解更多关于迭代器的信息，或者在PythoncollectionsABC文档中了解基本接口的信息。