Comment comparer des tuples en Python

Lorsque vous travaillez avec Python, vous pouvez souvent avoir besoin de comparer des tuples. Les tuples sont des séquences immuables, ce qui signifie qu’une fois créés, ils ne peuvent pas être modifiés. Cette caractéristique les rend particulièrement utiles pour stocker des collections fixes d’éléments. Comparer des tuples peut vous aider à déterminer leur égalité, leur ordre, et même leur contenu.

Dans cet article, nous allons explorer la façon dont Python compare les tuples, des simples vérifications d’égalité à l’ordre lexicographique, et le comportement des comparaisons lorsque les tuples diffèrent par leur type, leur longueur ou leur imbrication.

Comment Python compare les tuples

Python compare les tuples de manière lexicographique, de la même façon que les mots sont classés dans un dictionnaire. Il compare les premiers éléments de chaque tuple ; s’ils diffèrent, cette première différence décide de la comparaison, et les éléments restants ne sont jamais examinés. Si les premiers éléments sont égaux, il passe à la paire suivante, et ainsi de suite, jusqu’à ce qu’il trouve une différence ou qu’il n’y ait plus d’éléments. Si un tuple est un préfixe de l’autre — tous ses éléments correspondent au début du tuple le plus long — le tuple le plus court est considéré comme inférieur au plus long.

L’opérateur d’égalité (==) vérifie si les deux tuples ont les mêmes éléments dans le même ordre, et l’opérateur d’inégalité (!=) est son opposé exact :

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
tuple3 = (1, 2, 4)

print(tuple1 == tuple2)
print(tuple1 == tuple3)
print(tuple1 != tuple3)

Sortie :

True
False
True

Les opérateurs d’ordre (<, <=, >, >=) appliquent le même balayage élément par élément, en utilisant l’ordre propre à chaque paire pour décider :

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2)

print(tuple1 < tuple2)
print(tuple1 > tuple3)

Sortie :

True
True

Ici, tuple1 est inférieur à tuple2 parce que les deux premiers éléments sont égaux et que 3 < 4. Et tuple1 est supérieur à tuple3 parce que tuple3 est un préfixe de tuple1, donc le tuple le plus long s’ordonne après le plus court.

Gérer les différents types, longueurs et tuples imbriqués

L’égalité et l’ordre ne traitent pas les types mixtes de la même manière, et les confondre est une source fréquente d’attentes erronées.

L’égalité ne lève jamais d’erreur à cause des types. Deux éléments de types différents sont simplement inégaux — avec l’exception numérique habituelle selon laquelle des valeurs comme 1 et 1.0 sont considérées égales —, de sorte qu’une comparaison de tuples avec == renvoie False, et != renvoie True, sans que personne ne vérifie les types au préalable :

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 == tuple2)
print(tuple1 != tuple2)

Sortie :

False
True

L’ordre est plus strict. Dès qu’une comparaison d’ordre atteint une paire d’éléments qui ne peuvent pas être ordonnés l’un par rapport à l’autre, comme une chaîne de caractères face à un entier, elle lève une TypeError au lieu de renvoyer un résultat :

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 < tuple2)

Sortie :

TypeError: '<' not supported between instances of 'str' and 'int'

Les premiers éléments sont égaux, donc la comparaison passe à "a" face à 2 — et les chaînes de caractères et les entiers n’ont aucun ordre entre eux, d’où l’erreur. Notez que cela ne se produit que si la comparaison atteint réellement la paire incompatible : (0, "a") < (1, 2) renvoie False sans erreur, parce que les premiers éléments la décident déjà.

Les longueurs différentes interagissent avec une vérification populaire d’égalité élément par élément d’une manière facile à manquer. Combiner all() avec zip() compare les paires que zip() produit, et zip() s’arrête au tuple le plus court — de sorte que les éléments finaux sans correspondance sont silencieusement ignorés :

tuple1 = (1, 2, 3)
tuple2 = (1, 2)

print(all(a == b for a, b in zip(tuple1, tuple2)))
print(len(tuple1) == len(tuple2) and all(a == b for a, b in zip(tuple1, tuple2)))

Sortie :

True
False

La première ligne affiche True alors que les tuples ne sont pas égaux, parce que le 3 final n’est jamais comparé. Si vous utilisez ce motif — il est pratique pour les grands tuples ou pour une logique personnalisée par élément — associez-le toujours à une vérification de longueur, comme dans la deuxième ligne.

Les tuples imbriqués n’ont besoin d’aucun traitement spécial : un élément tuple est comparé avec les mêmes règles que tout autre élément, de manière récursive. (1, 2) à l’intérieur d’un tuple s’ordonne avant (3, 5) à l’intérieur d’un autre, parce que leurs propres premiers éléments différents en décident :

tuple1 = ((1, 2), (3, 4))
tuple2 = ((1, 2), (3, 5))

print(tuple1 < tuple2)
print(tuple1 == tuple2)

Sortie :

True
False

En résumé : utilisez == et != lorsque vous avez seulement besoin de savoir si deux tuples sont identiques — ils fonctionnent avec n’importe quel contenu. Utilisez les opérateurs d’ordre lorsque vous avez besoin de l’ordre relatif, et assurez-vous que les éléments que la comparaison atteindra réellement peuvent être ordonnés les uns par rapport aux autres.