Comment fonctionne la comparaison de tuples en Python ?

Une introduction rapide aux tuples

Python se compose de 4 types de données intégrés qui sont utilisés pour stocker des collections de données. Ces types de données sont :

Liste
Définir
Dictionnaire
Tuplet

Un tuple vous permet de stocker plusieurs éléments dans une seule variable. C'est donc une collection commandée et immuable /immuable. De plus, les tuples sont hétérogènes car ils vous permettent de stocker des éléments de différents types.

Syntaxe :

my_tuple = (1, 2, 3, 'Python')

Exemple :

my_tuple = ("Python", "Java", 200)
print(my_tuple)

# OUTPUT : ('Python', 'Java', 200)

Pour plus de détails sur les tuples en Python, veuillez consulter notre tutoriel de blog ici . Le but de cet article est de discuter du fonctionnement de la comparaison entre deux tuples.

Formulation du problème

Étant donné deux tuples ; comment fonctionne la comparaison entre les deux tuples ?

Exemple :

(4, 5) < (3, 5) # Equals false

Ainsi, comme illustré dans l'exemple ci-dessus - comment/pourquoi la sortie est-elle fausse ? Ou Comment Python compare-t-il ces deux tuples ?

? Comparaison de tuples - Python

? La règle empirique pour comparer les Tuples Python :

Tuples in Python are compared lexicographically. This means that the corresponding elements of the given tuples are compared to each other.

Par conséquent, les tuples en Python sont comparés sur la base de leur position :le premier élément du premier tuple est comparé au premier élément du deuxième tuple. S'ils ne sont pas égaux, la première comparaison suffit pour en déduire la sortie. Sinon, les deuxièmes éléments sont considérés, puis le troisième et ainsi de suite jusqu'à ce que tous les éléments correspondants des deux tuples aient été comparés.

Jetons un coup d'œil à la documentation Python parle de comparaison de valeur de séquences intégrées telles que des listes et des tuples :

Pour que deux collections soient "égales" :
- ils doivent être du même type , (par exemple, [10,20] == (10,20) est false car le type n'est pas le même).
- ils doivent avoir la même longueur , et
- chaque paire d'éléments correspondants dans les séquences données, doit être égal .
Les tuples prennent en charge la comparaison d'ordre et les collections qui prennent en charge la comparaison d'ordre sont classées de la même manière que leurs premiers éléments inégaux/différents.
- Par exemple, [10,20,a] <= [10,20,z] est identique à a <= z ). Dans le cas où un élément correspondant n'existe pas, la collection la plus courte est commandée en premier et est considérée comme la plus petite. (par exemple, [10,20] < [10,20,0] est true ).

⚠️ Attention

Vous ne devez pas considérer les tuples comme des vecteurs dans un espace à n dimensions , comparés selon leur longueur.
Dans les comparaisons ordonnées, < et > ne représentent pas "plus petit que » et « supérieur à "; ils représentent plutôt "est avant " et " est après “. Ainsi, dans notre exemple ci-dessus (4, 5) n'est pas avant (3, 5). Par conséquent, la sortie est False .

Voyons maintenant quelques scénarios qui clarifieront davantage notre concept.

➧Comparaisons normales

Examinons l'extrait de code suivant qui compare deux tuples dans de nombreux scénarios :

# comparing integers
print((10, 20) < (10, 25))
print((10, 20) == (10, 25))
print((10, 20) > (10, 25))
# comparing strings
print(('x', 'y') < ('x', 'z'))
# comparing list of tuples
print(([4, 5], [5, 6]) == ([4, 5], [5, 6]))

Sortie :

True
False
False
True
True

Explication :-

En comparant (10,20) et (10,25) on observe que le premier élément des deux tuples est égal, donc les éléments suivants sont comparés et il est évident que 20 < 25 . Cela signifie que (10,20) < (10,25) .
(‘x’, ‘y’) <(‘x’, ‘z’) vaut true car lorsque vous comparez les valeurs ASCII du deuxième élément des deux tuples, vous obtenez le résultat suivant : ord('y')< ord('z') # – > true
De même, dans le troisième scénario, il est tout à fait clair que lorsque nous comparons les deux tuples contenant des listes similaires, la sortie est true .

➧Comparer des tuples inégaux

Considérez que vous avez quelques tuples de longueurs différentes. Voyons comment cette comparaison fonctionne dans l'extrait suivant :

tup1 = (10, 20, 30)
tup2 = (10, 20, 30, 40)
if tup1 > tup2:
    print(tup1, ">", tup2, "--> TRUE")
else:
    print(tup1, '<', tup2, "--> TRUE")

Sortie :

(10, 20, 30) < (10, 20, 30, 40) – > TRUE

➧Comparer des tuples avec des éléments hétérogènes

Lors de la comparaison de deux tuples qui ont des éléments hétérogènes, c'est-à-dire == l'opérateur fonctionne normalement ; cependant < et > les opérateurs ne fonctionnent pas avec des types de données hétérogènes.

Exemple :

print(('5',1,2)==(6,1,2)) # – -> False
print(('5',1,2)>(6,1,2)) # – > TypeError: '>' not supported between instances of 'str' and 'int'

Par conséquent, pour évaluer les opérateurs supérieur à et inférieur à pour comparer des éléments hétérogènes de deux tuples, vous devez utiliser le map() fonction pour convertir les valeurs des deux tuples en un seul type. Vous pouvez en savoir plus sur la fonction map() dans ce didacticiel.

Exemple :

tup1 = (10, 20, 30)
tup2 = ('100', 20, 30)
print(tuple(map(int, tup2)) > tup1)

Sortie :

True

? Bonus :Méthodes pour comparer deux tuples en Python

➧ Méthode 1 :Utiliser all() et zip()

Le all(x) intégré de Python la fonction prend un itérable comme argument x comme une liste, un tuple ou un dictionnaire. Il renvoie True si tous les éléments itérables sont évalués à True en utilisant la conversion booléenne implicite, sinon, il renvoie False . Si l'itérable est vide, all() renvoie True car la condition est satisfaite pour tous les éléments .
Le zip() La fonction prend un nombre arbitraire d'itérables et les agrège en un seul itérable, un objet zip. Il combine les i-ièmes valeurs de chaque argument itérable dans un tuple. Par conséquent, si vous passez deux itérables, chaque tuple contiendra deux valeurs. Si vous passez trois itérables, chaque tuple contiendra trois valeurs. Par exemple, zip ensemble répertorie [1, 2, 3] et [4, 5, 6] à [(1,4), (2,5), (3,6)] .

Exemple :

tup1 = (10, 20, 40)
tup2 = (5, 15, 25)
if all(x > y for x, y in zip(tup1, tup2)):
    print("tup1 is greater!")
else:
    print("tup2 is greater!")

Sortie :

tup1 is greater!

➧ Méthode 2 :Utiliser all() et map() avec une fonction Lambda

tup1 = (10, 20, 40)
tup2 = (5, 15, 25)
if all(map(lambda x, y: x>y,tup1, tup2)):
    print("tup1 is greater!")
else:
    print("tup2 is greater!")

Sortie :

tup1 is greater!

Conclusion

J'espère que cet article vous a aidé à comprendre les comparaisons de tuples en Python. Veuillez vous abonner et restez à l'écoute pour des concepts et des discussions plus intéressants.