Tuples en Python

Les tuples Python

Un tuple est une séquence ordonnée et immuable d’objets Python. ‘Immuable’ signifie qu’une fois un tuple créé, ses éléments ne peuvent pas être modifiés, ajoutés ou supprimés. Les tuples sont similaires aux listes, mais la différence clé est leur immuabilité.

Les tuples sont définis en plaçant des valeurs séparées par des virgules entre parenthèses (). Les parenthèses sont facultatives si le contexte est clair, mais leur utilisation est une pratique courante.

# Création de tuples
tuple1 = ('physics', 'chemistry', 1997, 2000)
tuple2 = (1, 2, 3, 4, 5)
tuple3 = "a", "b", "c", "d" # Parenthèses facultatives ici

empty_tuple = ()

# Un tuple avec un seul élément nécessite une virgule finale
single_element_tuple = (50,)
not_a_tuple = (50) # Ceci est juste l'entier 50

print(type(single_element_tuple)) # Sortie : <class 'tuple'>
print(type(not_a_tuple))       # Sortie : <class 'int'>

Comme les listes et les chaînes de caractères, les éléments des tuples sont indexés à partir de 0. Vous pouvez accéder aux éléments, les découper (slice), concaténer des tuples et les répéter.

Accéder aux valeurs dans les tuples

Utilisez les crochets [] avec l’index pour accéder aux éléments individuels, ou le slicing [début:fin:pas] pour obtenir des sous-tuples.

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print(f"tup1[0]: {tup1[0]}")          # Accéder au premier élément
print(f"tup2[1:5]: {tup2[1:5]}")      # Trancher de l'index 1 jusqu'à (sans inclure) 5
print(f"tup1[-1]: {tup1[-1]}")         # Accéder au dernier élément

Sortie :

tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
tup1[-1]: 2000

Mise à jour des tuples (Immuabilité)

Les tuples sont immuables. Vous ne pouvez pas modifier un élément à l’intérieur d’un tuple après sa création.

tup1 = (12, 34.56)

# L'action suivante est INVALIDE et lèvera une TypeError :
# tup1[0] = 100
# TypeError : l'objet 'tuple' ne supporte pas l'assignation d'éléments

Cependant, vous pouvez créer de nouveaux tuples en combinant des tuples existants ou des parties de ceux-ci.

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# Créer un nouveau tuple en concaténant tup1 et tup2
tup3 = tup1 + tup2
print(f"New tuple tup3: {tup3}")

Sortie :

New tuple tup3: (12, 34.56, 'abc', 'xyz')

Si un tuple contient un objet mutable (comme une liste), le contenu de cet objet mutable peut être modifié, mais l’objet lui-même reste à la même position dans le tuple.

tuple_with_list = (1, 2, ['a', 'b'])
print(f"Original : {tuple_with_list}")

# Modifier la liste à l'intérieur du tuple (ceci est autorisé)
tuple_with_list[2].append('c')
print(f"Modifié : {tuple_with_list}")

# Tenter de remplacer l'objet liste lui-même échoue
# tuple_with_list[2] = ['x', 'y'] # TypeError !

Supprimer des éléments de tuple

Parce que les tuples sont immuables, vous ne pouvez pas supprimer des éléments individuels d’un tuple.

Vous pouvez cependant supprimer un objet tuple entier en utilisant l’instruction del.

tup = ('physics', 'chemistry', 1997, 2000)

print(f"Tuple original : {tup}")

# Supprimer l'objet tuple entier
del tup

# Tenter d'accéder à 'tup' maintenant lèvera une NameError
# print(tup)
# NameError : le nom 'tup' n'est pas défini
print("Le tuple 'tup' a été supprimé.")

Opérations de base sur les tuples

Les tuples prennent en charge les opérations de séquence standard comme la concaténation (+) et la répétition (*), qui donnent lieu à de nouveaux tuples.

Expression Python	Résultat	Description
len((1, 2, 3))	3	Longueur
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Concaténation
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	Répétition
3 in (1, 2, 3)	True	Vérification d’appartenance
for x in (1, 2, 3): print(x, end=' ')	1 2 3	Itération

Indexation et Tranchage (Slicing)

L’indexation et le tranchage fonctionnent de la même manière qu’avec les listes et les chaînes de caractères.

T = ('spam', 'Spam', 'SPAM!', 'eggs')

Expression Python	Résultat	Description
T[0]	'spam'	Premier élément (index 0)
T[-1]	'eggs'	Dernier élément
T[1:3]	('Spam', 'SPAM!')	Tranche de l’index 1 jusqu’à (sans inclure) 3
T[::2]	('spam', 'SPAM!')	Un élément sur deux

Déballage de tuple (Tuple Unpacking)

Une fonctionnalité très courante et puissante est le déballage de tuple (tuple unpacking), où vous assignez les éléments d’un tuple à des variables individuelles. Le nombre de variables doit correspondre au nombre d’éléments dans le tuple.

point = (10, 20, 30)
x, y, z = point # Déballage

print(f"x = {x}, y = {y}, z = {z}")

# Peut être utilisé pour un échange facile
a = 5
b = 10
a, b = b, a # Échanger les valeurs en utilisant le packing/unpacking de tuple
print(f"Échangé : a = {a}, b = {b}")

# Déballage étendu (Python 3)
numbers = (1, 2, 3, 4, 5)
first, second, *rest = numbers
print(f"premier : {first}, deuxième : {second}, reste : {rest}")

first, *middle, last = numbers
print(f"premier : {first}, milieu : {middle}, dernier : {last}")

Sortie :

x = 10, y = 20, z = 30
Swapped: a = 10, b = 5
first: 1, second: 2, rest: [3, 4, 5]
first: 1, middle: [2, 3, 4], last: 5

Fonctions intégrées pour les tuples

Python inclut des fonctions qui peuvent opérer sur les tuples :

Fonction	Description
len(tuple)	Donne le nombre total d’éléments dans le tuple.
max(tuple)	Renvoie l’élément du tuple avec la valeur maximale (les éléments doivent être comparables).
min(tuple)	Renvoie l’élément du tuple avec la valeur minimale (les éléments doivent être comparables).
sum(tuple)	Renvoie la somme de tous les éléments du tuple (les éléments doivent être numériques).
tuple(iterable)	Convertit un itérable (comme une liste, une chaîne ou un range) en un tuple.
sorted(tuple)	Renvoie une nouvelle liste contenant tous les éléments du tuple par ordre croissant.

Remarque : La fonction cmp(tuple1, tuple2) de Python 2 a été supprimée dans Python 3. Utilisez les opérateurs de comparaison standard (<, >, ==, etc.) qui fonctionnent lexicographiquement sur les tuples.

Pourquoi utiliser les tuples ?

Malgré leur similarité avec les listes, les tuples sont utiles dans plusieurs scénarios :