Tuples : séquences ordonnées et immuables

Qu'est-ce qu'un tuple en Python ? Définition et caractéristiques

En Python, un tuple est une structure de données similaire à une liste, mais avec une différence fondamentale : **les tuples sont immuables** (non modifiables). Cela signifie qu'une fois qu'un tuple est créé, vous ne pouvez plus modifier son contenu (ajouter, supprimer, ou modifier des éléments).

Comme les listes, les tuples sont :

• Ordonnés : Les éléments d'un tuple sont stockés dans un ordre précis, et cet ordre est conservé.
• Indexés : Vous pouvez accéder à chaque élément d'un tuple par sa position (son indice), en commençant par 0 pour le premier élément.
• Hétérogènes : Un tuple peut contenir des éléments de types différents.

La principale différence avec les listes est l'immuabilité. Cette caractéristique a des implications importantes sur l'utilisation des tuples et sur leur performance.

Créer un tuple : différentes méthodes

Il existe plusieurs façons de créer un tuple en Python :

• Utiliser des parenthèses `()` : C'est la méthode la plus courante. Vous pouvez créer un tuple vide ou un tuple contenant des éléments initiaux.
• Utiliser la fonction `tuple()` : Vous pouvez convertir un itérable (comme une liste, une chaîne de caractères, ou un ensemble) en tuple.
• Utiliser la virgule `,` : Pour créer un tuple avec un seul élément, vous devez ajouter une virgule après l'élément, même si vous utilisez des parenthèses.

Exemples :

# Tuple vide
tuple_vide = ()

# Tuple avec des éléments initiaux
coordonnees = (10, 20)
couleurs = ("rouge", "vert", "bleu")

# Tuple hétérogène
mixte = (1, "Bonjour", True, 3.14)

# Tuple à partir d'une liste
ma_liste = [1, 2, 3]
mon_tuple = tuple(ma_liste)  # (1, 2, 3)

# Tuple à partir d'une chaîne de caractères
lettres = tuple("Python")  # ('P', 'y', 't', 'h', 'o', 'n')

# Tuple avec un seul élément (attention à la virgule !)
tuple_un_element = (42,)  # La virgule est nécessaire
# Sans la virgule, ce serait juste un entier entre parenthèses : 
autre_chose = (42) # type(autre_chose) renvoie 

Notez la différence entre `(42)` et `(42,)`. Le premier est simplement l'entier 42 entre parenthèses (pour des raisons de priorité d'opérateurs, par exemple), tandis que le second est un tuple contenant un seul élément, l'entier 42.

Accéder aux éléments d'un tuple : indexation et slicing

Comme pour les listes, vous pouvez accéder aux éléments d'un tuple par leur indice, en utilisant des crochets `[]`. L'indexation commence à 0.

Exemples :

coordonnees = (10, 20, 30)

print(coordonnees[0])  # Affiche 10
print(coordonnees[1])  # Affiche 20
print(coordonnees[-1]) # Affiche 30 (le dernier élément)

Le slicing (tranchage) fonctionne également comme pour les listes, permettant d'extraire des sous-tuples :

nombres = (1, 2, 3, 4, 5, 6, 7, 8, 9)

print(nombres[2:5])    # Affiche (3, 4, 5)
print(nombres[:4])     # Affiche (1, 2, 3, 4)
print(nombres[5:])     # Affiche (6, 7, 8, 9)
print(nombres[::2])    # Affiche (1, 3, 5, 7, 9)
print(nombres[::-1])   # Affiche (9, 8, 7, 6, 5, 4, 3, 2, 1) (inverse le tuple)

Cependant, comme les tuples sont immuables, vous ne pouvez pas modifier un élément d'un tuple existant en utilisant l'indexation :

mon_tuple = (1, 2, 3)
# mon_tuple[0] = 10  # Ceci lèverait une TypeError: 'tuple' object does not support item assignment

Immuabilité des tuples : implications et avantages

L'immuabilité des tuples est leur caractéristique la plus importante. Elle signifie que vous ne pouvez pas modifier le contenu d'un tuple après sa création.

Cela a plusieurs implications :

• Sécurité : Les tuples garantissent que les données qu'ils contiennent ne seront pas modifiées accidentellement. Cela peut être utile pour représenter des données constantes ou des informations qui ne doivent pas être altérées.
• Performance : Python peut optimiser l'utilisation de la mémoire et les opérations sur les tuples, car il sait qu'ils ne changeront pas. Les tuples sont généralement plus rapides à créer et à parcourir que les listes.
• Utilisation comme clés de dictionnaire : Seuls les objets immuables peuvent être utilisés comme clés de dictionnaire en Python. Les tuples peuvent donc être utilisés comme clés, contrairement aux listes.
• Retour de fonctions : Les tuples sont souvent utilisés pour retourner plusieurs valeurs à partir d'une fonction.

Si vous avez besoin de modifier une séquence, utilisez une liste plutôt qu'un tuple. Si vous avez besoin d'une séquence immuable, utilisez un tuple.

"Tuple unpacking" : affectation multiple et déstructuration

Le "tuple unpacking" (dépaquetage de tuple) est une fonctionnalité puissante de Python qui permet d'affecter les éléments d'un tuple à des variables individuelles en une seule instruction.

Exemple :

coordonnees = (10, 20, 30)
x, y, z = coordonnees

print(x)  # Affiche 10
print(y)  # Affiche 20
print(z)  # Affiche 30

Le nombre de variables à gauche du signe `=` doit correspondre au nombre d'éléments dans le tuple, sinon Python lèvera une erreur `ValueError`.

Le tuple unpacking est souvent utilisé pour échanger les valeurs de deux variables sans utiliser de variable temporaire :

a = 10
b = 20

a, b = b, a

print(a)  # Affiche 20
print(b)  # Affiche 10

Il est aussi possible d'utiliser l'étoile `*` pour récupérer une partie du tuple dans une liste (opération appelée "extended unpacking") :

nombres = (1, 2, 3, 4, 5)
premier, *reste, dernier = nombres

print(premier) # 1
print(reste)   # [2, 3, 4]
print(dernier)  # 5

Le tuple unpacking fonctionne également avec les listes (et plus généralement, avec n'importe quel itérable).

Méthodes et opérations sur les tuples

Comme les tuples sont immuables, ils offrent moins de méthodes que les listes. Les principales méthodes disponibles sont :

• `count(element)` : Retourne le nombre d'occurrences d'un élément dans le tuple.
• `index(element, start=0, end=len(tuple))` : Retourne l'indice de la première occurrence d'un élément dans le tuple (entre `start` et `end` optionnels).

Exemples :

mon_tuple = (1, 2, 2, 3, 2, 4)

print(mon_tuple.count(2))   # 3
print(mon_tuple.index(3))   # 3

Vous pouvez utiliser l'opérateur `+` pour concaténer des tuples (cela crée un nouveau tuple) :

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
tuple3 = tuple1 + tuple2
print(tuple3)  # (1, 2, 3, 4, 5, 6)

Vous pouvez utiliser l'opérateur `*` pour répéter un tuple (cela crée également un nouveau tuple) :

mon_tuple = (1, 2)
print(mon_tuple * 3) # (1, 2, 1, 2, 1, 2)

Vous pouvez vérifier si un élément est présent dans un tuple avec l'opérateur `in` :

mon_tuple = (1, 2, 3)
print(2 in mon_tuple) # True