2

我一直在以简单的方式遍历列表的内容以获取用户输入：

for n in [ 1, 2, 3, 4 ]:
 command = raw_input ( "%d >> " % (n) )
 ...

我想实现一个撤消功能，这意味着将迭代“倒回”回之前的值。这是一种天真的方法，它确实减少了 n 的值，但随后跳过了原始值，因为指向列表的内部指针没有改变：

for n in [ 1, 2, 3, 4 ]:
 if f(n):
  n -= 1
 ...

在文档中，我看到了 iterator.next()，但没有看到 iterator.last()。我想我可以切换到通过整数索引访问列表成员，并通过自己操作索引来手动滚动循环，这并不是那么危险，但是有更好的方法吗？

4

3 回答 3

9

在现有的 Python 中没有明显的方法可以做到这一点，但是制作自己的支持回溯的迭代器很容易。例如，后面是一个“可搜索”的迭代器。寻求相对 0 重复相同的元素，或相对 -1 回到前一个元素。

注意，因为这种迭代方式不享受“保证前进的进步”，它可以说更容易出现无限循环。

class SeekableIterator(object):
    """An iterator that supports seeking backwards or forwards."""

    def __init__(self, iterable):
        """Make a SeekableIterator over an iterable collection."""

        self.iterable = iterable
        self.index = None

    def __iter__(self):
        """Start the iteration."""

        self.index = 0
        return self

    def next(self):
        """Return the next item in the iterator."""

        try:
            value = self.iterable[self.index]
            self.index += 1
            return value
        except IndexError:
            raise StopIteration

    def seek(self, n, relative=False):
        """Adjust the loop counter, either relatively or to an absolute index.
        Note that seeking 0 replays the current item. Seeking -1 goes to
        the previous item. If the adjustment pushes the index outside the
        iterable's bounds, raise an index error."""

        if relative:
            self.index += n - 1
            # NB index already advanced one in next(), so subtracting one here
        else:
            self.index = n
        if self.index < 0 or self.index >= len(self.iterable):
            raise IndexError


if __name__ == '__main__':

    import random

    def prob(percent):
        """Return True with roughly the given probability, else False"""
        return random.random() <= (percent * 1.0 / 100.0)

    seeker = SeekableIterator([1, 2, 3, 4])
    for n in seeker:
        print "n:", n

        if prob(50):
            if prob(50):
                print "\tREDO - seeking 0"
                seeker.seek(0, relative=True)
            elif n > 1:
                print "\tUNDO - seeking -1"
                seeker.seek(-1, relative=True)

这是一个示例输出：

n: 1
n: 2
n: 3
n: 4
    REDO - seeking 0
n: 4
    REDO - seeking 0
n: 4
    UNDO - seeking -1
n: 3
n: 4
于 2012-06-19T20:17:30.887 回答
4

使用While循环：

lis = [1, 2, 3, 4]
i = 0
while i < len(lis):
    if some_condition:
        print(lis[i])
        i += 1
    elif some_other_condition:
        print(lis[i])
        i -= 1
于 2012-06-19T19:44:08.347 回答
1

共识是不，没有办法让 python 迭代器回溯。这个线程有更多信息：

让python迭代器倒退？

但是，您可能会幸运地将循环重组为稍微不同的格式。考虑以下类似 python 的伪代码：

unprocessed = [1,2,3,...]
processed = []

traverse(unprocessed, processed, processor_function):
    item = unprocessed.head()
    unprocessed = unprocessed.tail()
    processed.prepend(item)
    if processor_function != None:
        processor_function(item)

如有必要，您的主循环逻辑可以按任意顺序调用 traverse，切换已处理和未处理以模拟向后迭代。你可以传递你想要的任何处理函数，包括传递None给简单地跳过处理。处理完所有元素后，列表将如下所示：

unprocessed = []
processed = [...,3,2,1]

这有点像图灵机式的。“读头”总是在第一个列表的第一个元素之上，读头“右边”的所有元素都在第一个列表中，索引随距离递增，读头“左边”的所有元素都在在第二个列表中，索引随距离递增。“最接近”读取头的元素是靠近每个列表开头的元素。

于 2012-06-19T19:45:22.340 回答