Comment supprimer des éléments d'une liste tout en itérant?

les réponses suggérant l'interprétation des listes sont presque correctes, sauf qu'elles construisent une liste entièrement nouvelle et lui donnent le même nom que l'ancienne liste, elles ne modifient pas l'ancienne liste en place. C'est différent de ce que vous feriez par suppression sélective, comme dans la suggestion de @Lennart -- c'est plus rapide, mais si votre liste est consultée via plusieurs références le fait que vous êtes juste reseating une des références et de ne pas modifier l'objet de la liste elle-même peut conduire à, des insectes désastreux.

heureusement , il est extrêmement facile d'obtenir à la fois la vitesse de compréhension des listes et la sémantique requise de modification en place -- code juste:

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

notez la différence subtile avec d'autres réponses: celle-ci N'affecte pas à un nom de barre - elle affecte à une tranche de liste qui se trouve être la liste entière, remplaçant ainsi la liste contents 151980920" dans le même objet de liste Python , plutôt que de simplement reseater une référence (de l'objet liste précédente à l'objet nouvelle liste) comme les autres réponses.

vous devez prendre une copie de la liste et itérer sur elle en premier, ou l'itération échouera avec ce qui peut être des résultats inattendus.

Par exemple (dépend du type de liste):

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

un exemple:

>>> 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 xrange(len(somelist) - 1, -1, -1):
    if some_condition(somelist, i):
        del somelist[i]

vous devez faire marche arrière sinon c'est un peu comme scier la branche d'arbre sur laquelle vous êtes assis: -)

votre meilleure approche pour un tel exemple serait un liste de compréhension

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

dans les cas où vous faites quelque chose de plus complexe que d'appeler une fonction determine , je préfère construire une nouvelle liste et simplement l'ajouter au fur et à mesure. Par exemple

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

copier la liste en utilisant remove pourrait rendre votre code un peu plus propre, comme décrit dans l'une des réponses ci-dessous. Vous ne devrait certainement pas faire cela pour des listes extrêmement grandes, puisque cela implique d'abord la copie de la liste entière, et aussi effectuer une opération O(n) remove pour chaque élément retiré, ce qui rend cet algorithme O(n^2) .

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

pour ceux qui aiment la programmation fonctionnelle:

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

ou

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

the tutorial officiel de Python 2 4.2. "pour les Déclarations" dit :

Si vous devez modifier la séquence de parcourir tout l'intérieur de la boucle (par exemple, pour dupliquer des éléments sélectionnés), il est recommandé que vous faites d'abord une copie. Itérer sur une séquence ne fait pas implicitement une copie. La notation de la tranche rend cela particulièrement commode:

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

qui est ce qui a été suggéré à: https://stackoverflow.com/a/1207427/895245

la documentation Python 2 7.3. "La déclaration" donne le même conseil :

Note: Il y a une subtilité lorsque la séquence est modifiée par la boucle (cela ne peut se produire que pour les séquences mutables, c'est-à-dire les listes). Un compteur interne est utilisé pour garder la trace de l'élément est utilisé, et il est incrémenté à chaque itération. Lorsque ce compteur atteint la longueur de la séquence de la boucle termine. Cela signifie que si la suite supprime le courant (ou la précédente) élément de la séquence, le prochain article sera ignorée (puisqu'il récupère l'index de l'élément courant qui a déjà été traité). De même, si la suite insère un élément dans la séquence avant l'élément courant, l'élément courant sera traité de nouveau la prochaine fois par la boucle. Cela peut conduire aux bogues désagréables qui peuvent être évités en faisant une copie temporaire en utilisant une tranche de la séquence entière, par exemple,

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

Python pourrait-il faire mieux?

il semble que cette API Python puisse être améliorée. Comparez-le, par exemple, avec son homologue Java ListIterator , ce qui rend très clair que vous ne pouvez pas modifier une liste étant itérée sauf avec l'itérateur et vous donne des moyens efficaces de le faire sans copier la liste. Allez, Python!

il pourrait être intelligent de créer une nouvelle liste si l'élément liste actuelle répond aux critères souhaités.

:

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

et pour éviter d'avoir à re-coder l'ensemble du projet avec le nouveau nom de listes:

originalList[:] = newList

note, de la documentation Python:

bien reçu.copie (x) Retourner une copie peu profonde de X.

bien reçu.propriétédeepcopy(x) Retour une copie en profondeur of X.

j'avais besoin de faire cela avec une liste énorme, et reproduire la liste semblait coûteux, d'autant plus que dans mon cas le nombre de suppressions serait peu élevé par rapport aux articles qui restent. J'ai pris cette approche de bas niveau.

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

ce que je ne sais pas, c'est l'efficacité de quelques suppressions par rapport à la copie d'une grande liste. Veuillez commenter si vous avez des idées.

cette réponse a été écrite à l'origine en réponse à une question qui a depuis été marquée comme dupliquée: suppression des coordonnées de la liste sur python

il y a deux problèmes dans votre code:

1) en utilisant remove (), vous tentez de supprimer des entiers alors que vous devez supprimer un tuple.

2) la boucle for sautera des éléments de votre liste.

que se passe-t-il lorsque nous exécutons votre code:

>>> 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)

le premier problème est que vous passez à la fois 'a' et 'b' Pour remove(), mais remove() n'accepte qu'un seul argument. Alors comment faire pour que remove() fonctionne correctement avec votre liste? Nous devons trouver ce qu'est chaque élément de votre liste. Dans ce cas, chacun est un n-uplet. Pour voir ceci, accédons à un élément de la liste (l'indexation commence à 0):

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

Aha! Chaque élément de L1 est en fait un n-uplet. Donc c'est ce que nous devons passer pour supprimer(). Les Tuples en python sont très faciles, ils sont simplement faits en enfermant des valeurs entre parenthèses. "a, b" n'est pas un tuple, mais "(a, b)" est un n-uplet. Nous modifions donc votre code et l'exécutons à nouveau:

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

ce code s'exécute sans aucune erreur, mais regardons la liste qu'il affiche:

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

Pourquoi est (1,-2) toujours dans votre liste? Il s'avère modifier la liste en utilisant une boucle pour itérer sur c'est une très mauvaise idée sans soins particuliers. La raison pour laquelle (1, -2) reste dans la liste est que les emplacements de chaque élément dans la liste ont changé entre les itérations de la boucle for. Regardons ce qui se passe si nous donnons au code ci-dessus une liste plus longue:

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

comme vous pouvez déduire de ce résultat, chaque fois que l'énoncé conditionnel évalue à true et un élément de liste est supprimé, la prochaine itération de la boucle sautera l'évaluation de la prochaine élément dans la liste parce que ses valeurs sont situés à différents indices.

la solution la plus intuitive est de copier la liste, puis de l'itérer sur la liste originale et de modifier seulement la copie. Vous pouvez essayer de le faire comme ceci:

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)

cependant, la sortie sera identique à avant:

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

c'est parce que lorsque nous avons créé L2, python n'a pas réellement créé un nouvel objet. Au lieu de cela, il a simplement fait référence à L2 au même objet que L1. Nous pouvons le vérifier avec " est " qui est différent de simplement "égal" (==).

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

nous pouvons faire une copie conforme en utilisant la copie.copie.)( Alors tout fonctionne comme prévu:

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

enfin, il y a une solution plus propre que d'avoir à faire une copie entièrement nouvelle de L1. La fonction inverse ():

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

malheureusement, je ne peux pas décrire de façon adéquate comment fonctionne reverse (). Il renvoie un objet' listreverseiterator ' lorsqu'une liste lui est passée. Pour des raisons pratiques, vous pouvez penser qu'il crée une copie inversée de son argument. C'est la solution que je recommande.

Si vous voulez faire autre chose pendant l'itération, il peut être agréable d'obtenir à la fois l'indice (qui vous garantit d'être en mesure de référence, par exemple, si vous avez une liste des dicts) et la liste réelle de l'élément de contenu.

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 vous donne accès à l'élément et l'index à la fois. reversed est ainsi que les indices que vous allez supprimer ultérieurement ne changent pas sur vous.

vous pourriez vouloir utiliser filter() disponible comme le intégré.

pour plus de détails voir ici

vous pouvez essayer pour-looping à l'envers donc pour some_list vous ferez quelque chose comme:

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)

de cette façon l'index est aligné et ne souffre pas des mises à jour de liste (indépendamment du fait que vous pop cur element ou non).

une solution possible, utile si vous voulez non seulement supprimer certaines choses, mais aussi faire quelque chose avec tous les éléments dans une seule boucle:

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

j'avais besoin de faire quelque chose de similaire et dans mon cas le problème était la mémoire - j'avais besoin de fusionner plusieurs objets dataset dans une liste, après avoir fait quelque chose avec eux, comme un nouvel objet, et avait besoin de se débarrasser de chaque entrée je fusionnais pour éviter de les dupliquer tous et l'explosion de la mémoire. Dans mon cas avoir les objets dans un dictionnaire au lieu d'une liste a fonctionné très bien:

""

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:

j'ai écrit une bibliothèque qui vous permet de faire ceci:

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'

il est préférable d'utiliser une autre méthode si possible qui ne nécessite pas de modifier votre itérable tout en itérant sur elle, mais pour certains algorithmes, il pourrait ne pas être si simple. Et donc si vous êtes sûr que vous voulez vraiment le modèle de code décrit dans la question originale, c'est possible.

devrait fonctionner sur toutes les séquences mutables pas seulement des listes.

réponse:

modifier: le dernier exemple de code dans cette réponse donne un cas d'utilisation pour pourquoi vous pourriez parfois vouloir modifier une liste en place plutôt que d'utiliser une compréhension de liste. La première partie des réponses Sert de tutoriel de comment un tableau peut être modifié en place.

la solution suit de cette réponse (pour une question connexe) de senderle. Ce qui explique comment l'index du tableau est mis à jour tout en itérant à travers une liste qui a été modifiée. La solution ci-dessous est conçue pour suivre correctement l'index du tableau même si la liste est modifiée.

Télécharger fluidIter.py à partir de ici https://github.com/alanbacon/FluidIterator , c'est juste un seul fichier, donc pas besoin d'installer git. Il n'y a pas de installez donc vous devez vous assurer que le fichier est dans le chemin python vous-même. Le code a été écrit pour python 3 et n'a pas été testé sur 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))

il en résultera la sortie suivante:

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]

ci-dessus nous avons utilisé la méthode pop sur l'objet de la liste des fluides. D'autres méthodes itérables communes sont également mises en œuvre, telles que: del fluidL[i] , .remove , .insert , .append , .extend . Le la liste peut également être modifiée en utilisant des tranches (les méthodes sort et reverse ne sont pas appliquées).

la seule condition est que vous devez seulement modifier la liste en place, si à un moment quelconque fluidL ou l ont été réassignés à un objet de liste différent le code ne fonctionnerait pas. L'objet original fluidL serait toujours utilisé par la boucle for mais serait hors de portée pour nous de modifier.

c'est à dire

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

si nous voulons accéder à la valeur index courante de la liste, nous ne pouvons pas utiliser enumerate, car cela ne compte que le nombre de fois que la boucle for a été exécutée. Au lieu de cela, nous utiliserons l'objet iterator directement.

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))

il en résultera ce qui suit:

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]

la classe FluidIterable ne fournit qu'un emballage pour l'objet original de la liste. L'objet original peut être consulté comme une propriété de l'objet fluide comme so:

originalList = fluidArr.fixedIterable

D'autres exemples / essais peuvent être trouvés dans la section if __name__ is "__main__": au bas de fluidIter.py . Elles valent la peine d'être examinées car elles expliquent ce qui se passe dans diverses situations. Par exemple: remplacer une grande partie de la liste par une tranche. Ou en utilisant (et en modifiant) le même itérable dans les boucles imbriquées.

comme je l'ai déclaré pour commencer: il s'agit d'une solution compliquée qui va nuire à la lisibilité de votre code et rendre plus difficile à débogage. Par conséquent, d'autres solutions telles que l'interprétation de la liste mentionnée dans la réponse "1519530920 de David Raznick devraient être considérées en premier. Ceci étant dit, j'ai trouvé des moments où cette classe m'a été utile et a été plus facile à utiliser que de garder la trace des indices d'éléments qui doivent être supprimés.

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

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]

les autres réponses sont correctes.c'est habituellement une mauvaise idée de supprimer d'une liste que vous itérez. L'itération inverse évite les pièges, mais il est beaucoup plus difficile de suivre le code qui fait cela, donc habituellement vous êtes mieux à l'aide d'une liste de compréhension ou filter .

il y a, cependant, un cas où il est sûr de supprimer des éléments d'une séquence que vous itérez: si vous supprimez seulement un élément pendant que vous itérez. Cela peut être assuré en utilisant un return ou un break . Par exemple:

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

c'est souvent plus facile à comprendre qu'une compréhension de liste quand vous faites certaines opérations avec des effets secondaires sur le premier élément dans une liste qui répond à une certaine condition et puis enlever cet élément de la liste immédiatement après.

Pour tout ce qui a le potentiel pour être vraiment grand, j'utilise la suite.

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)

qui devrait être nettement plus rapide que toute autre chose.

dans certaines situations, où vous faites plus que simplement filtrer une liste un élément à la fois, vous voulez que votre itération change tout en itérant.

voici un exemple où Copier la liste à l'avance est incorrect, l'itération inverse est impossible et une compréhension de la liste n'est pas non plus une option.

""" 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

tout de suite vous voulez créer une copie de la liste pour que vous puissiez l'avoir comme référence lorsque vous itérez et supprimez des tuples dans cette liste qui répondent à un certain critère.

alors cela dépend du type de liste que vous voulez pour la sortie que ce soit une liste des tuples supprimés ou une liste des tuples qui ne sont pas supprimés.

comme David l'a souligné, je recommande la compréhension de liste pour garder les éléments que vous ne voulez pas enlever.

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