Comment comparer des listes en Python

Pour comparer deux listes Python, décidez d’abord si l’ordre et le nombre de doublons ont une importance. Utilisez == pour une égalité ordonnée exacte, Counter pour ignorer l’ordre tout en gardant les occurrences, set() pour les valeurs uniques et une compréhension pour conserver l’ordre d’une liste.

Les exemples utilisent la bibliothèque standard de Python et ont été vérifiés avec Python 3.14.7. Ces méthodes répondent à des questions différentes : choisissez la sémantique voulue avant de privilégier les performances.

L’égalité renvoie un booléen, alors que les opérations sur ensembles et compteurs construisent de nouveaux résultats. Changer de représentation peut donc changer la réponse, pas seulement sa vitesse.

Comparer des listes ordonnées exactes avec ==

L’égalité de listes compare les éléments correspondants de gauche à droite. Les listes doivent avoir la même longueur, les mêmes valeurs à chaque position et le même ordre ; c’est le choix naturel pour des étapes ou événements séquencés.

"""Verify that list equality considers both values and order."""

first = [1, 2, 3]
same = [1, 2, 3]
reordered = [3, 2, 1]

print(first == same)
print(first == reordered)

True
False

Le second test est False bien que les deux listes contiennent les mêmes valeurs uniques. L’égalité directe accepte aussi des éléments non hachables, par exemple des listes imbriquées.

Les comparaisons suivent les règles d’égalité de chaque objet, notamment __eq__ pour des objets personnalisés. Elles ne signalent pas l’emplacement d’une différence imbriquée : elles renvoient seulement le résultat final.

Comparer des listes non ordonnées en gardant les doublons avec Counter

Employez collections.Counter si l’ordre ne compte pas, mais que la fréquence de chaque valeur compte. Un compteur associe chaque élément hachable à son nombre d’occurrences.

"""Compare unordered lists with and without duplicate multiplicity."""

from collections import Counter

left = [1, 2, 2, 3]
reordered = [3, 2, 1, 2]
fewer_duplicates = [3, 2, 1]

print(Counter(left) == Counter(reordered))
print(Counter(left) == Counter(fewer_duplicates))
print(set(left) == set(fewer_duplicates))

True
False
True

Counter détecte le deuxième 2 absent, tandis qu’un ensemble élimine les doublons et considère donc ces listes égales. N’utilisez pas l’égalité de deux ensembles si les répétitions ont une signification.

sorted(left) == sorted(right) garde aussi les doublons, mais exige des valeurs mutuellement ordonnables et crée deux listes triées. Counter exprime généralement plus directement l’égalité de fréquences ; sorted() reste utile si les séquences triées sont nécessaires.

Comparer les valeurs uniques, intersections et différences avec set()

Convertissez les listes en ensembles lorsque seules les valeurs distinctes comptent. & donne l’intersection, - une différence directionnelle et ^ la différence symétrique.

L’exemple ne trie les ensembles que pour afficher un résultat déterministe ; une comparaison d’ensembles n’impose aucun ordre.

Les ensembles rendent les tests d’appartenance efficaces, mais perdent position et multiplicité. Ne vous fiez pas à l’ordre affiché par un ensemble ; triez seulement pour une présentation stable de valeurs ordonnables.

"""Verify unique-value, order-preserving, and multiplicity-aware differences."""

from collections import Counter

left = [1, 2, 2, 3, 4]
right = [2, 3, 3, 5]
left_set = set(left)
right_set = set(right)

print(sorted(left_set & right_set))
print(sorted(left_set - right_set))
print(sorted(right_set - left_set))

right_members = set(right)
print([item for item in left if item in right_members])

left_counts = Counter(left)
right_counts = Counter(right)
print(sorted((left_counts & right_counts).elements()))
print(sorted((left_counts - right_counts).elements()))
print(sorted((right_counts - left_counts).elements()))

[2, 3]
[1, 4]
[5]
[2, 2, 3]
[2, 3]
[1, 2, 4]
[3, 5]

Les trois premières lignes montrent l’intersection de valeurs uniques et les différences directionnelles. left_set ^ right_set donnerait 1, 4 et 5, dans un ordre non spécifié.

Préserver l’ordre du résultat avec une compréhension de liste

Un ensemble ne préserve pas l’ordre de la première liste. Créez une fois un ensemble d’appartenance, puis parcourez la liste dont vous voulez conserver l’ordre.

La quatrième ligne, [2, 2, 3], garde ordre et répétitions de left. Avec des valeurs non hachables, une appartenance fondée sur l’égalité reste possible mais peut exiger des parcours répétés.

Préserver les multiplicités dans les intersections et différences avec Counter

Les ensembles répondent à des questions sur les valeurs uniques ; Counter garde les quantités pour les intersections et différences.

• left_counts & right_counts conserve le plus petit compte positif de chaque valeur commune.
• left_counts - right_counts soustrait les comptes et ne garde que les restes positifs.
• La soustraction inverse donne les éléments restants du côté droit.
• .elements() développe à nouveau les comptes en valeurs individuelles.

Dans l’exemple, l’intersection multiensemble est [2, 3], et non [2, 2, 3] : le minimum d’occurrences de 2 est un. Les restes sont [1, 2, 4] à gauche et [3, 5] à droite.

Cette méthode convient aux inventaires, votes ou étiquettes répétées, lorsque la quantité est significative. Un ensemble effacerait silencieusement cette information.

L’arithmétique de Counter retire les comptes nuls et négatifs de ces résultats. Inspectez les compteurs directement si l’application doit conserver ces soldes.

Gérer les valeurs non hachables et choisir la bonne méthode

set() et Counter exigent des éléments hachables. Les listes imbriquées, mutables, produisent donc un TypeError, alors que l’égalité directe continue de fonctionner.

"""Show the unhashable-item boundary of set and Counter comparisons."""

from collections import Counter

left = [[1], [2]]
right = [[1], [2]]

print(left == right)
for name, operation in (("set", set), ("Counter", Counter)):
    try:
        operation(left)
    except TypeError as error:
        print(f"{name}: {error}")

True
set: cannot use 'list' as a set element (unhashable type: 'list')
Counter: unhashable type: 'list'

Le texte exact de l’erreur set peut varier selon la version de Python ; le type d’exception et la cause — un élément non hachable — sont le comportement stable.

Si cela correspond au modèle de données, convertissez les listes internes en tuples avant d’utiliser set ou Counter. Sinon, conservez une comparaison fondée sur l’égalité qui respecte la sémantique recherchée.