Tuples et p-uplets nommés

Introduction

En mathématiques, un p-uplet est une collection ordonnée et finie de $p$ valeurs : un couple $(x, y)$ est un 2-uplet, un triplet $(x, y, z)$ un 3-uplet, et plus généralement $(a_1, a_2, \dots, a_p)$ un $p$-uplet.

Python propose ce même outil sous le nom de tuple. C'est, comme la liste, une séquence ordonnée indexée par entiers — à une différence cruciale près : un tuple est non modifiable (on dit immuable ou immutable). Voir [PC02].

Créer un tuple

Un tuple s'écrit avec des parenthèses, les valeurs séparées par des virgules.

point = (3, 5)
print(point)         # (3, 5)
print(type(point))   # <class 'tuple'>
print(len(point))    # 2

L'accès à un élément se fait exactement comme pour une liste, avec des crochets et un index entier commençant à 0 :

point = (3, 5)
print(point[0])     # 3
print(point[1])     # 5

La différence clé : immutabilité

Contrairement à une liste, un tuple ne peut pas être modifié après création. Toute tentative d'affectation lève une erreur.

point = (3, 5)
point[0] = 10
# TypeError: 'tuple' object does not support item assignment

Usage canonique : renvoyer plusieurs valeurs

Un tuple permet à une fonction de renvoyer plusieurs valeurs liées, et à l'appelant de les récupérer en une seule affectation appelée affectation multiple (ou déballage, unpacking).

def division_euclidienne(a, b):
    """Renvoie le quotient et le reste de a par b."""
    return (a // b, a % b)

q, r = division_euclidienne(17, 5)
print(q, r)
# Sortie : 3 2

Les parenthèses sont si naturelles ici qu'on peut même les omettre :

return a // b, a % b   # exactement équivalent à return (a // b, a % b)

P-uplets nommés — namedtuple

Un tuple ordinaire a un inconvénient : ses champs n'ont pas de nom. Si p = (48.85, 2.35), l'élève qui relit le code doit deviner que p[0] est la latitude et p[1] la longitude.

La bibliothèque standard collections fournit un outil pour donner un nom à chaque champ : namedtuple. Le résultat reste un tuple — donc immuable — mais on accède aux champs par leur nom.

from collections import namedtuple

# 1. On définit le type : un Point a deux champs nommés x et y
Point = namedtuple("Point", ["x", "y"])

# 2. On crée des valeurs de ce type
p = Point(3, 5)
q = Point(x=10, y=12)

# 3. On lit les champs par leur nom — plus parlant que p[0]
print(p.x, p.y)      # 3 5
print(q.x, q.y)      # 10 12

# Les opérations habituelles d'un tuple restent valables
print(len(p))        # 2
print(p[0])          # 3 — l'accès par index marche aussi

Comparaison rapide

# Tuple ordinaire — concis mais opaque
p = (48.85, 2.35)
print(p[0])           # 48.85 — quelle grandeur est-ce ?

# P-uplet nommé — explicite
Coord = namedtuple("Coord", ["latitude", "longitude"])
paris = Coord(48.85, 2.35)
print(paris.latitude) # 48.85 — aucun doute possible

Pièges courants

• Le tuple à un seul élément : (42) n'est pas un tuple, c'est juste l'entier 42 entre parenthèses. Pour faire un tuple à un élément, il faut une virgule : (42,).
• Vouloir modifier un tuple : si vous en avez besoin, c'est probablement une liste qu'il fallait choisir.
• Confondre [ ] et ( ) : crochets = liste (modifiable), parenthèses = tuple (figé). Le sens du code change avec le délimiteur.

Vérification de compréhension