Questo articolo si concentra su una delle operazioni per ottenere un elenco univoco da un elenco che contiene un possibile duplicato. La rimozione dei duplicati dall'operazione di elenco ha un gran numero di applicazioni e quindi è utile averne la conoscenza Pitone.
tutorial su pyspark
Modi per rimuovere i duplicati dall'elenco:
Di seguito sono riportati i metodi che tratteremo in questo articolo:
- Utilizzando metodo set()
- Utilizzando comprensione delle liste
- Utilizzando la comprensione delle liste con enumerare()
- Utilizzando collezioni.OrderedDict.fromkeys()
- Usare dentro, non dentro operatori
- Utilizzando comprensione delle liste e il metodo Array.index()
- Utilizzando Metodo Contatore()
- Utilizzando Metodo unico Numpy
- Usare un Panda DataFrame
Rimuovi i duplicati dall'elenco utilizzando il metodo set()
Questo è il modo più popolare con cui i duplicati vengono rimossi dall'elenco metodo set() . Ma lo svantaggio principale e notevole di questo approccio è che in questo particolare metodo si perde l'ordinamento degli elementi.
Python3
# initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '> >+> str>(test_list))> # using set() to remove duplicated from list> test_list>=> list>(>set>(test_list))> # printing list after removal> # distorted ordering> print> (>'The list after removing duplicates : '> >+> str>(test_list))> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 3, 5, 6]>
Complessità temporale: SU)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando la comprensione dell'elenco
Questo metodo funziona in modo simile al metodo sopra, ma questa è solo una abbreviazione di un metodo più lungo eseguito con l'aiuto di comprensione delle liste. ordine
Python3
# initializing list> test_list>=> [>1>,>3>,>5>,>6>,>3>,>5>,>6>,>1>]> print>(>'The original list is : '> >+> str>(test_list))> # using list comprehension to remove duplicated from list> res>=> []> [res.append(x)>for> x>in> test_list>if> x>not> in> res]> # printing list after removal> print> (>'The list after removing duplicates : '> >+> str>(res))> |
>
>Produzione
The original list is : [1, 3, 5, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 3, 5, 6]>
Complessità temporale: SU)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando la comprensione dell'elenco con enumerate()
IL comprensione delle liste accoppiato con enumerare la funzione può anche raggiungere questo compito. Fondamentalmente cerca elementi già verificati e salta l'aggiunta. Conserva l'ordine dell'elenco.
Python3
# initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '> >+> str>(test_list))> # using list comprehension + enumerate() to remove duplicated from list> res>=> [i>for> n, i>in> enumerate>(test_list)>if> i>not> in> test_list[:n]]> # printing list after removal> print> (>'The list after removing duplicates : '> >+> str>(res))> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 5, 3, 6]>
Complessità temporale: O(n^2)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco in Python utilizzandocollections.OrderedDict.fromkeys()
Questo è il metodo più veloce per raggiungere un compito particolare. Per prima cosa rimuove i duplicati e restituisce un dizionario che deve essere convertito in un elenco. Funziona bene anche nel caso delle stringhe.
Python3
# using collections.OrderedDict.fromkeys()> from> collections>import> OrderedDict> # initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '> >+> str>(test_list))> # using collections.OrderedDict.fromkeys() to remove duplicated from list> res>=> list>(OrderedDict.fromkeys(test_list))> # printing list after removal> print> (>'The list after removing duplicates : '> >+> str>(res))> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 5, 3, 6]>
Complessità temporale: SU)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando gli operatori in, non in
In questo, iteriamo attraverso l'elenco e manteniamo con esso un elenco corrispondente che contiene l'elemento dell'elenco di input e prima di aggiungere il nuovo elemento all'elenco corrispondente controlliamo se l'elemento esiste già o meno nell'elenco corrispondente e in questo modo possiamo rimuovere il duplicato dell'elenco di input.
Python3
ciclo del programma Java
# initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print>(>'The original list is : '> +> str>(test_list))> res>=> []> for> i>in> test_list:> >if> i>not> in> res:> >res.append(i)> # printing list after removal> print>(>'The list after removing duplicates : '> +> str>(res))> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 5, 3, 6]>
Complessità temporale: O(n^2)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando comprensione delle liste e metodo Array.index()
In questo metodo, utilizziamo la comprensione delle liste per scorrere l'elenco e l'indicizzazione dell'array per ottenere l'elemento da un array. Aggiungiamo gli elementi all'array solo se il primo indice di un elemento nell'array corrisponde all'indice corrente dell'elemento oppure trascura l'elemento.
Pitone
# initializing list> arr>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '>+> str>(arr))> # using list comprehension + arr.index()> res>=> [arr[i]>for> i>in> range>(>len>(arr))>if> i>=>=> arr.index(arr[i]) ]> # printing list after removal of duplicate> print>(>'The list after removing duplicates :'> >,res)> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] ('The list after removing duplicates :', [1, 5, 3, 6])> Complessità temporale: O(n^2)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando il file O Metodo Contatore()
In questo metodo utilizziamo il file Metodo Contatore() per creare un dizionario da un dato array. Ora recupera tutte le chiavi usando chiavi() metodo che fornisce solo valori univoci dall'elenco precedente.
Python3
powershell inferiore o uguale a
from> collections>import> Counter> # initializing list> arr>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '>+> str>(arr))> # using Counter() + keys() to remove duplicated from list> temp>=> Counter(arr)> res>=> [>*>temp]> # printing list after removal of duplicate> print>(>'The list after removing duplicates :'> >,res)> |
>
>Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1, 5, 3, 6]>
Complessità temporale: SU)
Complessità spaziale: SU)
Rimuovi i duplicati dall'elenco utilizzando il metodo univoco Numpy
Questo metodo viene utilizzato quando l'elenco contiene elementi dello stesso tipo e viene utilizzato per rimuovere i duplicati dall'elenco. Innanzitutto converte l'elenco in un file array numpy e quindi utilizza il metodo numpy unique() per rimuovere tutti gli elementi duplicati dall'elenco.
Nota: installare il modulo numpy utilizzando il comando pip install numpy duplicare
Python3
# initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print> (>'The original list is : '> >+> str>(test_list))> > # using numpy> import> numpy as np> > # removing duplicated from list> res>=> np.unique(test_list)> > # printing list after removal> print> (>'The list after removing duplicates : '> >+> str>(res))> |
>
>
Produzione
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1 3 5 6]>
Complessità temporale: SU)
Complessità spaziale: SU)
Utilizzo del frame dati Panda
IL pandas.DataFrame.drop_duplicates() Il metodo può essere utilizzato anche per rimuovere i duplicati da un elenco. Il metodo restituisce un nuovo DataFrame con i duplicati rimossi e i dati del frame dati originale telaio Rimane invariato.
Algoritmo:
Crea un frame di dati Panda con l'elenco. Utilizza il metodo drop_duplicates() su DataFram e quindi converti il DataFrame risultante in un elenco.
Python3
import> pandas as pd> # initializing list> test_list>=> [>1>,>5>,>3>,>6>,>3>,>5>,>6>,>1>]> print>(>'The original list is : '> +> str>(test_list))> # creating DataFrame> df>=> pd.DataFrame({>'col'>: test_list})> # using drop_duplicates() method> df.drop_duplicates(inplace>=>True>)> # converting back to list> res>=> df[>'col'>].tolist()> # printing list after removal> print>(>'The list after removing duplicates : '> +> str>(res))> |
>
>
Produzione:
The original list is : [1, 5, 3, 6, 3, 5, 6, 1] The list after removing duplicates : [1 , 5 , 3, 6]>
Complessità temporale: La complessità temporale del metodo drop_duplicates() è O(n log n) poiché ordina i valori prima di rimuovere i duplicati. La conversione da DataFrame a un elenco richiede tempo O(n). Pertanto, la complessità temporale complessiva di questo metodo è O(n log n).
Complessità spaziale: La complessità spaziale di questo metodo è O(n) perché vengono creati un nuovo DataFrame e un elenco, ciascuno con n elementi.