HOWTO · Python

Rimuovi tutte le occorrenze di un elemento da una lista in Python

In questo articolo vedremo come rimuovere tutte le occorrenze di un elemento da un List in Python.

In questa pagina

Una lista Python può contenere lo stesso valore molte volte, e ogni occorrenza è un elemento distinto con la propria posizione nella lista. remove() elimina solo la prima corrispondenza, quindi eliminare ogni occorrenza di un valore richiede un approccio diverso. L’opzione più diretta è una list comprehension, che costruisce una nuova lista che mantiene solo gli elementi desiderati; filter() offre un’alternativa basata su un predicato, mentre un ciclo attorno a remove() funziona quando la lista originale deve essere modificata sul posto.

Rimuovere tutti gli elementi corrispondenti con una list comprehension

Una list comprehension mantiene ogni elemento che soddisfa una condizione e raccoglie gli elementi rimasti in una nuova lista. Esegui questo esempio:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

numbers = [1, 2, 3, 4, 2, 5, 2]
target = 2
filtered = [x for x in numbers if x != target]
print(filtered)
print(numbers)
[1, 3, 4, 5]
[1, 2, 3, 4, 2, 5, 2]

La condizione x != target mantiene ogni valore diverso da 2, quindi tutte e tre le copie scompaiono da filtered mentre numbers contiene ancora i dati originali. Per sostituire la variabile originale invece di mantenere due liste, riassegna il risultato alla stessa variabile: numbers = [x for x in numbers if x != target]. Gli altri nomi associati al vecchio oggetto lista vedono ancora gli elementi non filtrati, il che di solito è ciò che desideri quando è il chiamante a possedere la lista.

Se il valore non compare mai nella lista, la comprensione viene comunque eseguita e produce una lista che contiene tutti gli elementi originali:

numbers = [1, 3, 4, 5]
target = 2
filtered = [x for x in numbers if x != target]
print(filtered)
[1, 3, 4, 5]

Questo rende la comprensione sicura da eseguire senza controllare prima l’appartenenza.

Rimuovere tutti gli elementi corrispondenti con filter()

La funzione filter() applica un predicato a ogni elemento e restituisce solo gli elementi per cui il predicato è vero. In Python 3 restituisce un iteratore, non una lista, quindi passa il suo risultato a list() quando ti serve una lista riutilizzabile. Il predicato è spesso una lambda, una piccola funzione anonima, che confronta ogni elemento con il valore da rimuovere:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

numbers = [1, 2, 3, 4, 2, 5, 2]
target = 2
filtered = list(filter(lambda x: x != target, numbers))
print(filtered)
[1, 3, 4, 5]

Come la comprensione, filter() costruisce una nuova sequenza e lascia numbers invariata; un valore che non compare mai produce una lista uguale all’input. Scegli filter() quando un predicato esiste già o deve essere riutilizzato, e preferisci la comprensione quando la condizione è un controllo occasionale come x != target.

Rimuovere tutti gli elementi corrispondenti con remove()

remove() è un metodo delle liste che elimina solo il primo elemento uguale al suo argomento e modifica la lista sul posto. Una singola chiamata non può mai eliminare i duplicati, quindi ripetila finché il valore è ancora presente:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

numbers = [1, 2, 3, 4, 2, 5, 2, 6]
target = 2
while target in numbers:
    numbers.remove(target)
print(numbers)
[1, 3, 4, 5, 6]

Ogni iterazione scansiona la lista una volta per target in numbers e di nuovo dentro remove() per individuare la prima corrispondenza, quindi il ciclo esegue due ricerche per ogni elemento eliminato. La condizione while è anche la salvaguardia: quando non resta nessuna corrispondenza, il test è falso e il ciclo si ferma. Chiamare remove() con un valore che non è nella lista solleva ValueError, quindi è il controllo di appartenenza — o una guardia equivalente come numbers.count(target) — a rendere sicura la rimozione ripetuta. Quando il valore non è mai stato nella lista, il corpo del ciclo non viene mai eseguito e la lista conserva tutti i suoi elementi.

Scegliere l’approccio giusto

  • Serve una copia filtrata: usa una list comprehension. Fa un solo passaggio sulla lista, dichiara la condizione in linea e lascia l’originale intatta.
  • Serve riutilizzare un predicato: usa filter() con lambda o una funzione con nome. Il risultato è un iteratore lazy, quindi ricorda la chiamata a list() quando ti serve una lista concreta.
  • Serve una modifica sul posto: usa il ciclo while ... remove() quando altro codice deve osservare il cambiamento sullo stesso oggetto lista. Poiché ogni elemento eliminato costa una scansione di appartenenza più una scansione di rimozione, fa più lavoro della comprensione a passaggio singolo su liste lunghe con molte corrispondenze.

Per le dimensioni tipiche delle liste, la comprensione è la soluzione più chiara e veloce da scrivere; le scansioni extra del ciclo diventano percettibili solo quando le liste diventano grandi o le rimozioni vengono eseguite frequentemente.