在 python 中删除列表项对 reversed() 的影响

Question

据我所知，reversed() 函数提供了一个迭代器，其工作方式与iter() 类似，但会以相反的顺序提供项目。但是，我遇到了从 reversed() 函数返回的对象的奇怪行为。

通过查看：

lst = ['a', 'b', 'c', 'd']
iter_lst = iter(lst)
lst.remove('c')
print(list(iter_lst))

输出：['a', 'b', 'd']

正如预期的那样。但是：

lst = ['a', 'b', 'c', 'd']
rev_iter_lst = reversed(lst)
lst.remove('c')
print(list(rev_iter_lst))

输出：[]

不应该是：['d', 'b', 'a'] 吗？

列表对象中的__reversed__() 方法或迭代器对象中的__next__() 方法的实现是否阻止了这种情况？我的意思是，如果原始列表中的某些内容发生变化，它可能不会产生反向序列......

更新：我已经发布了一个可能修复它的答案here，我已经对此进行了测试，但我不知道是否存在这种实现会毫无例外的情况结果。

Answer 1

根据list.__reversed__source code，迭代器记住最后一个索引地址，返回记住最后一个索引地址的迭代器。 现在，当您删除一个项目时，它将移动所有索引并使最后一个地址指向无处，并且它将返回一个空列表，因为没有什么可以迭代。 让我再描述一下： 考虑以下列表：lst = ['a','b','c'] 还让我们假设lst[0] 在 100 并且每个字符是一个字节，所以字符 'c' 在 102 中。 当您创建一个受人尊敬的迭代器时，它会记住 102 作为起点。 在下一步中，我们省略 'b' 现在字符 'c' 在地址 101 中。 当您要求迭代器进行迭代时，它会开始查看位置 102。它会在那里找到什么？实际上什么都没有，显然它会返回一个空列表。

我希望这会有所帮助:)

编辑：字地址不正确。我必须改用索引...

Answer 2

list 调用将迭代反向迭代器，其 index < PyList_GET_SIZE(seq) 检查 here 将失败，因为您同时缩小了 seq，因此不会产生值而是停止：

listreviter_next(listreviterobject *it)
{
    (some checks)
    index = it->it_index;
    if (index>=0 && index < PyList_GET_SIZE(seq)) {
        (decrease the index and return the element)
    }
    (stop the iteration)
}

Answer 3

所以在与@kkasra12 讨论之后，我最终实现了 Python 的伪列表对象（没有进行所有必要的检查）来模仿它的行为，我只专注于 reverse() 操作。这是我的课：

class MyList:
    def __init__(self, n):
        self.length = n
        self._seq = list(range(n))

    @property
    def seq(self):
        return self._seq

    def __len__(self):
        return self.length

    def __getitem__(self, item):
        return self._seq[item]

    def __setitem__(self, idx, value):
        self._seq[idx] = value

    def __reversed__(self):
        return ReverseIterator(self)

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

    def append(self, v):
        self._seq.append(v)
        self.length += 1

    def remove(self, v):
        self._seq.remove(v)
        self.length -= 1

还有我的ReverseIterator：

class ReverseIterator:
    def __init__(self, org):
        self.org = org
        self._index = org.length

    def __iter__(self):
        return self

    def __next__(self):
        if 0 < self._index:
            try:
                item = self.org.seq[self._index - 1]
                self._index -= 1
                return item
            except IndexError:
                raise StopIteration()
        else:
            raise StopIteration()

结果：

obj = MyList(6)
iter_obj = iter(obj)
obj.remove(2)
print(list(iter_obj))

print('-----------------------')

obj = MyList(6)
rev_iter_obj = reversed(obj)
obj.remove(2)
print(list(rev_iter_obj))

输出：

[0, 1, 3, 4, 5]
-----------------------
[]

通过注释上面的remove 语句，我们可以看到它的工作方式与原始list 对象一样。

然后我创建了新的 SmartReverseIterator 迭代器，它可以处理从原始对象中删除项目的情况，并且可以动态生成值，就像iter() 在 OP 中的列表中工作一样。

唯一应该考虑的是，如果删除了一个项目（self._index 将小于原始对象的长度），则应重置 self._index。

class SmartReverseIterator:
    def __init__(self, org):
        self.org = org
        self._index = org.length

    def __iter__(self):
        return self

    def __next__(self):
        if 0 < self._index:
            try:
                item = self.org.seq[self._index - 1]
                return item

            except IndexError:
                self._index = self.org.length
                item = self.org.seq[self._index - 1]
                return item

            finally:
                self._index -= 1
        else:
            raise StopIteration()

通过更改MyList 上的__reversed__ 方法以返回这个新的迭代器，结果将是：

obj = MyList(6)
iter_obj = iter(obj)
obj.remove(2)
print(list(iter_obj))

print('-----------------------')

obj = MyList(6)
rev_iter_obj = reversed(obj)
obj.remove(2)
print(list(rev_iter_obj))

输出：

[0, 1, 3, 4, 5]
-----------------------
[5, 4, 3, 1, 0]

我想知道这是否有任何缺点，或者换句话说，为什么 python 决定不对这样的 list 对象实现 __reversed__ 方法，以确切地导致 iter() 如果项目是删除。

在什么情况下我们会看到问题？