Как удалить элементы из списка во время итерации?

Я перебираю список кортежей в Python и пытаюсь удалить их, если они соответствуют определенным критериям.

for tup in somelist:
    if determine(tup):
         code_to_remove_tup

Что я должен использовать вместо code_to_remove_tup? Я не могу понять, как удалить предмет таким способом.

Вы можете использовать понимание списка, чтобы создать новый список, содержащий только те элементы, которые вы не хотите удалять:

somelist = [x for x in somelist if not determine(x)]

Или, назначив фрагменту somelist[:], вы можете изменить существующий список, чтобы он содержал только те элементы, которые вы хотите:

somelist[:] = [x for x in somelist if not determine(x)]

Этот подход может быть полезен, если есть другие ссылки, somelistкоторые должны отражать изменения.

Вместо понимания вы также можете использовать itertools. В Python 2:

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

Или в Python 3:

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

Для ясности и для тех, кто находит использование [:]обозначений хакерским или нечетким, вот более явная альтернатива. Теоретически, он должен выполнять то же самое в отношении пространства и времени, чем указанные выше строки.

temp = []
while somelist:
    x = somelist.pop()
    if not determine(x):
        temp.append(x)
while temp:
    somelist.append(templist.pop())

Он также работает на других языках, которые могут не иметь возможности замены элементов в списках Python, с минимальными изменениями. Например, не все языки приводят пустые списки к a, Falseкак это делает Python. Вы можете заменить while somelist:что-то более явное, как while len(somelist) > 0:.

Ответы, предполагающие понимание списка, почти верны - за исключением того, что они строят совершенно новый список и затем дают ему то же имя, что и старый список, они НЕ изменяют старый список на месте. Это отличается от того, что вы делаете при выборочном удалении, как в предложении @ Lennart - это быстрее, но если к вашему списку обращаются по нескольким ссылкам, тот факт, что вы просто повторно устанавливаете одну из ссылок и НЕ изменяете объект списка само по себе может привести к тонким, катастрофическим ошибкам.

К счастью, очень легко получить как скорость понимания списка, так и требуемую семантику изменения на месте - просто код:

somelist[:] = [tup for tup in somelist if determine(tup)]

Обратите внимание на небольшую разницу с другими ответами: этот НЕ присваивается пустому имени - он присваивает фрагменту списка, который просто является целым списком, тем самым заменяя содержимое списка в том же объекте списка Python , а не просто перезаписывая одну ссылку (из предыдущего объекта списка в новый объект списка), как и другие ответы.

Вам нужно сначала взять копию списка и повторить его, иначе итерация не удастся, что может привести к неожиданным результатам.

Например (зависит от того, какой тип списка):

for tup in somelist[:]:
    etc....

Пример:

>>> somelist = range(10)
>>> for x in somelist:
...     somelist.remove(x)
>>> somelist
[1, 3, 5, 7, 9]

>>> somelist = range(10)
>>> for x in somelist[:]:
...     somelist.remove(x)
>>> somelist
[]

for i in range(len(somelist) - 1, -1, -1):
    if some_condition(somelist, i):
        del somelist[i]

Тебе нужно идти задом наперед, иначе это похоже на спиливание ветки дерева, на котором ты сидишь :-)

Пользователи Python 2: замените range, xrangeчтобы избежать создания жестко закодированного списка

Официальное руководство по Python 2 4.2. "для заявлений"

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

Эта часть документов дает понять, что:

• вам нужно сделать копию итеративного списка, чтобы изменить его
• Один из способов сделать это с помощью обозначения среза [:]

Если вам нужно изменить последовательность, которую вы повторяете внутри цикла (например, для дублирования выбранных элементов), рекомендуется сначала сделать копию. Итерация по последовательности неявно делает копию. Обозначение среза делает это особенно удобным:

>>> 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. "За заявление"

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

Эта часть документов еще раз говорит о том, что вы должны сделать копию, и приводит фактический пример удаления:

Примечание: есть тонкость, когда последовательность модифицируется циклом (это может происходить только для изменяемых последовательностей, то есть списков). Внутренний счетчик используется для отслеживания того, какой элемент используется следующим, и он увеличивается на каждой итерации. Когда этот счетчик достигнет длины последовательности, цикл завершается. Это означает, что если набор удаляет текущий (или предыдущий) элемент из последовательности, следующий элемент будет пропущен (поскольку он получает индекс текущего элемента, который уже был обработан). Аналогично, если набор вставляет элемент в последовательность перед текущим элементом, текущий элемент будет обработан снова в следующий раз в цикле. Это может привести к неприятным ошибкам, которых можно избежать, сделав временную копию с использованием фрагмента всей последовательности, например,

for x in a[:]:
    if x < 0: a.remove(x)

Однако я не согласен с этой реализацией, поскольку .remove()приходится перебирать весь список, чтобы найти значение.

Лучшие обходные пути

Или:

• начать новый массив с нуля и .append()вернуться в конец: https://stackoverflow.com/a/1207460/895245

  Это экономит время, но экономит меньше места, поскольку сохраняет копию массива во время итерации.

• использовать delс индексом: https://stackoverflow.com/a/1207485/895245

  Это более экономно, так как распределяет копию массива, но менее эффективно по времени, поскольку списки CPython реализованы с помощью динамических массивов .

  Это означает, что удаление предмета требует сдвига всех следующих предметов назад на один, что является O (N).

Как правило, вы просто хотите .append()выбрать более быстрый вариант по умолчанию, если только память не представляет большой проблемы.

Мог ли Python сделать это лучше?

Похоже, что этот конкретный Python API может быть улучшен. Сравните это, например, с:

• Java ListIterator :: удалить какие документы "Этот вызов может быть сделан только один раз за вызов следующего или предыдущего"
• C ++, std::vector::eraseкоторый возвращает действительный интегратор элемента после того, как тот удален

и то, и другое ясно показывает, что вы не можете изменять итерируемый список, кроме как с помощью самого итератора, и дает вам эффективные способы сделать это без копирования списка.

Возможно, основное обоснование заключается в том, что списки Python предполагаются с поддержкой динамического массива, и, следовательно, любой тип удаления будет неэффективным по времени в любом случае, в то время как Java имеет более приятную иерархию интерфейса с обеими реализациями ArrayListи LinkedListреализациями ListIterator.

Похоже, в Python stdlib нет явного связанного типа списка: Python Linked List

Лучшим подходом для такого примера будет понимание списка

somelist = [tup for tup in somelist if determine(tup)]

В тех случаях, когда вы делаете что-то более сложное, чем вызов determineфункции, я предпочитаю создавать новый список и просто добавлять его по мере необходимости. Например

newlist = []
for tup in somelist:
    # lots of code here, possibly setting things up for calling determine
    if determine(tup):
        newlist.append(tup)
somelist = newlist

Копирование списка с использованием removeможет сделать ваш код немного чище, как описано в одном из ответов ниже. Вы определенно не должны делать это для очень больших списков, поскольку это включает в себя сначала копирование всего списка, а также выполнение O(n) removeоперации для каждого удаляемого элемента, что делает это O(n^2)алгоритмом.

for tup in somelist[:]:
    # lots of code here, possibly setting things up for calling determine
    if determine(tup):
        newlist.append(tup)

Для тех, кто любит функциональное программирование:

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

или

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

Мне нужно было сделать это с огромным списком, и дублирование списка казалось дорогим, тем более что в моем случае количество удалений было бы небольшим по сравнению с оставшимися элементами. Я выбрал этот низкоуровневый подход.

array = [lots of stuff]
arraySize = len(array)
i = 0
while i < arraySize:
    if someTest(array[i]):
        del array[i]
        arraySize -= 1
    else:
        i += 1

Что я не знаю, так это то, насколько эффективна пара удалений по сравнению с копированием большого списка. Пожалуйста, прокомментируйте, если у вас есть понимание.

Также было бы разумно просто создать новый список, если текущий элемент списка соответствует желаемым критериям.

так:

for item in originalList:
   if (item != badValue):
        newList.append(item)

и чтобы избежать необходимости перекодировать весь проект с новым именем списков:

originalList[:] = newList

обратите внимание, из документации Python:

copy.copy (x) Возвращает мелкую копию x.

copy.deepcopy (x) Возвращает глубокую копию x.

Этот ответ был первоначально написан в ответ на вопрос, который был помечен как дубликат: удаление координат из списка на python

В вашем коде есть две проблемы:

1) При использовании remove () вы пытаетесь удалить целые числа, тогда как вам нужно удалить кортеж.

2) Цикл for пропустит элементы в вашем списке.

Давайте разберемся, что происходит, когда мы выполняем ваш код:

>>> L1 = [(1,2), (5,6), (-1,-2), (1,-2)]
>>> for (a,b) in L1:
...   if a < 0 or b < 0:
...     L1.remove(a,b)
... 
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: remove() takes exactly one argument (2 given)

Первая проблема заключается в том, что вы передаете оба «a» и «b» для remove (), но remove () принимает только один аргумент. Итак, как мы можем заставить remove () правильно работать с вашим списком? Нам нужно выяснить, что представляет собой каждый элемент вашего списка. В этом случае каждый из них является кортежем. Чтобы увидеть это, давайте перейдем к одному элементу списка (индексация начинается с 0):

>>> L1[1]
(5, 6)
>>> type(L1[1])
<type 'tuple'>

Ага! Каждый элемент L1 на самом деле является кортежем. Так вот что мы должны передать, чтобы удалить (). Кортежи в python очень просты, они просто создаются путем заключения значений в скобки. «a, b» не является кортежем, но «(a, b)» является кортежем. Поэтому мы модифицируем ваш код и запускаем его снова:

# The remove line now includes an extra "()" to make a tuple out of "a,b"
L1.remove((a,b))

Этот код выполняется без ошибок, но давайте посмотрим на список, который он выводит:

L1 is now: [(1, 2), (5, 6), (1, -2)]

Почему (1, -2) все еще в вашем списке? Оказывается, изменение списка при использовании цикла для его перебора - очень плохая идея без особой осторожности. Причина того, что (1, -2) остается в списке, заключается в том, что местоположения каждого элемента в списке менялись между итерациями цикла for. Давайте посмотрим, что произойдет, если мы добавим приведенный выше код в более длинный список:

L1 = [(1,2),(5,6),(-1,-2),(1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
### Outputs:
L1 is now: [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]

Как вы можете сделать из этого результата, каждый раз, когда условный оператор оценивается как true и элемент списка удаляется, следующая итерация цикла будет пропускать оценку следующего элемента в списке, поскольку его значения теперь расположены с разными индексами.

Наиболее интуитивным решением является копирование списка, затем итерация по исходному списку и изменение только копии. Вы можете попробовать сделать это так:

L2 = L1
for (a,b) in L1:
    if a < 0 or b < 0 :
        L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
print L2 is L1
del L1
L1 = L2; del L2
print ("L1 is now: ", L1)

Однако выходные данные будут идентичны предыдущим:

'L1 is now: ', [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]

Это потому, что когда мы создали L2, python фактически не создавал новый объект. Вместо этого он просто ссылался на L2 на тот же объект, что и L1. Мы можем проверить это с помощью «is», которое отличается от просто «равно» (==).

>>> L2=L1
>>> L1 is L2
True

Мы можем сделать настоящую копию, используя copy.copy (). Тогда все работает как положено:

import copy
L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
L2 = copy.copy(L1)
for (a,b) in L1:
    if a < 0 or b < 0 :
        L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
del L1
L1 = L2; del L2
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]

Наконец, есть одно более чистое решение, чем создание совершенно новой копии L1. Обратный () функция:

L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
for (a,b) in reversed(L1):
    if a < 0 or b < 0 :
        L1.remove((a,b))
print ("L1 is now: ", L1)
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]

К сожалению, я не могу адекватно описать, как работает reversed (). Он возвращает объект 'listreverseiterator', когда ему передается список. В практических целях вы можете думать об этом как о создании обратной копии аргумента. Это решение, которое я рекомендую.

Если вы хотите сделать что-то еще во время итерации, может быть неплохо получить как индекс (который гарантирует вам возможность ссылаться на него, например, если у вас есть список диктов), так и фактическое содержимое элемента списка.

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дает вам доступ к элементу и индексу сразу. reversedтак что индексы, которые вы собираетесь удалить позже, не изменятся на вас.

Вы можете использовать filter() доступные как встроенные.

Для более подробной информации проверьте здесь

Большинство ответов здесь хотят, чтобы вы создали копию списка. У меня был случай использования, когда список был довольно длинным (110 КБ), и было разумнее продолжать сокращать список.

Прежде всего вам нужно заменить цикл foreach на цикл while ,

i = 0
while i < len(somelist):
    if determine(somelist[i]):
         del somelist[i]
    else:
        i += 1

Значение iв блоке if не изменяется, потому что вы захотите получить значение нового элемента из того же индекса после удаления старого элемента.

Вы можете попробовать выполнить цикл в обратном порядке, поэтому для some_list вы будете делать что-то вроде:

list_len = len(some_list)
for i in range(list_len):
    reverse_i = list_len - 1 - i
    cur = some_list[reverse_i]

    # some logic with cur element

    if some_condition:
        some_list.pop(reverse_i)

Таким образом, индекс выравнивается и не страдает от обновления списка (независимо от того, используете ли вы элемент cur или нет).

Одно из возможных решений, полезное, если вы хотите не только удалить некоторые вещи, но и сделать что-то со всеми элементами в одном цикле:

alist = ['good', 'bad', 'good', 'bad', 'good']
i = 0
for x in alist[:]:
    if x == 'bad':
        alist.pop(i)
        i -= 1
    # do something cool with x or just print x
    print(x)
    i += 1

Мне нужно было сделать что-то похожее, и в моем случае проблема заключалась в памяти - мне нужно было объединить несколько объектов набора данных в списке, после того, как они поработали с ними, в новый объект, и мне нужно было избавиться от каждой записи, с которой я сливался. избегайте дублирования их всех и взрыва памяти. В моем случае наличие объектов в словаре вместо списка работало нормально:

`` `

k = range(5)
v = ['a','b','c','d','e']
d = {key:val for key,val in zip(k, v)}

print d
for i in range(5):
    print d[i]
    d.pop(i)
print d

`` `

TLDR:

Я написал библиотеку, которая позволяет вам сделать это:

from fluidIter import FluidIterable
fSomeList = FluidIterable(someList)  
for tup in fSomeList:
    if determine(tup):
        # remove 'tup' without "breaking" the iteration
        fSomeList.remove(tup)
        # tup has also been removed from 'someList'
        # as well as 'fSomeList'

Лучше использовать другой метод, если это возможно, который не требует изменения вашей итерации при ее повторении, но для некоторых алгоритмов это может быть не так просто. И поэтому, если вы уверены, что действительно хотите код шаблона, описанный в исходном вопросе, это возможно.

Должен работать со всеми изменяемыми последовательностями, а не только со списками.

Полный ответ:

Редактировать: последний пример кода в этом ответе дает пример использования того, почему вы можете захотеть изменить список на месте, а не использовать его для понимания. Первая часть ответов служит руководством к тому, как можно изменить массив на месте.

Решение следует из этого ответа (для связанного вопроса) от senderle. Что объясняет, как индекс массива обновляется при переборе списка, который был изменен. Приведенное ниже решение предназначено для правильного отслеживания индекса массива, даже если список изменен.

Скачать fluidIter.pyс здесь https://github.com/alanbacon/FluidIterator , это просто один файл поэтому нет необходимости устанавливать мерзавца. Установщика не существует, поэтому вам нужно убедиться, что файл находится в пути python. Код был написан для Python 3 и не тестировался на Python 2.

from fluidIter import FluidIterable
l = [0,1,2,3,4,5,6,7,8]  
fluidL = FluidIterable(l)                       
for i in fluidL:
    print('initial state of list on this iteration: ' + str(fluidL)) 
    print('current iteration value: ' + str(i))
    print('popped value: ' + str(fluidL.pop(2)))
    print(' ')

print('Final List Value: ' + str(l))

Это даст следующий результат:

initial state of list on this iteration: [0, 1, 2, 3, 4, 5, 6, 7, 8]
current iteration value: 0
popped value: 2

initial state of list on this iteration: [0, 1, 3, 4, 5, 6, 7, 8]
current iteration value: 1
popped value: 3

initial state of list on this iteration: [0, 1, 4, 5, 6, 7, 8]
current iteration value: 4
popped value: 4

initial state of list on this iteration: [0, 1, 5, 6, 7, 8]
current iteration value: 5
popped value: 5

initial state of list on this iteration: [0, 1, 6, 7, 8]
current iteration value: 6
popped value: 6

initial state of list on this iteration: [0, 1, 7, 8]
current iteration value: 7
popped value: 7

initial state of list on this iteration: [0, 1, 8]
current iteration value: 8
popped value: 8

Final List Value: [0, 1]

Выше мы использовали popметод объекта списка флюидов. Другие общие Iterable также реализованы методы , такие как del fluidL[i], .remove, .insert, .append, .extend. Список также можно изменить с помощью срезов ( sortиreverse методы не реализованы).

Единственным условием является то, что вы должны только изменить список на месте, если в какой-то момент fluidLили если он lбыл переназначен на другой объект списка, код не будет работать. Исходный fluidLобъект по-прежнему будет использоваться циклом for, но мы не сможем его изменить.

т.е.

fluidL[2] = 'a'   # is OK
fluidL = [0, 1, 'a', 3, 4, 5, 6, 7, 8]  # is not OK

Если мы хотим получить доступ к текущему значению индекса списка, мы не можем использовать перечисление, поскольку это только подсчитывает, сколько раз цикл for выполнялся. Вместо этого мы будем использовать объект итератора напрямую.

fluidArr = FluidIterable([0,1,2,3])
# get iterator first so can query the current index
fluidArrIter = fluidArr.__iter__()
for i, v in enumerate(fluidArrIter):
    print('enum: ', i)
    print('current val: ', v)
    print('current ind: ', fluidArrIter.currentIndex)
    print(fluidArr)
    fluidArr.insert(0,'a')
    print(' ')

print('Final List Value: ' + str(fluidArr))

Это выведет следующее:

enum:  0
current val:  0
current ind:  0
[0, 1, 2, 3]

enum:  1
current val:  1
current ind:  2
['a', 0, 1, 2, 3]

enum:  2
current val:  2
current ind:  4
['a', 'a', 0, 1, 2, 3]

enum:  3
current val:  3
current ind:  6
['a', 'a', 'a', 0, 1, 2, 3]

Final List Value: ['a', 'a', 'a', 'a', 0, 1, 2, 3]

FluidIterableКласс просто предоставляет обертку для исходного объекта списка. Доступ к исходному объекту можно получить как свойство объекта Fluid, например:

originalList = fluidArr.fixedIterable

Больше примеров / тестов можно найти в if __name__ is "__main__":разделе внизу fluidIter.py. На них стоит посмотреть, потому что они объясняют, что происходит в различных ситуациях. Например: замена больших разделов списка с использованием фрагмента. Или используя (и модифицируя) ту же итерацию во вложенных циклах for.

Как я уже сказал, для начала: это сложное решение, которое ухудшит читабельность вашего кода и затруднит его отладку. Поэтому другие решения , такие как списковые упомянутый в Дэвиде Raznick в ответе следует считать первым. При этом я нашел случаи, когда этот класс был полезен для меня и его было проще использовать, чем отслеживать индексы элементов, которые необходимо удалить.

Изменить: как уже упоминалось в комментариях, этот ответ на самом деле не представляет проблему, для которой этот подход обеспечивает решение. Я постараюсь рассмотреть это здесь:

Понимание списка обеспечивает способ создания нового списка, но эти подходы имеют тенденцию рассматривать каждый элемент изолированно, а не текущее состояние списка в целом.

т.е.

newList = [i for i in oldList if testFunc(i)]

Но что, если результат testFuncзависит от уже добавленных элементов newList? Или элементы все еще вoldList этом, могут быть добавлены далее? Может все же быть способ использовать понимание списка, но он начнет терять свою элегантность, и для меня легче изменить список на месте.

Приведенный ниже код является одним из примеров алгоритма, который страдает от вышеуказанной проблемы. Алгоритм сократит список, так что ни один элемент не будет кратным любому другому элементу.

randInts = [70, 20, 61, 80, 54, 18, 7, 18, 55, 9]
fRandInts = FluidIterable(randInts)
fRandIntsIter = fRandInts.__iter__()
# for each value in the list (outer loop)
# test against every other value in the list (inner loop)
for i in fRandIntsIter:
    print(' ')
    print('outer val: ', i)
    innerIntsIter = fRandInts.__iter__()
    for j in innerIntsIter:
        innerIndex = innerIntsIter.currentIndex
        # skip the element that the outloop is currently on
        # because we don't want to test a value against itself
        if not innerIndex == fRandIntsIter.currentIndex:
            # if the test element, j, is a multiple 
            # of the reference element, i, then remove 'j'
            if j%i == 0:
                print('remove val: ', j)
                # remove element in place, without breaking the
                # iteration of either loop
                del fRandInts[innerIndex]
            # end if multiple, then remove
        # end if not the same value as outer loop
    # end inner loop
# end outerloop

print('')
print('final list: ', randInts)

Результат и окончательный сокращенный список показаны ниже

outer val:  70

outer val:  20
remove val:  80

outer val:  61

outer val:  54

outer val:  18
remove val:  54
remove val:  18

outer val:  7
remove val:  70

outer val:  55

outer val:  9
remove val:  18

final list:  [20, 61, 7, 55, 9]

Самый эффективный метод - это понимание списка, многие люди показывают свое дело, конечно, это также хороший способ справиться с iteratorситуацией filter.

Filterполучает функцию и последовательность. Filterприменяет переданную функцию к каждому элементу по очереди, а затем решает, следует ли сохранить или отбросить элемент в зависимости от того, является ли возвращаемое значение функции Trueили False.

Вот пример (получите шансы в кортеже):

list(filter(lambda x:x%2==1, (1, 2, 4, 5, 6, 9, 10, 15)))  
# result: [1, 5, 9, 15]

Внимание: вы также не можете обрабатывать итераторы. Итераторы иногда лучше, чем последовательности.

цикл 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

так что 4-я итерация сделала указатель переместился на 5-ую ..

вот почему ваш цикл не покрывает 65, так как он переместился в предыдущий индекс.

поэтому вы не должны ссылаться на список в другой переменной, которая все еще ссылается на оригинал, а не на копию.

ite = lis #dont do it will reference instead copy

поэтому сделайте копию списка, используя list[::]

теперь тебе это даст,

[5, 7, 13, 29]

Проблема в том, что вы удалили значение из списка во время итерации, после чего индекс вашего списка свернется.

так что вы можете попробовать понимание вместо этого.

который поддерживает все повторяемые как, список, кортеж, dict, строка и т. д.

Если вы хотите удалить элементы из списка во время итерации, используйте цикл while, чтобы вы могли изменять текущий индекс и индекс конца после каждого удаления.

Пример:

i = 0
length = len(list1)

while i < length:
    if condition:
        list1.remove(list1[i])
        i -= 1
        length -= 1

    i += 1

Остальные ответы верны: обычно плохая идея удалять из списка, который вы перебираете. Обратная итерация позволяет избежать ловушек, но гораздо сложнее следовать коду, который делает это, поэтому обычно вам лучше использовать понимание списка или filter.

Однако есть один случай, когда безопасно удалить элементы из последовательности, которую вы повторяете: если вы удаляете только один элемент во время итерации. Это может быть обеспечено с помощью returnили break. Например:

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

Это часто легче понять, чем понимание списка, когда вы выполняете некоторые операции с побочными эффектами для первого элемента в списке, который удовлетворяет некоторому условию, а затем сразу же удаляете этот элемент из списка.

Я могу придумать три подхода для решения вашей проблемы. В качестве примера я создам случайный список кортежей somelist = [(1,2,3), (4,5,6), (3,6,6), (7,8,9), (15,0,0), (10,11,12)]. Условие, которое я выбираю, таково sum of elements of a tuple = 15. В финальном списке у нас будут только те кортежи, чья сумма не равна 15.

То, что я выбрал, является случайно выбранным примером. Вы можете изменить в список кортежей и условие , что я выбрал.

Метод 1.> Используйте предложенный вами фреймворк (где заполняется код внутри цикла for). Я использую небольшой код delдля удаления кортежа, который удовлетворяет указанному условию. Однако этот метод пропускает кортеж (который удовлетворяет указанному условию), если два последовательно размещенных кортежа удовлетворяют данному условию.

for tup in somelist:
    if ( sum(tup)==15 ): 
        del somelist[somelist.index(tup)]

print somelist
>>> [(1, 2, 3), (3, 6, 6), (7, 8, 9), (10, 11, 12)]

Метод 2.> Создайте новый список, который содержит элементы (кортежи), где данное условие не выполняется (это то же самое, что удаление элементов списка, где выполняется данное условие). Ниже приведен код для этого:

newlist1 = [somelist[tup] for tup in range(len(somelist)) if(sum(somelist[tup])!=15)]

print newlist1
>>>[(1, 2, 3), (7, 8, 9), (10, 11, 12)]

Метод 3.> Найдите индексы, в которых выполняется данное условие, а затем используйте элементы удаления (кортежи), соответствующие этим индексам. Ниже приведен код для этого.

indices = [i for i in range(len(somelist)) if(sum(somelist[i])==15)]
newlist2 = [tup for j, tup in enumerate(somelist) if j not in indices]

print newlist2
>>>[(1, 2, 3), (7, 8, 9), (10, 11, 12)]

Метод 1 и метод 2 быстрее, чем метод 3 . Метод2 и метод3 более эффективны, чем метод1. Я предпочитаю method2 . Для вышеупомянутого примераtime(method1) : time(method2) : time(method3) = 1 : 1 : 1.7

Для всего, что может быть действительно большим, я использую следующее.

import numpy as np

orig_list = np.array([1, 2, 3, 4, 5, 100, 8, 13])

remove_me = [100, 1]

cleaned = np.delete(orig_list, remove_me)
print(cleaned)

Это должно быть значительно быстрее, чем все остальное.

В некоторых ситуациях, когда вы делаете больше, чем просто фильтруете список по одному элементу за раз, вы хотите, чтобы ваша итерация изменялась во время итерации.

Вот пример, где предварительное копирование списка некорректно, обратная итерация невозможна, и понимание списка также не вариант.

""" Sieve of Eratosthenes """

def generate_primes(n):
    """ Generates all primes less than n. """
    primes = list(range(2,n))
    idx = 0
    while idx < len(primes):
        p = primes[idx]
        for multiple in range(p+p, n, p):
            try:
                primes.remove(multiple)
            except ValueError:
                pass #EAFP
        idx += 1
        yield p

Если вы будете использовать новый список позже, вы можете просто установить элемент в None, а затем судить о нем в последующем цикле, как это

for i in li:
    i = None

for elem in li:
    if elem is None:
        continue

Таким образом, вам не нужно копировать список, и это легче понять.

открыть список чисел, и вы хотите удалить все не делятся на 3,

list_number =[i for i in range(100)]

используя list comprehension, это создаст новый список и создаст новое пространство памяти

new_list =[i for i in list_number if i%3!=0]

используя lambda filterфункцию, это создаст результирующий новый список и займет место памяти

new_list = list(filter(lambda x:x%3!=0, list_number))

без использования места в памяти для нового списка и изменения существующего списка

for index, value in enumerate(list_number):
    if list_number[index]%3==0:
        list_number.remove(value)