Più o meno ho bisogno di scrivere un programma che controlli se una lista ha dei duplicati e se lo fa li rimuove e restituisce una nuova lista con gli elementi che non sono stati duplicati/rimossi. Questo è quello che ho ma ad essere onesti non so cosa fare.
def remove_duplicates():
t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
for t in t2:
t.append(t.remove())
return t
L'approccio comune per ottenere una collezione unica di oggetti è usare un set
. Gli insiemi sono collezioni non ordinate di oggetti distinti. Per creare un insieme da qualsiasi iterabile, potete semplicemente passarlo alla funzione built-in set()
. Se in seguito avrete nuovamente bisogno di una vera lista, potrete analogamente passare l'insieme alla funzione list()
.
Il seguente esempio dovrebbe coprire qualsiasi cosa stiate cercando di fare:
>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]
Come potete vedere dal risultato dell'esempio, l'ordine originale non viene mantenuto. Come detto sopra, gli insiemi stessi sono collezioni non ordinate, quindi l'ordine viene perso. Quando si riconverte un insieme in una lista, viene creato un ordine arbitrario.
Se l'ordine è importante per te, allora dovrai usare un meccanismo diverso. Una soluzione molto comune per questo è affidarsi a OrderedDict
per mantenere l'ordine delle chiavi durante l'inserimento:
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]
A partire da Python 3.7, il dizionario integrato è garantito per mantenere anche l'ordine di inserimento, quindi potete anche usarlo direttamente se siete su Python 3.7 o successivo (o CPython 3.6):
>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]
Notate che questo ha l'overhead di creare prima un dizionario e poi di creare una lista da esso. Se non hai effettivamente bisogno di preservare l'ordine, è meglio usare un set. Controlla questa domanda per maggiori dettagli e modi alternativi per preservare l'ordine quando si rimuovono i duplicati.
Infine si noti che sia il set
che le soluzioni OrderedDict
/dict
richiedono che i tuoi elementi siano hashabili. Questo di solito significa che devono essere immutabili. Se avete a che fare con elementi che non sono hashabili (ad esempio oggetti lista), allora dovrete usare un approccio lento in cui dovrete fondamentalmente confrontare ogni elemento con ogni altro elemento in un ciclo annidato.
È un one-liner: list(set(source_list))
farà il trucco.
Un set
è qualcosa che non può avere duplicati.
Aggiornamento: un approccio "order-preserving" è di due righe:
from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()
Qui usiamo il fatto che OrderedDict
ricorda l'ordine di inserimento delle chiavi, e non lo cambia quando viene aggiornato un valore in una particolare chiave. Inseriamo True
come valore, ma potremmo inserire qualsiasi cosa, i valori semplicemente non vengono usati. (Anche set
funziona molto come un dict
con valori ignorati).