Supprimer toutes les occurrences d'une valeur dans une liste?

Vous pouvez utiliser une compréhension de liste:

def remove_values_from_list(the_list, val):
   return [value for value in the_list if value != val]

x = [1, 2, 3, 4, 2, 2, 3]
x = remove_values_from_list(x, 2)
print x
# [1, 3, 4, 3]

Vous pouvez utiliser l'affectation de tranche si la liste d'origine doit être modifiée, tout en utilisant une compréhension de liste efficace (ou une expression de générateur).

>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> x[:] = (value for value in x if value != 2)
>>> x
[1, 3, 4, 3]

Répéter la solution du premier message d'une manière plus abstraite:

>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> while 2 in x: x.remove(2)
>>> x
[1, 3, 4, 3]

Voir les solutions simples

Solution 1:

>>> [i for i in x if i != 2]

Cela renverra une liste contenant tous les éléments de x Sans 2

Solution 2:

>>> while 2 in x : x.remove(2)

Toutes les réponses ci-dessus (à L'exception de Martin Andersson) créent une nouvelle liste sans les éléments souhaités, plutôt que de supprimer les éléments de la liste d'origine.

>>> import random, timeit
>>> a = list(range(5)) * 1000
>>> random.shuffle(a)

>>> b = a
>>> print(b is a)
True

>>> b = [x for x in b if x != 0]
>>> print(b is a)
False
>>> b.count(0)
0
>>> a.count(0)
1000

>>> b = a
>>> b = filter(lambda a: a != 2, x)
>>> print(b is a)
False

Cela peut être important si vous avez d'autres références à la liste qui traînent.

Pour modifier la liste en place, utilisez une méthode comme celle-ci

>>> def removeall_inplace(x, l):
...     for _ in xrange(l.count(x)):
...         l.remove(x)
...
>>> removeall_inplace(0, b)
>>> b is a
True
>>> a.count(0)
0

En ce qui concerne la vitesse, les résultats sur mon ordinateur portable sont (tous sur une liste d'entrées 5000 avec des entrées 1000 supprimées)

• compréhension de liste - ~400 $ us
• filtre - ~ 900us
• .supprimer () boucle-50ms

Donc le.supprimer la boucle est environ 100 fois plus lent........ Hmmm, peut-être une approche différente est nécessaire. Le plus rapide que j'ai trouvé utilise la compréhension de la liste, mais remplace ensuite le contenu de la liste d'origine.

>>> def removeall_replace(x, l):
....    t = [y for y in l if y != x]
....    del l[:]
....    l.extend(t)

• removeall_replace () - 450us

Au prix de la lisibilité, je pense que cette version est légèrement plus rapide car elle ne force pas le while à réexaminer la liste, faisant ainsi exactement le même travail que remove doit faire de toute façon:

x = [1, 2, 3, 4, 2, 2, 3]
def remove_values_from_list(the_list, val):
    for i in range(the_list.count(val)):
        the_list.remove(val)

remove_values_from_list(x, 2)

print(x)

, Vous pouvez le faire

while 2 in x:   
    x.remove(2)

Pour supprimer toutes les occurrences en double et en laisser une dans la liste:

test = [1, 1, 2, 3]

newlist = list(set(test))

print newlist

[1, 2, 3]

Voici la fonction que j'ai utilisée pour le projet Euler:

def removeOccurrences(e):
  return list(set(e))

Je crois que c'est probablement plus rapide que tout autre moyen si vous ne vous souciez pas de l'ordre des listes, si vous prenez soin de l'ordre final stockez les index de l'original et recourez à cela.

category_ids.sort()
ones_last_index = category_ids.count('1')
del category_ids[0:ones_last_index]

Approche Numpy et timings contre une liste / tableau avec 1.000.000 éléments:

Horaires:

In [10]: a.shape
Out[10]: (1000000,)

In [13]: len(lst)
Out[13]: 1000000

In [18]: %timeit a[a != 2]
100 loops, best of 3: 2.94 ms per loop

In [19]: %timeit [x for x in lst if x != 2]
10 loops, best of 3: 79.7 ms per loop

Conclusion: numpy est 27 fois plus rapide (sur mon cahier) par rapport à l'approche de compréhension de liste

PS si vous voulez convertir votre liste Python régulière lst en tableau numpy:

arr = np.array(lst)

Configuration:

import numpy as np
a = np.random.randint(0, 1000, 10**6)

In [10]: a.shape
Out[10]: (1000000,)

In [12]: lst = a.tolist()

In [13]: len(lst)
Out[13]: 1000000

Vérifier:

In [14]: a[a != 2].shape
Out[14]: (998949,)

In [15]: len([x for x in lst if x != 2])
Out[15]: 998949

Supprime toutes les occurrences d'une valeur d'une liste Python

lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list():
    for list in lists:
      if(list!=7):
         print(list)
remove_values_from_list()

Résultat: 6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11

Sinon,

lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list(remove):
    for list in lists:
      if(list!=remove):
        print(list)
remove_values_from_list(7)

Résultat: 6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11

Première solution, en utilisant le filtre.
Deuxième solution, en utilisant la compréhension de liste.

#If we want to remove all 2.
ls = [2, 2, 3, 4, 5, 6, 7, 8, 2, 3, 4, 6, 2]

# 1-filter takes two arguments(condition,sequence)
   ls = list(filter(lambda x: x != 2, ls))

# 2-list comprehension
   ls = [x for x in ls if x != 2]

for i in range(a.count(' ')):
    a.remove(' ')

Beaucoup plus simple je crois.

Quel est le problème avec:

Moteur=['1','2','2'] Pour i dans le moteur: Si je != '2': Print(je) Imprimer (moteur)

En utilisant anaconda

Cela modifie-t-il la liste?

>>> x=[1,2,3,4,5,6,7,8]
>>> x
[1, 2, 3, 4, 5, 6, 7, 8]
>>> x = [val for val in x if val not in [2,3,4]]
>>> x
[1, 5, 6, 7, 8]

mylist=list(set(mylist))
mylist.remove(element)

Peut-être pas le plus pythonique mais toujours le plus facile pour moi haha

Si vous n'avez pas intégré filter ou que vous ne voulez pas utiliser d'espace supplémentaire et que vous avez besoin d'une solution linéaire...

def remove_all(A, v):
    k = 0
    n = len(A)
    for i in range(n):
        if A[i] !=  v:
            A[k] = A[i]
            k += 1

    A = A[:k]

À propos de la vitesse!

import time
s_time = time.time()

print 'start'
a = range(100000000)
del a[:]
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 3.25

s_time = time.time()
print 'start'
a = range(100000000)
a = []
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 2.11

p=[2,3,4,4,4]
p.clear()
print(p)
[]

Uniquement avec Python 3