for循环将遍历一个索引…

假设你有一个清单，

[5, 7, 13, 29, 65, 91]

您使用了一个名为lis的列表变量。你用同样的方法来移除…

你的变量

lis = [5, 7, 13, 29, 35, 65, 91]
       0  1   2   3   4   5   6

在第5次迭代中，

你的数字35不是质数，所以你把它从列表中删除了。

lis.remove(y)

然后下一个值(65)移动到前一个索引。

lis = [5, 7, 13, 29, 65, 91]
       0  1   2   3   4   5

所以第四次迭代完成指针移动到第五次…

这就是为什么你的循环没有覆盖65，因为它已经移动到前一个索引。

因此，你不应该将一个列表引用到另一个变量中，它仍然引用原始变量而不是副本。

ite = lis # Don’t do it will reference instead copy

所以使用list[::]复制列表。

现在你会付出，

[5, 7, 13, 29]

问题是你在迭代过程中从列表中删除了一个值，然后你的列表索引就会崩溃。

所以你可以试试列表理解。

它支持所有的可迭代对象，如list, tuple, dict, string等。

对于喜欢函数式编程的人:

somelist[:] = filter(lambda tup: not determine(tup), somelist)

or

from itertools import ifilterfalse
somelist[:] = list(ifilterfalse(determine, somelist))

变通方案概述

:

use a linked list implementation/roll your own. A linked list is the proper data structure to support efficient item removal, and does not force you to make space/time tradeoffs. A CPython list is implemented with dynamic arrays as mentioned here, which is not a good data type to support removals. There doesn't seem to be a linked list in the standard library however: Is there a linked list predefined library in Python? https://github.com/ajakubek/python-llist start a new list() from scratch, and .append() back at the end as mentioned at: https://stackoverflow.com/a/1207460/895245 This time efficient, but less space efficient because it keeps an extra copy of the array around during iteration. use del with an index as mentioned at: https://stackoverflow.com/a/1207485/895245 This is more space efficient since it dispenses the array copy, but it is less time efficient, because removal from dynamic arrays requires shifting all following items back by one, which is O(N).

一般来说，如果你做得很快，不想添加一个自定义LinkedList类，你只需要在默认情况下使用更快的.append()选项，除非内存是一个大问题。

官方Python 2教程4.2。“声明”

https://docs.python.org/2/tutorial/controlflow.html#for-statements

这部分文档明确说明:

您需要复制迭代列表才能修改它 一种方法是使用切片符号[:]

If you need to modify the sequence you are iterating over while inside the loop (for example to duplicate selected items), it is recommended that you first make a copy. Iterating over a sequence does not implicitly make a copy. The slice notation makes this especially convenient: >>> words = ['cat', 'window', 'defenestrate'] >>> for w in words[:]: # Loop over a slice copy of the entire list. ... if len(w) > 6: ... words.insert(0, w) ... >>> words ['defenestrate', 'cat', 'window', 'defenestrate']

Python 2文档7.3。“for语句”

https://docs.python.org/2/reference/compound_stmts.html#for

这部分文档再次说明你必须复制一份，并给出了一个实际的删除示例:

Note: There is a subtlety when the sequence is being modified by the loop (this can only occur for mutable sequences, i.e. lists). An internal counter is used to keep track of which item is used next, and this is incremented on each iteration. When this counter has reached the length of the sequence the loop terminates. This means that if the suite deletes the current (or a previous) item from the sequence, the next item will be skipped (since it gets the index of the current item which has already been treated). Likewise, if the suite inserts an item in the sequence before the current item, the current item will be treated again the next time through the loop. This can lead to nasty bugs that can be avoided by making a temporary copy using a slice of the whole sequence, e.g., for x in a[:]:

    if x < 0: a.remove(x)

然而，我不同意这个实现，因为.remove()必须遍历整个列表才能找到值。

Python能做得更好吗?

似乎这个特定的Python API可以得到改进。例如，将其与:

Java ListIterator::删除哪些文档“此调用只能对next或previous调用一次” c++ std::vector::erase，返回被删除元素之后的一个有效的互操作器

这两种方法都清楚地表明，除了使用迭代器本身，您不能修改正在迭代的列表，并为您提供了在不复制列表的情况下修改列表的有效方法。

可能潜在的基本原理是，Python列表被假定为动态数组支持，因此任何类型的删除都将是低效的，而Java在ListIterator的ArrayList和LinkedList实现方面都有更好的接口层次结构。

在Python标准库中似乎也没有显式的链表类型:Python链表

您可能希望使用内置的filter()。

更多详情请点击这里

其他答案是正确的，从你正在迭代的列表中删除通常是一个坏主意。反向迭代避免了一些陷阱，但是要遵循这样做的代码要困难得多，所以通常您最好使用列表理解或过滤器。

然而，有一种情况下，从您正在迭代的序列中删除元素是安全的:如果您在迭代时只删除一项。这可以通过返回或中断来确保。例如:

for i, item in enumerate(lst):
    if item % 4 == 0:
        foo(item)
        del lst[i]
        break

当您对满足某些条件的列表中的第一个项执行一些具有副作用的操作，然后立即从列表中删除该项时，这通常比列表推导式更容易理解。

如果您想在迭代期间做其他事情，那么最好同时获得索引(这保证您能够引用它，例如，如果您有一个字典列表)和实际的列表项内容。

inlist = [{'field1':10, 'field2':20}, {'field1':30, 'field2':15}]    
for idx, i in enumerate(inlist):
    do some stuff with i['field1']
    if somecondition:
        xlist.append(idx)
for i in reversed(xlist): del inlist[i]

Enumerate使您可以同时访问项和索引。反向是为了以后你要删除的索引不会改变。