Comment comparer deux listes en Python

Introduction

Lors de la programmation en Python ou lors de son apprentissage, vous pourriez avoir besoin de déterminer si deux ou plusieurs listes sont égales. Lorsque vous comparez des listes pour l'égalité, vous vérifiez si les listes ont la même longueur et si chaque élément de la liste est égal. Des listes de longueurs différentes ne sont jamais égales.

Cet article décrit comment utiliser les fonctionnalités Python suivantes pour comparer des listes :

• méthode sort() ou fonction sorted() avec l'opérateur ==
• fonction set() avec l'opérateur ==
• reduce() et map() fonctions avec l'opérateur ==
• classe collection.Counter() avec l'opérateur ==
• compréhension de liste

Utiliser la méthode sort() ou la fonction sorted() pour comparer des listes

Vous pouvez utiliser la méthode sort() ou la fonction sorted() pour trier des listes dans le but de les comparer pour l'égalité. La méthode sort() trie la liste sur place, tandis que la fonction sorted() retourne une nouvelle liste. Après le tri, les listes qui sont égales auront les mêmes éléments aux mêmes positions d'index. L'opérateur == compare les listes, élément par élément (comparaison élément par élément).

L'ordre des éléments de la liste originale n'est pas important, car les listes sont triées avant la comparaison.

Exemple de la méthode sort()

L'exemple suivant montre comment utiliser la méthode sort() pour trier et comparer des listes pour l'égalité :

l1 = [10, 20, 30, 40, 50] 
l2 = [20, 30, 50, 40, 70] 
l3 = [50, 10, 30, 20, 40] 

l1.sort() 
l2.sort() 
l3.sort() 

if l1 == l2: 
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

if l1 == l3: 
    print ("The lists l1 and l3 are the same") 
else: 
    print ("The lists l1 and l3 are not the same") 

La sortie est :

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

L'exemple de code précédent trie chaque liste, compare l1 à l3 et imprime le résultat, puis compare l1 à l2 et imprime le résultat.

Exemple de la fonction sorted()

L'exemple suivant démontre comment utiliser la fonction sorted() pour trier et comparer des listes pour l'égalité :

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 10, 30, 20, 40]

l1_sorted = sorted(l1)
l2_sorted = sorted(l2)
l3_sorted = sorted(l3)

if l1_sorted == l2_sorted:
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if l1_sorted == l3_sorted:
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

La sortie est :

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

Le code d'exemple précédent renvoie une version triée de chaque liste, compare l1 à l3 et affiche le résultat, puis compare l1 à l2 et affiche le résultat.

Utiliser les fonctions reduce() et map() pour comparer des listes

Vous pouvez utiliser la fonction map() de Python avec la fonction functools.reduce() pour comparer les éléments de deux listes. Lorsque vous les utilisez en combinaison, la fonction map() applique la fonction donnée à chaque élément et la fonction reduce() s'assure qu'elle applique la fonction de manière consécutive.

La fonction map() accepte une fonction et un itérable comme arguments. La fonction map() applique la fonction donnée à chaque élément de l'itérable et renvoie ensuite un objet map (itérateur) en résultat.

La fonction functools.reduce() accepte également une fonction et un itérable comme arguments. La fonction functools.reduce() applique la fonction donnée à chaque élément de l'itérable de manière récursive. Au départ, functools.reduce() applique la fonction sur les deux premiers éléments et renvoie le résultat, puis applique la fonction sur le résultat et le troisième élément, et continue jusqu'à ce que la liste n'ait plus d'éléments.

Lorsque vous les utilisez en combinaison, la fonction map() applique la fonction donnée à chaque élément et la fonction reduce() garantit qu'elle applique la fonction de manière consécutive.

L'ordre des éléments de la liste est important lorsque vous utilisez les fonctions reduce() et map(). Des listes avec les mêmes éléments dans un ordre différent ne renverront pas true lorsqu'elles sont comparées pour l'égalité. Si nécessaire, vous pouvez trier les listes d'abord.

L'exemple suivant montre comment utiliser les fonctions reduce() et map() pour comparer des listes pour l'égalité :

import functools

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [10, 20, 30, 40, 50]

if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l2), True):
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l3), True):
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

La sortie est :

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

Le code d'exemple précédent compare l1 à l2 puis compare l1 à l3.

Utiliser la fonction set() pour comparer des listes

Vous pouvez utiliser la fonction set() pour créer des objets set à partir des listes données, puis comparer les ensembles pour l'égalité en utilisant l'opérateur ==.

L'ordre des éléments de la liste originale n'est pas important, car l'opérateur == renvoie true lorsque chaque ensemble contient des éléments identiques dans n'importe quel ordre.

L'exemple suivant montre comment créer des ensembles à partir de listes et comparer les ensembles pour égalité :

l1 = [10, 20, 30, 40, 50]
l2 = [50, 10, 30, 20, 40]

a = set(l1)
b = set(l2)

if a == b:
    print("Lists l1 and l2 are equal")
else:
    print("Lists l1 and l2 are not equal")

La sortie est :

Lists l1 and l2 are equal

Le code d'exemple précédent crée des ensembles a et b à partir des listes l1 et l2, puis compare les ensembles et imprime le résultat.

Utiliser la classe collections.Counter() pour comparer des listes

La classe collections.Counter() peut être utilisée pour comparer des listes. La fonction counter() compte la fréquence des éléments dans une liste et stocke les données sous forme d'objet dictionnaire au format valeur:fréquence. Si deux listes ont la même sortie de dictionnaire, vous pouvez en déduire que les listes sont les mêmes.

L'ordre des éléments de la liste d'origine n'est pas important lorsque vous utilisez la classe Counter pour comparer des listes.

L'exemple suivant démontre comment créer des objets Counter à partir des listes données et les comparer pour l'égalité :

import collections

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 20, 30, 40, 10]

if collections.Counter(l1) == collections.Counter(l2):
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if collections.Counter(l1) == collections.Counter(l3):
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

La sortie est :

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

Le code d'exemple précédent crée des objets Counter pour les listes l1 et l2, les compare et imprime le résultat. Le code se répète pour les listes l1 et l3.

Utiliser la compréhension de liste pour comparer des listes

Vous pouvez utiliser des compréhensions de liste pour comparer deux listes. Pour plus d'informations sur les compréhensions de liste, reportez-vous à Comprendre les compréhensions de liste en Python 3.

L'ordre des éléments de la liste originale n'est pas important lorsque vous utilisez la compréhension de liste pour comparer des listes.

L'exemple suivant démontre comment utiliser une compréhension de liste pour comparer des listes :

l1 = [10, 20, 30, 40, 50]
l2 = [50, 75, 30, 20, 40]
l3 = [50, 20, 30, 40, 10]

res = [x for x in l1 + l2 if x not in l1 or x not in l2]

print(res)
if not res:
    print("Lists l1 and l2 are equal")
else:
    print("Lists l1 and l2 are not equal")

res2 = [x for x in l1 + l3 if x not in l1 or x not in l3]

print(res2)
if not res2:
    print("Lists l1 and l3 are equal")
else:
    print("Lists l1 and l3 are not equal")

L'exemple de code précédent définit un élément pointeur x pour les listes l1 et l2, puis vérifie si l'élément pointé par l'élément pointeur est présent dans les listes. Si le résultat, res, est une liste vide, alors vous pouvez en déduire que les listes sont égales, car il n'y a pas d'éléments qui apparaissent uniquement dans l'une des listes.

La sortie est :

[10, 75]
Lists l1 and l2 are not equal

Conclusion

Cet article décrit quelques façons différentes de comparer des listes pour l'égalité en Python. Poursuivez votre apprentissage avec d'autres tutoriels Python.