Les tuples en Python

Les Tuples

Python propose plusieurs structures de données (listes, dictionnaires, ensembles…). Parmi elles, les tuples sont souvent méconnus, alors qu'ils jouent un rôle essentiel dans la programmation de qualité.

Création d'un tuple

t1 = (1, 2, 3)          # syntaxe standard avec parenthèses
t2 = 1, 2, 3            # syntaxe sans parenthèses (packing)
t3 = (5,)               # tuple à UN seul élément — la virgule est obligatoire !
t4 = ()                 # tuple vide
t5 = tuple([1, 2, 3])   # conversion liste → tuple

a = (5)    # ❌ int, pas un tuple → type(a) = <class 'int'>
b = (5,)   # ✅ tuple → type(b) = <class 'tuple'>

print(type(a))   # <class 'int'>
print(type(b))   # <class 'tuple'>

Exemple n°1 — Différentes formes de tuples

t1 = ("Python", 3.14, True)       # tuple hétérogène
t2 = tuple([1, 2, 3])              # conversion liste → tuple
t3 = (1, (2, 3), (4, (5, 6)))     # tuple imbriqué

print(t1)
print(t2)
print(t3)
print(f"Type de t1 : {type(t1)}")
print(f"Longueur   : {len(t1)}")

('Python', 3.14, True)
(1, 2, 3)
(1, (2, 3), (4, (5, 6)))
Type de t1 : <class 'tuple'>
Longueur   : 3

Accès aux éléments

L'accès aux éléments d'un tuple fonctionne exactement comme pour les listes : indexation positive, négative et slicing.

Exemple n°2 — Indexation et slicing

t = (10, 20, 30, 40, 50)

print(t[0])     # 10  — premier élément
print(t[2])     # 30  — troisième élément
print(t[-1])    # 50  — dernier élément
print(t[-2])    # 40  — avant-dernier
print(t[1:4])   # (20, 30, 40) — slicing
print(t[:3])    # (10, 20, 30) — du début à l'index 3 exclu
print(t[::2])   # (10, 30, 50) — un élément sur deux

10
30
50
40
(20, 30, 40)
(10, 20, 30)
(10, 30, 50)

t = (10, 20, 30)
t[0] = 99      # ❌ TypeError: 'tuple' object does not support item assignment
t.append(40)   # ❌ AttributeError: 'tuple' object has no attribute 'append'

Fonctions et méthodes utiles

Bien qu'immuables, les tuples supportent toutes les opérations de lecture des séquences Python.

Exemple n°3 — Fonctions sur un tuple

notes = (14, 18, 12, 16, 18, 10)

print(f"Nombre    : {len(notes)}")
print(f"Somme     : {sum(notes)}")
print(f"Maximum   : {max(notes)}")
print(f"Minimum   : {min(notes)}")
print(f"Moyenne   : {sum(notes)/len(notes):.2f}")
print(f"Nb de 18  : {notes.count(18)}")
print(f"Index 16  : {notes.index(16)}")

Nombre    : 6
Somme     : 88
Maximum   : 18
Minimum   : 10
Moyenne   : 14.67
Nb de 18  : 2
Index 16  : 3

Opérations sur les tuples

t3 = t1 + t2      # Concaténation → nouveau tuple
t4 = t1 * 3       # Répétition → nouveau tuple
x in t            # Test d'appartenance → True / False
x not in t        # Test d'absence → True / False

Exemple n°4 — Opérations courantes

t1 = (1, 2, 3)
t2 = (4, 5, 6)

# Concaténation
t3 = t1 + t2
print(f"t1 + t2  = {t3}")

# Répétition
t4 = t1 * 3
print(f"t1 * 3   = {t4}")

# Test d'appartenance
print(f"3 in t1  = {3 in t1}")
print(f"9 in t1  = {9 in t1}")

# Parcours
for val in t1:
    print(val, end="  ")

t1 + t2  = (1, 2, 3, 4, 5, 6)
t1 * 3   = (1, 2, 3, 1, 2, 3, 1, 2, 3)
3 in t1  = True
9 in t1  = False
1  2  3

t = (1, 2, 3)
t = t + (4,)   # ✅ crée un nouveau tuple (1, 2, 3, 4)
               # l'ancien tuple (1, 2, 3) est abandonné

Tuples et fonctions

L'un des usages les plus importants des tuples est le retour multiple de valeurs par une fonction. Python emballe automatiquement les valeurs retournées dans un tuple.

Exemple n°5 — Retour multiple avec un tuple

def min_max(L):
    """Retourne le minimum et le maximum d'une liste."""
    return min(L), max(L)   # retourne un tuple implicitement

# Déballage (unpacking)
m, M = min_max([4, 2, 7, 1, 9, 3])
print(f"Minimum : {m}")
print(f"Maximum : {M}")

Minimum : 1
Maximum : 9

Exemple n°6 — Tuple unpacking (déballage)

# Déballage simple
point = (3, 7)
x, y = point
print(f"x = {x}, y = {y}")

# Déballage avec * (reste)
premiers = (2, 3, 5, 7, 11, 13)
p1, p2, *reste = premiers
print(f"Deux premiers : {p1}, {p2}")
print(f"Reste         : {reste}")

# Échange de variables via tuple
a, b = 10, 20
a, b = b, a
print(f"Après échange : a={a}, b={b}")

x = 3, y = 7
Deux premiers : 2, 3
Reste         : [5, 7, 11, 13]
Après échange : a=20, b=10

Exemple n°7 — Tuple comme clé de dictionnaire

# Les tuples peuvent servir de clés de dictionnaire
distances = {
    ("Meknès",  "Rabat")      : 138,
    ("Meknès",  "Casablanca") : 220,
    ("Meknès",  "Marrakech")  : 354,
}

ville1, ville2 = "Meknès", "Rabat"
print(f"Distance {ville1} → {ville2} : {distances[(ville1, ville2)]} km")

Distance Meknès → Rabat : 138 km

Listes vs Tuples