Esiste un modo semplice per eliminare un elemento elenco in base al valore?

a = [1, 2, 3, 4]
b = a.index(6)

del a[b]
print(a)

Quanto sopra mostra il seguente errore:

Traceback (most recent call last):
  File "D:\zjm_code\a.py", line 6, in <module>
    b = a.index(6)
ValueError: list.index(x): x not in list

Quindi devo fare questo:

a = [1, 2, 3, 4]

try:
    b = a.index(6)
    del a[b]
except:
    pass

print(a)

Ma non esiste un modo più semplice per farlo?

Per rimuovere la prima occorrenza di un elemento in un elenco, utilizzare semplicemente list.remove:

>>> a = ['a', 'b', 'c', 'd']
>>> a.remove('b')
>>> print(a)
['a', 'c', 'd']

Ricorda che non rimuove tutte le occorrenze del tuo elemento. Usa una comprensione dell'elenco per quello.

>>> a = [10, 20, 30, 40, 20, 30, 40, 20, 70, 20]
>>> a = [x for x in a if x != 20]
>>> print(a)
[10, 30, 40, 30, 40, 70]

Di solito Python genererà un'eccezione se gli dici di fare qualcosa che non può, quindi dovrai farlo:

if c in a:
    a.remove(c)

o:

try:
    a.remove(c)
except ValueError:
    pass

Un'eccezione non è necessariamente una cosa negativa purché sia ​​quella che ti aspetti e gestisci correttamente.

Tu puoi fare

a=[1,2,3,4]
if 6 in a:
    a.remove(6)

ma sopra è necessario cercare 6 nell'elenco 2 volte, quindi prova tranne che sarebbe più veloce

try:
    a.remove(6)
except:
    pass

Prendere in considerazione:

a = [1,2,2,3,4,5]

Per eliminare tutte le occorrenze, è possibile utilizzare la funzione filtro in Python. Ad esempio, sembrerebbe:

a = list(filter(lambda x: x!= 2, a))

Quindi, manterrebbe tutti gli elementi di a != 2.

Per estrarre solo uno degli oggetti usa

a.remove(2)

Ecco come farlo sul posto (senza comprensione dell'elenco):

def remove_all(seq, value):
    pos = 0
    for item in seq:
        if item != value:
           seq[pos] = item
           pos += 1
    del seq[pos:]

Se sai quale valore eliminare, ecco un modo semplice (il più semplice possibile, comunque):

a = [0, 1, 1, 0, 1, 2, 1, 3, 1, 4]
while a.count(1) > 0:
    a.remove(1)

Otterrai [0, 0, 2, 3, 4]

Un'altra possibilità è quella di utilizzare un set anziché un elenco, se un set è applicabile nella propria applicazione.

IE se i tuoi dati non sono ordinati e non hanno duplicati, quindi

my_set=set([3,4,2])
my_set.discard(1)

è privo di errori.

Spesso un elenco è solo un comodo contenitore per gli articoli che sono effettivamente non ordinati. Ci sono domande che chiedono come rimuovere tutte le occorrenze di un elemento da un elenco. Se in primo luogo non vuoi duplicati, ancora una volta è utile un set.

my_set.add(3)

non cambia my_set dall'alto.

Come affermato da numerose altre risposte, list.remove()funzionerà, ma lancia un ValueErrorse l'elemento non era nell'elenco. Con python 3.4+, esiste un approccio interessante alla gestione di questo, usando il gestore di soppressione :

from contextlib import suppress
with suppress(ValueError):
    a.remove('b')

Trovare un valore in un elenco e quindi eliminare quell'indice (se esiste) è più facile semplicemente usando il metodo di rimozione dell'elenco:

>>> a = [1, 2, 3, 4]
>>> try:
...   a.remove(6)
... except ValueError:
...   pass
... 
>>> print a
[1, 2, 3, 4]
>>> try:
...   a.remove(3)
... except ValueError:
...   pass
... 
>>> print a
[1, 2, 4]

Se lo fai spesso, puoi avvolgerlo in una funzione:

def remove_if_exists(L, value):
  try:
    L.remove(value)
  except ValueError:
    pass

Questo esempio è veloce e cancellerà tutte le istanze di un valore dall'elenco:

a = [1,2,3,1,2,3,4]
while True:
    try:
        a.remove(3)
    except:
        break
print a
>>> [1, 2, 1, 2, 4]

In una riga:

a.remove('b') if 'b' in a else None

a volte è utile.

Ancora più semplice:

if 'b' in a: a.remove('b')

Se i tuoi elementi sono distinti, allora farà una semplice differenza di serie.

c = [1,2,3,4,'x',8,6,7,'x',9,'x']
z = list(set(c) - set(['x']))
print z
[1, 2, 3, 4, 6, 7, 8, 9]

Possiamo anche usare .pop:

>>> lst = [23,34,54,45]
>>> remove_element = 23
>>> if remove_element in lst:
...     lst.pop(lst.index(remove_element))
... 
23
>>> lst
[34, 54, 45]
>>> 

Sovrascrivi l'elenco indicizzando tutto tranne gli elementi che desideri rimuovere

>>> s = [5,4,3,2,1]
>>> s[0:2] + s[3:]
[5, 4, 2, 1]

Con un ciclo for e una condizione:

def cleaner(seq, value):    
    temp = []                      
    for number in seq:
        if number != value:
            temp.append(number)
    return temp

E se vuoi rimuoverne alcuni, ma non tutti:

def cleaner(seq, value, occ):
    temp = []
    for number in seq:
        if number == value and occ:
            occ -= 1
            continue
        else:
            temp.append(number)
    return temp

 list1=[1,2,3,3,4,5,6,1,3,4,5]
 n=int(input('enter  number'))
 while n in list1:
    list1.remove(n)
 print(list1)

Ad esempio, vogliamo rimuovere tutti gli 1 da x. Ecco come lo farei:

x = [1, 2, 3, 1, 2, 3]

Ora, questo è un uso pratico del mio metodo:

def Function(List, Unwanted):
    [List.remove(Unwanted) for Item in range(List.count(Unwanted))]
    return List
x = Function(x, 1)
print(x)

E questo è il mio metodo in una sola riga:

[x.remove(1) for Item in range(x.count(1))]
print(x)

Entrambi producono questo come output:

[2, 3, 2, 3, 2, 3]

Spero che sia di aiuto. PS, tieni presente che questo è stato scritto nella versione 3.6.2, quindi potrebbe essere necessario modificarlo per le versioni precedenti.

Forse le tue soluzioni funzionano con ints, ma non funziona con me con dizionari.

In una mano, remove () non ha funzionato per me. Ma forse funziona con i tipi di base. Immagino che il codice seguente sia anche il modo di rimuovere elementi dall'elenco degli oggetti.

D'altra parte, 'del' non ha funzionato correttamente neanche. Nel mio caso, usando python 3.6: quando provo a cancellare un elemento da una lista in un comando 'for' con il comando 'del', python cambia l'indice nel processo e bucle si ferma prematuramente prima del tempo. Funziona solo se elimini elemento per elemento in ordine inverso . In questo modo non cambi l'indice dell'array degli elementi in sospeso quando lo attraversi

Quindi, ho usato:

c = len(list)-1
for element in (reversed(list)):
    if condition(element):
        del list[c]
    c -= 1
print(list)

dove 'list' è come [{'key1': value1 '}, {' key2 ': value2}, {' key3 ': value3}, ...]

Inoltre puoi fare più pythonic usando enumerate:

for i, element in enumerate(reversed(list)):
    if condition(element):
        del list[(i+1)*-1]
print(list)

arr = [1, 1, 3, 4, 5, 2, 4, 3]

# to remove first occurence of that element, suppose 3 in this example
arr.remove(3)

# to remove all occurences of that element, again suppose 3
# use something called list comprehension
new_arr = [element for element in arr if element!=3]

# if you want to delete a position use "pop" function, suppose 
# position 4 
# the pop function also returns a value
removed_element = arr.pop(4)

# u can also use "del" to delete a position
del arr[4]

Ciò rimuove tutte le istanze di "-v"dall'array sys.argve non si lamenta se non sono state trovate istanze:

while "-v" in sys.argv:
    sys.argv.remove('-v')

Puoi vedere il codice in azione, in un file chiamato speechToText.py:

$ python speechToText.py -v
['speechToText.py']

$ python speechToText.py -x
['speechToText.py', '-x']

$ python speechToText.py -v -v
['speechToText.py']

$ python speechToText.py -v -v -x
['speechToText.py', '-x']

questa è la mia risposta, basta usare while e for

def remove_all(data, value):
    i = j = 0
    while j < len(data):
        if data[j] == value:
            j += 1
            continue
        data[i] = data[j]
        i += 1
        j += 1
    for x in range(j - i):
        data.pop()