Les tuples Python : guide complet

Un tuple est une séquence ordonnée et immuable en Python. Il peut contenir des éléments de tout type — entiers, chaînes de caractères, flottants, autres tuples — et ces éléments conservent leur position de manière permanente après la création du tuple. Cette page couvre tout ce dont vous avez besoin pour travailler avec les tuples : comment les créer, les lire, les combiner, et savoir quand les préférer à une liste Python.

Qu'est-ce qu'un tuple Python ?

Un tuple s'écrit sous la forme d'une séquence de valeurs séparées par des virgules, entourée de parenthèses :

Trois propriétés clés définissent les tuples :

• Ordonné — les éléments ont une position fixe (index 0, 1, 2, …).
• Immuable — vous ne pouvez pas modifier, ajouter ou supprimer des éléments après la création.
• Autorise les doublons — la même valeur peut apparaître plusieurs fois.

Tuples vs. listes

Les tuples et les listes stockent tous deux des séquences ordonnées, mais leur mutabilité diffère fondamentalement :

Utilisez un tuple lorsque les données ne doivent pas changer — constantes de configuration, valeurs de retour de fonctions portant plusieurs données liées, ou clés de dictionnaire.

Créer des tuples

Syntaxe de base

Listez des valeurs séparées par des virgules entre parenthèses :

Types mixtes

Un tuple peut contenir des éléments de types différents, y compris d'autres tuples :

mixed = (1, 'hello', 3.14, True)
print(mixed)
# Output: (1, 'hello', 3.14, True)

Tuple vide

empty = ()
print(empty)        # Output: ()
print(type(empty))  # Output: <class 'tuple'>

Tuple à un seul élément

C'est un piège courant. Sans la virgule finale, Python interprète les parenthèses comme un groupement, pas comme un tuple :

not_a_tuple = (42)
print(type(not_a_tuple))  # Output: <class 'int'>

real_tuple = (42,)
print(type(real_tuple))   # Output: <class 'tuple'>

La virgule finale en fait un tuple — incluez-la toujours pour les tuples à un seul élément.

Créer à partir d'un itérable

Utilisez le constructeur intégré tuple() pour convertir n'importe quel itérable en tuple :

Tuple sans parenthèses (empaquetage)

Python vous permet de créer un tuple en listant simplement des valeurs séparées par des virgules — les parenthèses sont facultatives :

packed = 1, 2, 3
print(packed)        # Output: (1, 2, 3)
print(type(packed))  # Output: <class 'tuple'>

Accéder aux éléments d'un tuple

Indexation positive

Les indices commencent à 0 pour le premier élément :

Indexation négative

Les indices négatifs comptent à partir de la fin. -1 est le dernier élément :

Découpage

Utilisez [start:stop:step] pour extraire un sous-tuple. L'index stop est exclu :

t = (0, 1, 2, 3, 4)
print(t[1:4])   # Output: (1, 2, 3)
print(t[:3])    # Output: (0, 1, 2)
print(t[2:])    # Output: (2, 3, 4)
print(t[::2])   # Output: (0, 2, 4)

Tuples imbriqués

Accédez aux éléments imbriqués en chaînant les crochets d'index :

nested = ((1, 2), (3, 4), (5, 6))
print(nested[1])     # Output: (3, 4)
print(nested[1][0])  # Output: 3

Vérification d'appartenance

L'opérateur in vérifie si une valeur existe dans un tuple :

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # Output: True
print('mango' in fruits)   # Output: False

Pour plus de techniques d'indexation et de découpage, consultez Accéder aux tuples.

Immuabilité des tuples

Une fois créé, les éléments d'un tuple ne peuvent pas être modifiés :

my_tuple = (1, 2, 3)
my_tuple[0] = 99  # TypeError: 'tuple' object does not support item assignment

Si vous avez besoin d'une version modifiée, construisez un nouveau tuple à partir de découpages et de concaténations :

Notez qu'un tuple peut contenir des objets mutables comme des listes. Le tuple lui-même est immuable (vous ne pouvez pas remplacer la référence à la liste), mais la liste à l'intérieur peut toujours être modifiée.

Consultez Modifier les tuples pour une discussion complète des solutions de contournement.

Opérations sur les tuples

Concaténation avec +

Joindre deux tuples avec + crée un nouveau tuple :

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)
# Output: (1, 2, 3, 4)

Répétition avec *

Répétez le contenu d'un tuple avec * :

t = (0,) * 3
print(t)
# Output: (0, 0, 0)

Pour toutes les stratégies d'assemblage, consultez Joindre des tuples.

Méthodes des tuples

Les tuples disposent exactement de deux méthodes intégrées, car l'immuabilité exclut tout ce qui modifierait la collection.

count()

Retourne le nombre de fois qu'une valeur apparaît :

index()

Retourne l'index de la première occurrence d'une valeur. Lève une ValueError si la valeur n'est pas trouvée :

Consultez Méthodes des tuples pour une référence complète.

Fonctions intégrées avec les tuples

Les fonctions intégrées de Python fonctionnent sur tout itérable, y compris les tuples :

sorted() retourne toujours une liste, même lorsqu'un tuple lui est fourni en entrée. Encapsulez le résultat dans tuple() si vous avez besoin d'un tuple trié en retour.

Décomposition de tuples

La décomposition assigne chaque élément d'un tuple à une variable distincte en une seule instruction :

Décomposition étendue avec *

Une variable préfixée d'un astérisque absorbe n'importe quel nombre d'éléments restants dans une liste :

first, *rest = (10, 20, 30, 40)
print(first)  # Output: 10
print(rest)   # Output: [20, 30, 40]

Permutation de variables

La décomposition de tuples permet de permuter des variables en une seule ligne — sans variable temporaire :

x, y = 5, 10
x, y = y, x
print(x, y)
# Output: 10 5

Consultez Décomposer des tuples pour plus de modèles, y compris la décomposition imbriquée.

Itérer sur un tuple

Une boucle for visite chaque élément dans l'ordre :

fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)
# Output:
# apple
# banana
# cherry

Utilisez enumerate() lorsque vous avez également besoin de l'index :

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output:
# 0 apple
# 1 banana
# 2 cherry

Consultez Boucler sur des tuples pour les boucles while, zip(), et le parcours de tuples imbriqués.

Construire des tuples à partir de compréhensions

Python ne possède pas de syntaxe de compréhension de tuple, mais vous pouvez passer une expression génératrice à tuple() pour obtenir le même résultat :

L'expression x**2 for x in my_list à l'intérieur de tuple() est un générateur — il produit les valeurs une par une sans construire de liste intermédiaire.

Quand utiliser les tuples

Les tuples sont particulièrement adaptés dans ces situations :

• Valeurs de retour multiples. Les fonctions peuvent retourner plusieurs valeurs de façon propre sous forme de tuple : return x, y.
• Clés de dictionnaire. Les listes ne peuvent pas servir de clés de dictionnaire car elles sont mutables ; les tuples le peuvent.
• Intégrité des données. Si une collection ne doit pas changer — valeurs RGB, ligne de base de données, coordonnées géographiques — un tuple l'impose au niveau du langage.
• Légère performance supérieure. L'itération et la création de tuples sont marginalement plus rapides que les opérations équivalentes sur des listes.

# Using a tuple as a dictionary key
locations = {}
locations[(48.8566, 2.3522)] = 'Paris'
locations[(51.5074, -0.1278)] = 'London'
print(locations[(48.8566, 2.3522)])
# Output: Paris

Pratique