Comment vérifier si un tuple est trié par ordre croissant en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un tuple est trié par ordre croissant en Python. Les tuples, tout comme les listes, sont des séquences immuables. Étant donné que les tuples ne peuvent pas être triés directement à l'aide de méthodes qui modifient la séquence d'origine, ce laboratoire explore des approches alternatives.

Le laboratoire montre comment utiliser la fonction sorted() pour créer une nouvelle liste triée à partir d'un tuple et la reconvertir en tuple. Il présente également les fonctions all() et zip() comme outils pour vérifier si un tuple est déjà trié par ordre croissant.

Skills Graph

Apprendre les tuples triés

Dans cette étape, vous allez apprendre à propos des tuples triés en Python. Les tuples sont similaires aux listes, mais ils sont immuables, ce qui signifie que leurs éléments ne peuvent pas être modifiés après leur création. Un tuple trié est simplement un tuple dont les éléments sont arrangés dans un ordre spécifique, généralement croissant ou décroissant.

Étant donné que les tuples sont immuables, vous ne pouvez pas les trier directement à l'aide de méthodes telles que sort() qui modifient la liste d'origine. Au lieu de cela, vous utiliserez la fonction sorted(), qui renvoie une nouvelle liste triée à partir des éléments de n'importe quel itérable, y compris les tuples. Vous pouvez ensuite reconvertir cette liste triée en tuple.

Commençons par créer un simple tuple :

my_tuple = (5, 2, 8, 1, 9)
print(my_tuple)

Maintenant, trions ce tuple à l'aide de la fonction sorted() et convertissons le résultat en tuple :

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.
2. Créez un nouveau fichier nommé sort_tuple.py dans le répertoire ~/project.
3. Copiez et collez le code suivant dans sort_tuple.py :

my_tuple = (5, 2, 8, 1, 9)
sorted_list = sorted(my_tuple)
sorted_tuple = tuple(sorted_list)

print("Original tuple:", my_tuple)
print("Sorted tuple:", sorted_tuple)

Ce code définit d'abord un tuple appelé my_tuple. Ensuite, il utilise la fonction sorted() pour créer une liste triée à partir des éléments de my_tuple. Enfin, il convertit la liste triée en un tuple appelé sorted_tuple.

Pour exécuter le script, ouvrez un terminal dans VS Code (vous le trouverez dans le panneau inférieur) et exécutez la commande suivante :

python sort_tuple.py

Vous devriez voir la sortie suivante :

Original tuple: (5, 2, 8, 1, 9)
Sorted tuple: (1, 2, 5, 8, 9)

Comme vous pouvez le voir, la fonction sorted() renvoie un nouveau tuple avec les éléments du tuple d'origine arrangés par ordre croissant.

Vous pouvez également trier le tuple par ordre décroissant en utilisant le paramètre reverse de la fonction sorted() :

my_tuple = (5, 2, 8, 1, 9)
sorted_list = sorted(my_tuple, reverse=True)
sorted_tuple = tuple(sorted_list)

print("Original tuple:", my_tuple)
print("Sorted tuple (descending):", sorted_tuple)

Enregistrez les modifications dans sort_tuple.py et exécutez-le à nouveau :

python sort_tuple.py

La sortie devrait maintenant être :

Original tuple: (5, 2, 8, 1, 9)
Sorted tuple (descending): (9, 8, 5, 2, 1)

Maintenant, vous avez un tuple trié par ordre décroissant.

Comparaison avec sorted()

Dans l'étape précédente, vous avez appris à trier un tuple à l'aide de la fonction sorted(). Dans cette étape, nous allons approfondir l'étude de la fonction sorted() et comparer son comportement avec d'autres méthodes, en mettant en évidence sa polyvalence et ses cas d'utilisation.

La fonction sorted() est une fonction intégrée (built-in) de Python qui peut être utilisée pour trier n'importe quel itérable, y compris les listes, les tuples, les chaînes de caractères et les dictionnaires. Elle renvoie une nouvelle liste triée sans modifier l'itérable d'origine. Cela est particulièrement utile lorsque vous souhaitez conserver la structure de données d'origine.

Explorons quelques exemples pour illustrer la puissance de sorted() :

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.
2. Modifiez le fichier existant sort_tuple.py dans le répertoire ~/project, ou créez-le s'il n'existe pas.
3. Copiez et collez le code suivant dans sort_tuple.py :

## Sorting a list of strings
string_list = ["banana", "apple", "orange"]
sorted_string_list = sorted(string_list)
print("Original list:", string_list)
print("Sorted list:", sorted_string_list)

## Sorting a string (characters)
my_string = "hello"
sorted_string = sorted(my_string)
print("Original string:", my_string)
print("Sorted string (as list):", sorted_string)

## Sorting a dictionary (keys)
my_dict = {"c": 3, "a": 1, "b": 2}
sorted_dict_keys = sorted(my_dict)
print("Original dictionary:", my_dict)
print("Sorted dictionary keys:", sorted_dict_keys)

Ce code montre comment sorted() peut être utilisée avec différents types de données. Il trie une liste de chaînes de caractères par ordre alphabétique, trie les caractères d'une chaîne de caractères et trie les clés d'un dictionnaire.

Pour exécuter le script, ouvrez un terminal dans VS Code (vous le trouverez dans le panneau inférieur) et exécutez la commande suivante :

python sort_tuple.py

Vous devriez voir la sortie suivante :

Original list: ['banana', 'apple', 'orange']
Sorted list: ['apple', 'banana', 'orange']
Original string: hello
Sorted string (as list): ['e', 'h', 'l', 'l', 'o']
Original dictionary: {'c': 3, 'a': 1, 'b': 2}
Sorted dictionary keys: ['a', 'b', 'c']

Notez que sorted() renvoie toujours une liste, quelle que soit le type d'entrée. Si vous avez besoin du résultat dans un autre format, comme un tuple, vous pouvez le convertir en utilisant tuple(), comme vous l'avez appris dans l'étape précédente.

Une autre caractéristique importante de sorted() est le paramètre key. Ce paramètre vous permet de spécifier une fonction qui sera utilisée pour extraire une clé de comparaison de chaque élément de l'itérable. Cela est utile pour trier des objets complexes en fonction d'un attribut spécifique.

Par exemple, trions une liste de tuples en fonction du deuxième élément de chaque tuple :

## Sorting a list of tuples based on the second element
tuple_list = [(1, 'z'), (2, 'a'), (3, 'b')]
sorted_tuple_list = sorted(tuple_list, key=lambda x: x[1])
print("Original list of tuples:", tuple_list)
print("Sorted list of tuples (by second element):", sorted_tuple_list)

Ajoutez ce code à votre fichier sort_tuple.py et exécutez-le à nouveau :

python sort_tuple.py

La sortie devrait maintenant inclure :

Original list of tuples: [(1, 'z'), (2, 'a'), (3, 'b')]
Sorted list of tuples (by second element): [(2, 'a'), (3, 'b'), (1, 'z')]

Dans cet exemple, la fonction lambda x: x[1] extrait le deuxième élément de chaque tuple, et sorted() utilise ces éléments pour déterminer l'ordre des tuples dans la liste triée.

Vérification avec all() et zip()

Dans cette étape, vous allez apprendre à utiliser les fonctions all() et zip() en conjonction avec des tuples triés pour effectuer des vérifications et des comparaisons plus avancées.

La fonction all() est une fonction intégrée (built-in) de Python qui renvoie True si tous les éléments d'un itérable sont vrais (ou si l'itérable est vide). Elle est souvent utilisée pour vérifier si une condition est remplie pour tous les éléments d'une séquence.

La fonction zip() est une autre fonction intégrée de Python qui prend plusieurs itérables en arguments et renvoie un itérateur de tuples. Chaque tuple contient les éléments correspondants des itérables d'entrée. Elle est utile pour associer des éléments de différentes séquences pour des comparaisons ou d'autres opérations.

Voyons comment ces fonctions peuvent être utilisées avec des tuples triés :

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.
2. Modifiez le fichier existant sort_tuple.py dans le répertoire ~/project, ou créez-le s'il n'existe pas.
3. Copiez et collez le code suivant dans sort_tuple.py :

## Checking if a tuple is sorted using all() and zip()
def is_sorted(data):
    ## zip(data, data[1:]) pairs consecutive elements
    ## all(x <= y for x, y in ...) checks if each pair is in ascending order
    return all(x <= y for x, y in zip(data, data[1:]))

my_tuple1 = (1, 2, 3, 4, 5)
my_tuple2 = (5, 2, 8, 1, 9)

print("Tuple 1:", my_tuple1, "is sorted:", is_sorted(my_tuple1))
print("Tuple 2:", my_tuple2, "is sorted:", is_sorted(my_tuple2))

Ce code définit une fonction is_sorted() qui vérifie si un tuple donné est trié par ordre croissant. Elle utilise zip() pour associer les éléments consécutifs du tuple et all() pour vérifier si chaque paire est dans l'ordre croissant.

Pour exécuter le script, ouvrez un terminal dans VS Code (vous le trouverez dans le panneau inférieur) et exécutez la commande suivante :

python sort_tuple.py

Vous devriez voir la sortie suivante :

Tuple 1: (1, 2, 3, 4, 5) is sorted: True
Tuple 2: (5, 2, 8, 1, 9) is sorted: False

Comme vous pouvez le voir, la fonction is_sorted() identifie correctement si les tuples sont triés ou non.

Étendons cet exemple pour vérifier si deux tuples sont identiques après tri :

## Checking if two tuples are identical after sorting
def are_identical_after_sorting(tuple1, tuple2):
    return sorted(tuple1) == sorted(tuple2)

tuple_a = (3, 1, 4, 1, 5)
tuple_b = (1, 5, 1, 4, 3)
tuple_c = (1, 2, 3, 4, 5)

print("Tuple A:", tuple_a, "and Tuple B:", tuple_b, "are identical after sorting:", are_identical_after_sorting(tuple_a, tuple_b))
print("Tuple A:", tuple_a, "and Tuple C:", tuple_c, "are identical after sorting:", are_identical_after_sorting(tuple_a, tuple_c))

Ajoutez ce code à votre fichier sort_tuple.py et exécutez-le à nouveau :

python sort_tuple.py

La sortie devrait maintenant inclure :

Tuple A: (3, 1, 4, 1, 5) and Tuple B: (1, 5, 1, 4, 3) are identical after sorting: True
Tuple A: (3, 1, 4, 1, 5) and Tuple C: (1, 2, 3, 4, 5) are identical after sorting: False

Dans cet exemple, la fonction are_identical_after_sorting() vérifie si deux tuples contiennent les mêmes éléments, indépendamment de leur ordre d'origine. Elle trie les deux tuples et compare ensuite les listes triées.

Résumé

Dans ce laboratoire (lab), vous avez appris à propos des tuples triés en Python et à les créer. Étant donné que les tuples sont immuables, vous ne pouvez pas les trier directement. Au lieu de cela, la fonction sorted() est utilisée pour créer une nouvelle liste triée à partir des éléments du tuple, qui est ensuite reconvertie en tuple.

Le laboratoire a démontré comment trier un tuple par ordre croissant en utilisant sorted() et comment afficher le tuple d'origine et le tuple trié à l'aide d'instructions print. Le laboratoire a également mentionné la possibilité de trier par ordre décroissant en utilisant le paramètre reverse, bien que le code complet pour cela ait été tronqué.