Tempo fa ho scritto una guida su come confrontare due dizionari in Python 3 e su come questo compito non sia così semplice come potrebbe sembrare. Si scopre che confrontare due elenchi in Python è così complicato come confrontare dict s.
Il modo in cui ci è stato insegnato a confrontare due oggetti in Python è un po' fuorviante. La maggior parte dei libri e dei tutorial insegna il confronto degli oggetti utilizzando il == o il is operatore. In realtà, questi due operatori coprono solo una piccola parte dei casi d'uso più frequenti.
Ad esempio:
- E se volessimo confrontare un elenco di numeri in virgola mobile considerando una certa tolleranza?
- E se volessimo mettere a confronto due liste ma ignorando l'ordine in cui compaiono gli elementi?
- forse dobbiamo confrontare due liste e restituire gli elementi che si intersecano entrambi
- A volte potremmo voler ottenere la differenza tra due elenchi
- Cosa succede se abbiamo due elenchi di stringhe e dobbiamo confrontarli ignorando le maiuscole e minuscole?
- Cosa succede se ci viene fornito un elenco di
numpyarray per confrontarsi, cosa possiamo fare? - o forse abbiamo un elenco di oggetti personalizzati o un elenco di dizionari.
L'elenco potrebbe continuare all'infinito e per tutti questi casi d'uso si utilizza == non aiuta.
Questo è ciò che vedremo in questo articolo. Impareremo i modi migliori per confrontare due elenchi in Python per diversi casi d'uso in cui == l'operatore non è abbastanza.
Pronto? Andiamo!
Confronto se due liste sono uguali in python
Il modo più semplice per confrontare due elenchi per l'uguaglianza è utilizzare il == operatore. Questo metodo di confronto funziona bene per casi semplici, ma come vedremo in seguito, non funziona con confronti avanzati.
Un esempio di un caso semplice potrebbe essere un elenco di int o str oggetti.
>>> numbers = [1, 2, 3]
>>> target = [1, 2, 3]
>>> numbers == target
True
>>> [1, 2, 3] == [1, 3, 2]
False
>>> ['name', 'lastname'] == ['name', 'lastname']
True
>>> ['name', 'lastname'] == ['name', 'last name']
False
Abbastanza semplice, vero? Sfortunatamente, il mondo è complesso, così come il codice del livello di produzione. Nel mondo reale, le cose si complicano molto velocemente. A titolo illustrativo, considera i seguenti casi.
Si supponga di avere un elenco di virgola mobile costruito dinamicamente. Puoi aggiungere singoli elementi o elementi derivati da un'operazione matematica come 0.1 + 0.1 .
>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target # compares the lists
False
>>> numbers # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]
Chiaramente, l'aritmetica in virgola mobile ha i suoi limiti e talvolta vogliamo confrontare due elenchi ma ignorare gli errori di precisione o addirittura definire una certa tolleranza. Per casi come questo, il == operatore non sarà sufficiente.
Le cose possono complicarsi se gli elenchi hanno oggetti personalizzati o oggetti di altre librerie, come numpy .
In [1]: import numpy as np
In [2]: numbers = [np.ones(3), np.zeros(2)]
In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]
In [4]: target = [np.ones(3), np.zeros(2)]
In [5]: numbers == target
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
Potresti anche voler confrontare le liste e restituire le corrispondenze. O magari confrontare le due liste e restituire le differenze. O forse vuoi confrontare due elenchi ignorando i duplicati o confrontare un elenco di dizionari in Python.
In ogni singolo caso, utilizzando == non è la risposta, ed è quello che vedremo dopo:come eseguire complesse operazioni di confronto tra due elenchi in Python.
Confronto di due elenchi di numeri float
Nella sezione precedente, abbiamo visto che l'aritmetica in virgola mobile può causare errori di precisione. Se abbiamo una lista di float e vogliamo confrontarla con un'altra lista, è probabile che il == l'operatore non aiuterà.
Rivisitiamo l'esempio della sezione precedente e vediamo qual è il modo migliore per confrontare due elenchi di float.
>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target # compares the lists
False
>>> numbers # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]
Come vedi, 0.1 + 0.1 + 0.1 = 0.30000000000000004 , che fa fallire il confronto. Ora, come possiamo fare di meglio? È anche possibile?
Ci sono alcuni modi per affrontare questo compito. Uno sarebbe creare la nostra funzione personalizzata, che itera sugli elementi e confrontarli uno per uno usando math.isclose() funzione.
Fortunatamente non dobbiamo reinventare la ruota. Come ho mostrato nell'articolo "come confrontare due dicts", possiamo usare una libreria chiamata deepdiff per quello. Questa libreria supporta diversi tipi di oggetti e gli elenchi sono uno di questi.
L'esempio seguente inizia impostando i due elenchi che vogliamo confrontare. Lo passiamo quindi a deepdiff.DeepDiff costruttore che restituisce la differenza. È fantastico, il valore restituito è molto più informativo di un semplice booleano.
Poiché vogliamo ignorare l'errore di precisione, possiamo impostare il numero di cifre DOPO il punto decimale da utilizzare nel confronto.
Il risultato è un dict vuoto, il che significa che le liste sono uguali. Se proviamo a confrontare un elenco con un numero float che differisce per più di 3 cifre significative, la libreria restituirà quella differenza.
Per la riproducibilità, in questo articolo ho utilizzato l'ultima versione di deepdiff che è 5.6.0 .
In [1]: from deepdiff import DeepDiff
In [2]: numbers = []
In [3]: numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation
In [4]: numbers.append(0.2) # add a single element
In [5]: target = [0.3, 0.2]
# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]:
{'values_changed': {'root[0]': {'new_value': 0.3,
'old_value': 0.30000000000000004}}}
# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}
In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]
In [9]: target = [0.341, 0.2]
# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]:
{'values_changed': {'root[0]': {'new_value': 0.341,
'old_value': 0.30000000000000004}}}
Confronto se due liste senza ordine (liste non ordinate) sono uguali
Le liste in Python non sono ordinate per impostazione predefinita. A volte vogliamo confrontare due elenchi ma trattarli come uguali purché abbiano gli stessi elementi, indipendentemente dal loro ordine.
Ci sono due modi per farlo:
- ordinando le liste e usando il
==operatore - convertendoli in
setse usando il==operatore - usando
deepdiff
Questi primi due metodi presuppongono che gli elementi possano essere confrontati in modo sicuro usando il == operatore. Questo approccio non funziona per i numeri in virgola mobile e altri oggetti complessi, ma come abbiamo visto nella sezione precedente, possiamo usare deepdiff .
Ordinamento degli elenchi e utilizzo di == operatore
Puoi ordinare gli elenchi in Python in due modi diversi:
- utilizzando
list.sort()metodo - usando
sorted()funzione
Il primo metodo ordina un elenco sul posto e ciò significa che l'elenco verrà modificato. È una buona idea non modificare un elenco esistente in quanto può introdurre bug difficili da rilevare.
Usando sorted è meglio poiché restituisce un nuovo elenco e mantiene l'originale non modificato.
Vediamo come funziona.
In [6]: numbers = [10, 30, 20]
In [7]: target = [10, 20, 30]
In [8]: numbers == target
Out[8]: False
In [9]: sorted(numbers) == sorted(target)
Out[9]: True
In [10]: sorted(numbers)
Out[10]: [10, 20, 30]
In [11]: sorted(target)
Out[11]: [10, 20, 30]
Di conseguenza, ordinando prima le liste ci assicuriamo che entrambe le liste abbiano lo stesso ordine, e quindi possano essere confrontate usando il == operatore.
Conversione dell'list s a un set
Contrariamente alle liste, i set in Python non si preoccupano dell'ordine. Ad esempio, un insieme {1, 2, 3} è uguale a {2, 3, 1} . Pertanto, possiamo utilizzare questa funzione per confrontare i due elenchi ignorando l'ordine degli elementi.
Per fare ciò, convertiamo ogni elenco in un set, quindi utilizzando il == per confrontarli.
In [12]: numbers = [10, 30, 20]
In [13]: target = [10, 20, 30]
In [14]: set(numbers) == set(target)
Out[14]: True
In [15]: set(numbers)
Out[15]: {10, 20, 30}
In [16]: set(target)
Out[16]: {10, 20, 30}
Utilizzo di deepdiff biblioteca
Questa libreria ci consente anche di ignorare l'ordine in sequenze come list S. Per impostazione predefinita, prenderà in considerazione l'ordine, ma se impostiamo ignore_order a True , allora stiamo tutti bene. Vediamolo in azione.
In [11]: numbers = [10, 30, 20]
In [12]: target = [10, 20, 30]
In [13]: DeepDiff(numbers, target)
Out[13]:
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
'root[2]': {'new_value': 30, 'old_value': 20}}}
In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}
Usando deepdiff ha pro e contro. Alla fine, è una libreria esterna che devi installare, quindi se puoi usare un set per confrontare gli elenchi, quindi attenersi ad esso. Tuttavia, se hai altri casi d'uso in cui può brillare, allora lo farei.
Come confrontare due liste e restituire corrispondenze
In questa sezione vedremo come confrontare due liste e trovare la loro intersezione. In altre parole, vogliamo trovare i valori che appaiono in entrambi.
Per farlo, possiamo usare ancora una volta un set e prendi il loro incrocio.
In [1]: t1 = [2, 1, 0, 7, 4, 9, 3]
In [2]: t2 = [7, 6, 11, 12, 9, 23, 2]
In [3]: set(t1).intersection(set(t2))
Out[3]: {2, 7, 9}
# the & operator is a shorthand for the set.intersection() method
In [4]: set(t1) & set(t2)
Out[4]: {2, 7, 9}
Come confrontare due elenchi in Python e restituire le differenze
Possiamo trovare la differenza tra due liste in Python in due modi diversi:
- usando
set - usando il
deepdiffbiblioteca
Utilizzo di set
Proprio come abbiamo fatto per determinare l'intersezione, possiamo sfruttare il set struttura dati per verificare la differenza tra due elenchi in python.
Se vogliamo ottenere tutti gli elementi che sono presenti nella prima lista ma non nella seconda, possiamo usare il set.difference() .
D'altra parte, se vogliamo trovare tutti gli elementi che sono in una delle liste ma non in entrambe, allora possiamo usare set.symmetric_difference() .
In [8]: t1 = [2, 1, 0, 7, 4, 9, 3]
In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]
In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}
In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}
In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}
In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}
In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}
Questo metodo ha una limitazione:raggruppa ciò che è diverso tra le liste in un risultato finale che è la differenza impostata. E se volessimo sapere quali elementi in quella differenza appartengono a quale elenco?
Utilizzo di deepdiff
Come abbiamo visto finora, questa libreria è potente e restituisce una bella differenza. Vediamo cosa succede quando utilizziamo deepdiff per ottenere la differenza tra due elenchi in Python.
In [15]: t1 = [2, 1, 0, 7, 4, 9, 3]
In [16]: t2 = [7, 6, 11, 12, 9, 23, 2]
In [17]: DeepDiff(t1, t2)
Out[17]:
{'values_changed': {'root[0]': {'new_value': 7, 'old_value': 2},
'root[1]': {'new_value': 6, 'old_value': 1},
'root[2]': {'new_value': 11, 'old_value': 0},
'root[3]': {'new_value': 12, 'old_value': 7},
'root[4]': {'new_value': 9, 'old_value': 4},
'root[5]': {'new_value': 23, 'old_value': 9},
'root[6]': {'new_value': 2, 'old_value': 3}}}
In [18]: DeepDiff(t1, t2, ignore_order=True)
Out[18]:
{'values_changed': {'root[4]': {'new_value': 6, 'old_value': 4},
'root[6]': {'new_value': 11, 'old_value': 3},
'root[1]': {'new_value': 12, 'old_value': 1}},
'iterable_item_added': {'root[5]': 23},
'iterable_item_removed': {'root[2]': 0}}
Di conseguenza, deepdiff restituisce ciò che è cambiato da una lista all'altra. L'approccio corretto dipenderà quindi dal tuo caso d'uso. Se vuoi una differenza dettagliata, usa DeepDiff . Altrimenti, usa semplicemente un set .
Come confrontare due elenchi di stringhe
Il confronto di due elenchi di stringhe in Python dipende in gran parte dal tipo di confronto che si desidera effettuare. Questo perché possiamo confrontare una stringa in diversi modi.
In questa sezione, vedremo 3 diversi modi per farlo.
Il più semplice sta usando un == operatore, come abbiamo visto all'inizio. Questo metodo è adatto se si desidera un confronto rigoroso tra ciascuna stringa.
In [1]: names = ['jack', 'josh', 'james']
In [2]: target = ['jack', 'josh', 'james']
In [3]: names == target
Out[3]: True
Le cose iniziano a complicarsi se si desidera confrontare l'elenco di stringhe ma ignorando il caso. Usando il == perché non funziona.
In [4]: names = ['Jack', 'Josh', 'James']
In [2]: target = ['jack', 'josh', 'james']
In [5]: names == target
Out[5]: False
Lo strumento migliore per questo è ancora deepdiff . Ci permette di ignorare la stringa passandogli un flag booleano.
In [1]: import deepdiff
In [2]: names = ['Jack', 'Josh', 'James']
In [3]: target = ['jack', 'josh', 'james']
# ignoring string case
In [4]: deepdiff.DeepDiff(names, target, ignore_string_case=True)
Out[4]: {}
# considering the case
In [5]: deepdiff.DeepDiff(names, target)
Out[5]:
{'values_changed': {'root[0]': {'new_value': 'jack', 'old_value': 'Jack'},
'root[1]': {'new_value': 'josh', 'old_value': 'Josh'},
'root[2]': {'new_value': 'james', 'old_value': 'James'}}}
Possiamo anche ignorare l'ordine in cui le stringhe appaiono negli elenchi.
In [6]: names = ['Jack', 'James', 'Josh']
In [7]: target = ['jack', 'josh', 'james']
# ignoring the order and string case
In [8]: deepdiff.DeepDiff(names, target, ignore_string_case=True, ignore_order=T
...: rue)
Out[8]: {}
# considering the order but ignoring the case
In [9]: deepdiff.DeepDiff(names, target, ignore_string_case=True)
Out[9]:
{'values_changed': {'root[1]': {'new_value': 'josh', 'old_value': 'james'},
'root[2]': {'new_value': 'james', 'old_value': 'josh'}}}
Puoi anche andare oltre ed eseguire confronti avanzati passando un operatore personalizzato a DeepDiff .
Ad esempio, supponiamo di voler confrontare le stringhe ma ignorando eventuali spazi bianchi che potrebbero avere.
O forse vuoi eseguire una corrispondenza fuzzy utilizzando una metrica di modifica della distanza.
Per fare ciò, possiamo scrivere la logica di confronto nella classe operator e passarla a DeepDiff .
In questo primo esempio, ignoreremo qualsiasi spazio bianco tagliando le stringhe prima di confrontarle.
class IgnoreWhitespaceOperator:
def match(self, level) -> bool:
return True
def give_up_diffing(self, level, diff_instance) -> bool:
if isinstance(level.t1, str) and isinstance(level.t2, str):
return level.t1.strip() == level.t2.strip()
return False
Quindi possiamo semplicemente collegarci a DeepDiff aggiungendolo all'elenco di custom_operators , così custom_operators=[IgnoreWhitespaceOperator()] .
In [6]: from deepdiff import DeepDiff
In [13]: names = ['Jack', 'James ', ' Josh ']
In [14]: target = ['Jack', 'James', 'Josh',]
# the operator will ignore the spaces in both lists
In [15]: DeepDiff(names, target, custom_operators=[IgnoreWhitespaceOperator()])
Out[15]: {}
In [16]: target = ['Jack', 'James', 'Josh', 'Jelly']
# if one of the list has an additional member, this will be flagged
In [17]: DeepDiff(names, target, custom_operators=[IgnoreWhitespaceOperator()])
Out[17]: {'iterable_item_added': {'root[3]': 'Jelly'}}
In [18]: target = ['Jack', 'Josh', 'James']
# by default, the library doesn't ignore order
In [19]: DeepDiff(names, target, custom_operators=[IgnoreWhitespaceOperator()])
Out[19]:
{'values_changed': {'root[1]': {'new_value': 'Josh', 'old_value': 'James '},
'root[2]': {'new_value': 'James', 'old_value': ' Josh '}}}
# if you don't care about order, be explicit
In [20]: DeepDiff(names, target, ignore_order=True, custom_operators=[IgnoreWhitespaceOperator()])
Out[20]: {}
Come confrontare due elenchi di dizionari
Confrontare due elenchi di dizionari in Python è decisamente complicato senza l'aiuto di una libreria esterna. Come abbiamo visto finora, deepdiff è abbastanza versatile e possiamo usarlo per confrontare oggetti complessi profondi come elenchi di dizionari.
Vediamo cosa succede quando passiamo due elenchi di dizionari.
In [1]: from deepdiff import DeepDiff
In [2]: first_list = [
...: {
...: 'number': 1,
...: 'list': ['one', 'two']
...: },
...: {
...: 'number': 2,
...: 'list': ['one', 'two']
...: },
...: ]
In [3]: target_list = [
...: {
...: 'number': 3,
...: 'list': ['one', 'two']
...: },
...: {
...: 'number': 2,
...: 'list': ['one', 'two']
...: },
...: ]
In [4]: DeepDiff(first_list, target_list)
Out[4]: {'values_changed': {"root[0]['number']": {'new_value': 3, 'old_value': 1}}}
Visualizza la posizione esatta in cui gli elementi differiscono e qual è la differenza!
Vediamo un altro esempio in cui una lista ha un elemento mancante.
In [2]: first_list = [
...: {
...: 'number': 1,
...: 'list': ['one', 'two']
...: },
...: {
...: 'number': 2,
...: 'list': ['one', 'two']
...: },
...: ]
In [5]: target = [
...: {
...: 'number': 3,
...: 'list': ['one', 'two']
...: },
...: ]
In [6]:
In [6]: DeepDiff(first_list, target)
Out[6]:
{'values_changed': {"root[0]['number']": {'new_value': 3, 'old_value': 1}},
'iterable_item_removed': {'root[1]': {'number': 2, 'list': ['one', 'two']}}}
Dice che il secondo dizionario è stato rimosso, come nel caso di questo esempio.
Come confrontare due elenchi di elenchi
Confrontare elenchi multidimensionali, alias un elenco di elenchi, è facile per deepdiff . Funziona proprio come un elenco di dict s.
Nell'esempio seguente, abbiamo due elenchi multidimensionali che vogliamo confrontare. Quando passato a DeepDiff , restituisce la posizione esatta in cui gli elementi differiscono.
Ad esempio, per la posizione [1][0] , il nuovo valore è 8 e il vecchio è 3. Un altro aspetto interessante è che funziona per strutture profondamente nidificate, ad esempio deepdiff evidenzia anche la differenza nel [2][0][0] posizione.
In [1]: from deepdiff import DeepDiff
In [2]: first_list = [[1, 2], [3, 4], [[5]]]
In [3]: target_list = [[1, 2], [8, 4], [[7]]]
In [4]: DeepDiff(first_list, target_list)
Out[4]:
{'values_changed': {'root[1][0]': {'new_value': 8, 'old_value': 3},
'root[2][0][0]': {'new_value': 7, 'old_value': 5}}}
Quando si alimenta la libreria con due elenchi multidimensionali identici, restituisce una risposta vuota.
In [3]: target_list = [[1, 2], [8, 4], [[7]]]
In [5]: second_list = [[1, 2], [8, 4], [[7]]]
In [7]: DeepDiff(second_list, target_list)
Out[7]: {}
Come confrontare due elenchi di oggetti
A volte abbiamo un elenco di oggetti personalizzati che vogliamo confrontare. Forse vogliamo ottenere una differenza o semplicemente controllare se contengono gli stessi elementi. La soluzione a questo problema non potrebbe essere diversa:usa deepdiff .
L'esempio seguente mostra la potenza di questa libreria. Confronteremo due liste contenenti oggetti personalizzati e potremo asserire se sono uguali o meno e quali sono le differenze.
Nell'esempio seguente, abbiamo due elenchi di Person oggetti. L'unica differenza tra i due è che nell'ultima posizione Person l'oggetto ha un'età diversa. deepdiff non solo trova la posizione giusta - [1] - ma trova anche che age anche il campo è diverso.
In [9]: from deepdiff import DeepDiff
In [10]: first = [Person('Jack', 34), Person('Janine', 23)]
In [11]: target = [Person('Jack', 34), Person('Janine', 24)]
In [12]: DeepDiff(first, target)
Out[12]: {'values_changed': {'root[1].age': {'new_value': 24, 'old_value': 23}}}
In [14]: second = [Person('Jack', 34), Person('Janine', 24)]
In [15]: DeepDiff(second, target)
Out[15]: {}
Come confrontare due elenchi di array numpy
In questa sezione vedremo come confrontare due elenchi di numpy matrici. Questo è un compito abbastanza comune per coloro che lavorano con la scienza dei dati e/o l'apprendimento automatico.
Abbiamo visto nella prima sezione che usando il == operatore non funziona bene con elenchi di numpy matrici. Per fortuna possiamo usare... indovina un po'!? Sì, possiamo usare deepdiff .
L'esempio seguente mostra due elenchi con numpy diversi gli array e la libreria possono rilevare la posizione esatta in cui differiscono. Quanto è bello?
In [16]: import numpy as np
In [17]: from deepdiff import DeepDiff
In [18]: first = [np.ones(3), np.array([1, 2, 3])]
In [19]: target = [np.zeros(4), np.array([1, 2, 3, 4])]
In [20]: DeepDiff(first, target)
Out[20]:
{'values_changed': {'root[0][0]': {'new_value': 0.0, 'old_value': 1.0},
'root[0][1]': {'new_value': 0.0, 'old_value': 1.0},
'root[0][2]': {'new_value': 0.0, 'old_value': 1.0}},
'iterable_item_added': {'root[0][3]': 0.0, 'root[1][3]': 4}}
Conclusione
In questo post, abbiamo visto molti modi per confrontare due elenchi in Python. Il metodo migliore dipende dal tipo di elementi che abbiamo e da come vogliamo confrontare. Si spera che ora tu sappia come:
- controlla se due liste sono uguali in python
- confronta due liste senza ordine (liste non ordinate)
- confronta due liste in python e restituisci le corrispondenze
- confronta due elenchi in python e restituisce differenze
- confronta due elenchi di stringhe
- confronta due elenchi di dizionari
- confronta due elenchi di elenchi
- confronta due elenchi di oggetti
- confronta due elenchi di array numpy
