En Python, le tuple est une structure de données appartenant à la catégorie des séquences immuables. À l'inverse des listes, les éléments d'un tuple ne peuvent pas être modifiés, ajoutés ou supprimés après leur création. Cette caractéristique en fait un choix privilégié pour stocker des constantes ou des données qui doivent rester intègres durant l'exécution d'un script.

1. Création de tuples

1.1 Syntaxe avec parenthèses

La méthode la plus courante consiste à utiliser des parenthèses. Il est également possible de définir un tuple par simple énumération de valeurs séparées par des virgules.

# Création standard
coordonnees = (10.5, 20.0, 5.5)

# Création sans parenthèses (packing)
donnees = 100, 200, 300

# Cas particulier : tuple à un seul élément
# La virgule est obligatoire pour différencier le tuple d'une expression entre parenthèses
un_seul = (50,) 
print(type(un_seul))  # <class 'tuple'>

pas_un_tuple = (50)
print(type(pas_un_tuple))  # <class 'int'>

1.2 Utilisation du constructeur tuple()

La fonction tuple() permet de convertir n'importe quel objet itérable (chaîne de caractères, liste, range) en tuple.

# Conversion d'une chaîne
lettres = tuple("ABC") # ('A', 'B', 'C')

# Conversion d'une liste
nombres = tuple([1, 2, 3]) # (1, 2, 3)

# Conversion d'un objet range
sequence = tuple(range(5)) # (0, 1, 2, 3, 4)

2. Accès aux élémants et immuabilité

L'accès aux données d'un tuple s'effectue via des indices, de la même manière que pour les listes. Toutefois, toute tentative de modification directe déclenchera une erreur.

mon_tuple = (10, 20, 30, 40)

# Accès par indice
print(mon_tuple[0])  # 10

# Slicing (découpage)
print(mon_tuple[1:3]) # (20, 30)

# Preuve d'immuabilité
try:
    mon_tuple[1] = 99
except TypeError as e:
    print(f"Erreur : {e}") # 'tuple' object does not support item assignment

3. Opérations et fonctions intégrées

Bien que les tuples soient immuables, ils supportent de nombreuses opérations de lecture et de transformation indirecte :

• len(t) : retourne le nombre d'éléments.
• max(t) et min(t) : retournent respectivement la valeur maximale et minimale.
• sum(t) : calcule la somme des éléments numériques.
• sorted(t) : contrairement à list.sort(), cette fonction retourne une nouvelle liste contenant les éléments triés, sans modifier le tuple d'origine.

valeurs = (15, 5, 25, 10)
valeurs_triees = sorted(valeurs)
print(valeurs_triees) # [5, 10, 15, 25]

4. Agrégation avec zip()

La fonction zip() est souvent utilisée pour fusionner plusieurs itérables en une séquence de tuples.

noms = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

combinaison = zip(noms, scores)
print(list(combinaison)) # [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

5. Expressions génératrices

En utilisant des parenthèses au lieu de crochets pour une compréhension de liste, on crée un générateur. Ce dernier ne stocke pas toutes les données en mémoire immédiatement, mais les produit à la demande.

# Création d'un générateur
gen = (x * x for x in range(5))

print(gen) # <generator object ...>

# Conversion du générateur en tuple
resultat = tuple(gen)
print(resultat) # (0, 1, 4, 9, 16)

# Un générateur est épuisé après lecture
print(tuple(gen)) # ()

6. Avantages des tuples

1. Performance : Le traitement des tuples est plus rapide que celui des listes car leur structure est statique en mémoire.
2. Sécurité : Ils protègent les données contre les modifications accidentelles.
3. Clés de dictionnaire : Contrairement aux listes, les tuples peuvent servir de clés dans un dictionnaire (à condition qu'ils ne contiennent que des objets hashables).