Dans ce laboratoire, vous acquerrez une compréhension complète des tuples en Python. Vous apprendrez à créer des tuples, à accéder à leurs éléments en utilisant l'indexation et le slicing (tranchage), et à explorer leur nature immuable. Vous vous entraînerez également à utiliser les opérateurs de tuple, le dépaquetage (unpacking) et les fonctions intégrées courantes pour travailler efficacement avec les données de type tuple.
Dans cette étape, vous apprendrez à créer des tuples et à accéder à leurs éléments. Les tuples sont des collections d'éléments ordonnées et immuables, ce qui signifie que leur contenu ne peut pas être modifié après leur création.
Tout d'abord, localisez l'explorateur de fichiers sur le côté gauche du WebIDE. Trouvez et ouvrez le fichier nommé tuple_basics.py. Nous écrirons notre code dans ce fichier.
Commençons par créer quelques types de tuples différents. Ajoutez le code suivant à tuple_basics.py :
## Create an empty tuple
empty_tuple = ()
print("Empty tuple:", empty_tuple)
print("Type of empty_tuple:", type(empty_tuple))
## Create a tuple with a single element (note the trailing comma)
single_element_tuple = (50,)
print("\nSingle element tuple:", single_element_tuple)
print("Type of single_element_tuple:", type(single_element_tuple))
## Create a tuple with multiple elements
fruits = ("apple", "banana", "cherry")
print("\nFruits tuple:", fruits)
## Create a tuple from a list using the tuple() constructor
numbers_list = [1, 2, 3, 4]
numbers_tuple = tuple(numbers_list)
print("\nTuple from list:", numbers_tuple)Après avoir ajouté le code, enregistrez le fichier (vous pouvez utiliser le raccourci Ctrl+S). Ensuite, ouvrez le terminal en bas du WebIDE et exécutez le script avec la commande suivante :
python tuple_basics.pyVous devriez voir la sortie suivante, qui confirme la création et les types de vos tuples :
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)Maintenant, apprenons à accéder aux éléments à l'intérieur d'un tuple. Vous pouvez utiliser l'indexation (en commençant par 0) pour obtenir un seul élément et le slicing (tranchage) pour obtenir une sous-séquence d'éléments.
Ajoutez le code suivant à la fin de votre fichier tuple_basics.py :
## Define a sample tuple for accessing elements
my_tuple = ('p', 'y', 't', 'h', 'o', 'n')
print("\nOriginal tuple:", my_tuple)
## Access elements using indexing
print("First element (index 0):", my_tuple[0])
print("Last element (index -1):", my_tuple[-1])
## Access elements using slicing
print("Elements from index 1 to 3:", my_tuple[1:4])
print("Elements from index 2 to the end:", my_tuple[2:])
print("Reverse the tuple:", my_tuple[::-1])Enregistrez à nouveau le fichier et exécutez le script depuis le terminal :
python tuple_basics.pyLa sortie complète inclura désormais les résultats de l'accès aux éléments du tuple :
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)
Original tuple: ('p', 'y', 't', 'h', 'o', 'n')
First element (index 0): p
Last element (index -1): n
Elements from index 1 to 3: ('y', 't', 'h')
Elements from index 2 to the end: ('t', 'h', 'o', 'n')
Reverse the tuple: ('n', 'o', 'h', 't', 'y', 'p')Vous avez maintenant réussi à créer des tuples et à accéder à leurs éléments.
Une caractéristique clé des tuples est leur immuabilité. Cela signifie qu'une fois qu'un tuple est créé, vous ne pouvez pas modifier, ajouter ou supprimer ses éléments. Dans cette étape, vous verrez ce qui se passe lorsque vous essayez de modifier un tuple et apprendrez la bonne façon d'obtenir une "modification" en créant un nouveau tuple.
Ouvrez le fichier tuple_modification.py depuis l'explorateur de fichiers.
Premièrement, essayons de changer un élément dans un tuple directement. Ajoutez le code suivant à tuple_modification.py. La ligne qui tente la modification est commentée.
my_tuple = ('a', 'b', 'c', 'd', 'e')
print("Original tuple:", my_tuple)
## The following line will cause a TypeError because tuples are immutable.
## You can uncomment it to see the error for yourself.
## my_tuple[0] = 'f'Si vous exécutiez le code avec la ligne avant-dernière non commentée, Python s'arrêterait et afficherait une TypeError: 'tuple' object does not support item assignment.
Puisque nous ne pouvons pas modifier un tuple sur place, la solution consiste à créer un nouveau tuple avec les changements souhaités. Nous pouvons le faire en utilisant le slicing (tranchage) et la concaténation (+).
Ajoutez le code suivant à la fin de tuple_modification.py pour voir comment "remplacer" un élément :
## "Modify" a tuple by creating a new one
## Concatenate a new single-element tuple ('f',) with a slice of the original tuple
modified_tuple = ('f',) + my_tuple[1:]
print("New 'modified' tuple:", modified_tuple)
print("Original tuple is unchanged:", my_tuple)De même, vous pouvez "supprimer" un élément en créant un nouveau tuple qui l'exclut. Ajoutez ce code à votre fichier :
## "Delete" an element by creating a new tuple
## Concatenate the slice before the element with the slice after the element
tuple_after_deletion = my_tuple[:2] + my_tuple[3:] ## Excludes element at index 2 ('c')
print("\nNew tuple after 'deletion':", tuple_after_deletion)Enregistrez le fichier et exécutez-le depuis le terminal :
python tuple_modification.pyLa sortie démontrera que nous avons créé de nouveaux tuples tandis que l'original reste intact :
Original tuple: ('a', 'b', 'c', 'd', 'e')
New 'modified' tuple: ('f', 'b', 'c', 'd', 'e')
Original tuple is unchanged: ('a', 'b', 'c', 'd', 'e')
New tuple after 'deletion': ('a', 'b', 'd', 'e')Cette étape met en évidence la nature immuable des tuples et la pratique standard pour contourner cette limitation.
Python fournit plusieurs opérateurs utiles pour travailler avec les tuples. Vous apprendrez également le dépaquetage de tuple (tuple unpacking), une fonctionnalité puissante pour assigner les éléments d'un tuple à des variables.
Ouvrez le fichier tuple_operators.py depuis l'explorateur de fichiers.
Explorons les opérateurs de concaténation (+), de répétition (*) et d'appartenance (in). Ajoutez le code suivant à tuple_operators.py :
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
## Concatenation (+)
concatenated_tuple = tuple1 + tuple2
print("Concatenated:", concatenated_tuple)
## Repetition (*)
repeated_tuple = tuple1 * 3
print("Repeated:", repeated_tuple)
## Membership (in)
is_present = 'b' in tuple2
print("\nIs 'b' in tuple2?", is_present)
is_absent = 5 in tuple1
print("Is 5 in tuple1?", is_absent)Enregistrez le fichier et exécutez-le depuis le terminal :
python tuple_operators.pyVous verrez les résultats de ces opérations :
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? FalseEnsuite, explorons le dépaquetage de tuple. Cela vous permet d'assigner les éléments d'un tuple à plusieurs variables en une seule ligne lisible. Le nombre de variables doit correspondre au nombre d'éléments dans le tuple.
Ajoutez le code suivant à la fin de tuple_operators.py :
## Tuple unpacking
person_info = ("Alice", 30, "Engineer")
name, age, profession = person_info
print("\nOriginal info tuple:", person_info)
print("Unpacked Name:", name)
print("Unpacked Age:", age)
print("Unpacked Profession:", profession)Enregistrez à nouveau le fichier et exécutez le script :
python tuple_operators.pyLa sortie inclura maintenant les variables dépaquetées :
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? False
Original info tuple: ('Alice', 30, 'Engineer')
Unpacked Name: Alice
Unpacked Age: 30
Unpacked Profession: EngineerLe dépaquetage de tuple est particulièrement utile pour les fonctions qui retournent plusieurs valeurs, car elles les retournent souvent dans un tuple.
Dans cette dernière étape, vous apprendrez à utiliser les fonctions et méthodes intégrées courantes qui opèrent sur les tuples. Les tuples possèdent deux méthodes principales, count() et index(), et peuvent être utilisés avec de nombreuses fonctions à usage général.
Ouvrez le fichier tuple_functions.py depuis l'explorateur de fichiers.
Commençons par les méthodes de tuple. count() retourne le nombre de fois qu'un élément apparaît, et index() retourne l'indice de la première occurrence d'un élément.
Ajoutez le code suivant à tuple_functions.py :
my_tuple = (1, 5, 2, 8, 5, 3, 5, 9)
print("Tuple:", my_tuple)
## count() method
count_of_5 = my_tuple.count(5)
print("Count of 5:", count_of_5)
## index() method
index_of_8 = my_tuple.index(8)
print("Index of 8:", index_of_8)Maintenant, utilisons quelques fonctions intégrées très utiles avec les tuples, telles que len(), max(), min(), sum(), et sorted().
Ajoutez le code suivant à la fin de tuple_functions.py :
number_tuple = (10, 5, 20, 15, 30, 5)
print("\nNumber tuple:", number_tuple)
## len() function
print("Length:", len(number_tuple))
## max() and min() functions
print("Maximum value:", max(number_tuple))
print("Minimum value:", min(number_tuple))
## sum() function (for numeric tuples)
print("Sum of elements:", sum(number_tuple))
## sorted() function (returns a new sorted list)
sorted_list = sorted(number_tuple)
print("Sorted list from tuple:", sorted_list)Notez que la fonction sorted() retourne une nouvelle liste, et non un tuple. Si vous avez besoin d'un tuple trié, vous pouvez reconvertir le résultat en utilisant tuple(sorted_list).
Enregistrez le fichier et exécutez-le depuis le terminal :
python tuple_functions.pyVotre sortie devrait ressembler à ceci :
Tuple: (1, 5, 2, 8, 5, 3, 5, 9)
Count of 5: 3
Index of 8: 3
Number tuple: (10, 5, 20, 15, 30, 5)
Length: 6
Maximum value: 30
Minimum value: 5
Sum of elements: 85
Sorted list from tuple: [5, 5, 10, 15, 20, 30]Vous avez maintenant appris à utiliser des méthodes et fonctions importantes pour inspecter et analyser les tuples.
Dans ce laboratoire, vous avez acquis une base solide dans l'utilisation des tuples Python. Vous avez appris à créer des tuples de différentes manières et à accéder à leurs éléments en utilisant l'indexation et le découpage (slicing). Vous avez exploré le concept fondamental de l'immuabilité des tuples et vous vous êtes exercé à créer de nouveaux tuples pour effectuer des "modifications". Vous vous êtes également familiarisé avec les opérateurs de tuple courants tels que + et *, la commodité du dépaquetage de tuple (tuple unpacking), ainsi que l'utilité des méthodes intégrées (count(), index()) et des fonctions (len(), max(), sorted()) pour travailler avec les données des tuples.
