Почему это для цикла кажется сломать после утверждения if? [Дубликат]

Возможно, вы захотите использовать filter() в качестве встроенного.

Подробнее проверьте здесь

Официальный учебник Python 2 4.2. «for Statementments» говорит:

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

>>> 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']

, что и было предложено в: https://stackoverflow.com/a/1207427/895245

Документация Python 2 7.3. «Инструкция for» дает тот же совет:

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

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

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

Кажется, что этот конкретный API Python может быть улучшен. Сравните его, например, со своим Java-партнером ListIterator , что делает его совершенно ясным, что вы не можете изменить список, который выполняется итерацией, за исключением самого итератора, и дает вам эффективные способы сделать это без копирования списка , Давай, Питон!

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, это всего лишь один файл, поэтому нет необходимо установить git. Нет инсталлятора, поэтому вам нужно убедиться, что файл находится на пути 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 метод на объекте списка текучей среды. Также применяются другие обычные итерационные методы, такие как del fluidL[i], .remove, .insert, .append, .extend. Список также может быть изменен с использованием срезов (методы sort и reverse не реализованы).

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

ie

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 просто предоставляет оболочку для исходного объекта списка. К исходному объекту можно обращаться как к свойству жидкого объекта, например:

originalList = fluidArr.fixedIterable

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

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

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

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

ie

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]

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

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)

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

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

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

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