15.1 Création d'une copie de tuple
Alors, nous savons déjà que les tuples (tuples) sont des séquences immuables d'éléments.
En raison de leur immuabilité, créer une copie de tuple peut sembler être une tâche insignifiante, car contrairement aux listes, les tuples ne changent pas après leur création.
Cependant, dans certains cas, il peut être nécessaire de créer une copie d'un tuple, surtout quand il est important de travailler avec sa version séparée sans modifier les données originales. Voici les principales méthodes :
Assignation directe
Le moyen le plus simple de créer une copie d'un tuple est d'utiliser l'assignation directe. Cela crée un nouvel objet tuple, mais comme les tuples sont immuables, les deux objets référenceront les mêmes données.
original_tuple = (1, 2, 3, 4, 5)
copied_tuple = original_tuple
print(copied_tuple)
Dans ce cas, copied_tuple réfèrera au même objet que original_tuple.
Utilisation de la fonction tuple()
Une autre manière de créer une copie d'un tuple est d'utiliser la fonction intégrée tuple(). Cette fonction crée un nouveau tuple en copiant les éléments du tuple original.
original_tuple = (1, 2, 3, 4, 5)
copied_tuple = tuple(original_tuple)
print(copied_tuple)
Cette méthode est particulièrement utile quand tu veux t'assurer que tu créés un nouvel objet, même si l'objet original peut être un autre objet iterable.
Conversion via une liste
Parfois, il peut être nécessaire de créer une copie modifiable d'un tuple sous la forme d'une liste pour faire des modifications, puis de la reconvertir en tuple.
original_tuple = (1, 2, 3, 4, 5)
temp_list = list(original_tuple)
temp_list.append(6)
copied_tuple = tuple(temp_list)
print(copied_tuple)
Dans cet exemple, nous convertissons d'abord le tuple en liste, ajoutons un nouvel élément, puis convertissons la liste en tuple.
15.2 Fusion de tuples
Contrairement aux listes, les tuples ne peuvent pas être modifiés après leur création, mais tu peux créer de nouveaux tuples en combinant ceux qui existent déjà. La fusion de tuples est une opération courante qui peut être utile dans divers scénarios de programmation.
Méthodes principales pour fusionner des tuples
Concaténation
La manière la plus simple de combiner deux ou plusieurs tuples est d'utiliser l'opérateur +. Cette méthode crée un nouveau tuple qui est le résultat de la concaténation des tuples originaux.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)
Dans cet exemple, combined_tuple contiendra les éléments (1, 2, 3, 4, 5, 6).
Multiplication par un entier
Tu peux également utiliser l'opérateur * pour multiplier un tuple par un entier. Cela répète le tuple un certain nombre de fois et crée un nouveau tuple.
tuple1 = (1, 2, 3)
multiplied_tuple = tuple1 * 3
print(multiplied_tuple)
Ici, multiplied_tuple contiendra les éléments (1, 2, 3, 1, 2, 3, 1, 2, 3).
Fonction itertools.chain
Pour fusionner un grand nombre de tuples, tu peux utiliser la fonction chain du module itertools. Cela est pratique lorsque le nombre de tuples à fusionner est inconnu à l'avance.
from itertools import chain
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
tuple3 = (7, 8, 9)
combined_tuple = tuple(chain(tuple1, tuple2, tuple3))
print(combined_tuple)
Le résultat sera (1, 2, 3, 4, 5, 6, 7, 8, 9).
15.3 Tuples imbriqués
Les tuples qui contiennent d'autres tuples à l'intérieur sont appelés tuples imbriqués (nested tuples). Les tuples imbriqués offrent un moyen pratique d'organiser et de structurer les données, surtout lorsque tu dois représenter des données multidimensionnelles ou des structures complexes.
Tu peux combiner des tuples pour créer des structures imbriquées. Cela est utile pour organiser des données en structures multidimensionnelles. Créer un tuple imbriqué en Python est tout aussi simple que créer un tuple ordinaire. Tu n'as qu'à inclure un tuple dans un autre.
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
Dans cet exemple, nested_tuple contient trois tuples, chacun comportant trois éléments.
Exemple de création d'un tuple imbriqué à partir de tuples ordinaires :
Dans cet exemple, nested_tuple contient trois tuples, chacun comportant trois éléments.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
nested_tuple = (tuple1, tuple2)
print(nested_tuple)
Ici, nested_tuple contiendra ((1, 2, 3), (4, 5, 6)).
Accès aux éléments d'un tuple imbriqué
L'accès aux éléments d'un tuple imbriqué se fait en utilisant une indexation multiple. Tu indiques d'abord l'index pour le tuple externe, puis pour l'interne.
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
# Accès à l'élément 5 dans le deuxième tuple imbriqué
element = nested_tuple[1][1]
print(element) # Affiche: 5
Tableaux multidimensionnels
Les tuples imbriqués sont souvent utilisés pour représenter des tableaux bidimensionnels ou multidimensionnels. Par exemple, un tableau de données peut être représenté comme un tuple de tuples, où chaque ligne du tableau est un tuple distinct.
Structuration des données
Les tuples imbriqués sont pratiques pour structurer des données comme des coordonnées géographiques (latitude et longitude) pour plusieurs endroits :
locations = (("New York", (40.7128, -74.0060)),
("Los Angeles", (34.0522, -118.2437)),
("Chicago", (41.8781, -87.6298)))
GO TO FULL VERSION