2.8. Tuples

Un tuple est une séquence ordonnée et immuable de valeurs. Une fois créé, les éléments qu’il contient ne peuvent être ni ajoutés, ni supprimés, ni modifiés.

2.8.1. Créer des tuples

Utilisez des parenthèses (ou simplement des virgules) pour créer un tuple :

empty   = ()
point   = (3, 4)
triple  = 1, 2, 3                # parentheses are optional
mixed   = (1, "two", 3.14)
nested  = ((1, 2), (3, 4))

2.8.1.1. Le piège de l’élément unique

Des parenthèses autour d’une valeur ne sont que des parenthèses ; ce qui fait réellement un tuple, c’est la virgule. Un tuple à un seul élément nécessite une virgule finale :

>>> (1)
1                                # just an int in parens
>>> (1,)
(1,)                             # a one-element tuple
>>> type((1)), type((1,))
(<class 'int'>, <class 'tuple'>)

2.8.2. Longueur, indexation et découpage

Comme pour les listes et les chaînes de caractères – len(), l’indexation, le découpage, in et + / * fonctionnent tous de la même manière :

>>> point = (3, 4, 5)
>>> len(point)
3
>>> point[0]
3
>>> point[1:]
(4, 5)
>>> 4 in point
True
>>> (1, 2) + (3, 4)
(1, 2, 3, 4)

2.8.3. Immuabilité

Les tuples n’ont pas de append, pop, sort, ni aucune autre méthode opérant sur place. L’affectation indexée déclenche une TypeError :

>>> point = (3, 4)
>>> point[0] = 99
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item assignment

Pour « modifier » un tuple, construisez-en un nouveau avec les valeurs modifiées.

2.8.4. Dépaquetage

Le principal super-pouvoir d’un tuple est le dépaquetage : affecter chaque élément à une variable distincte en une seule instruction.

Le dépaquetage lie chaque élément d’un tuple à une variable nommée en une seule affectation.

>>> point = (3, 4)
>>> x, y = point
>>> x
3
>>> y
4

La partie droite peut être n’importe quel itérable – une liste, une chaîne de caractères, la valeur de retour d’une fonction :

>>> a, b, c = "abc"
>>> a, b, c
('a', 'b', 'c')

Un * en tête collecte « le reste » d’un dépaquetage dans une liste :

>>> first, *rest = [10, 20, 30, 40]
>>> first
10
>>> rest
[20, 30, 40]

2.8.5. Valeurs de retour multiples

Une fonction peut renvoyer un tuple pour livrer plusieurs valeurs à la fois ; l’appelant les dépaquette à la réception :

def size_of(rect):
    return (rect[2] - rect[0], rect[3] - rect[1])

width, height = size_of((10, 20, 110, 140))
# width = 100, height = 120

Les parenthèses du return sont optionnelles – un simple return a, b est aussi un tuple.

2.8.6. Tuple ou liste

Un guide pratique pour savoir lequel choisir :

• Tuple pour des données de forme fixe, souvent hétérogènes : des points (x, y), des couleurs (r, g, b), des valeurs de retour multiples, des arguments de fonction empaquetés pour un usage ultérieur.

• Liste pour des données de longueur variable, souvent homogènes : une liste de mesures, une file d’éléments à traiter, tout ce auquel vous prévoyez d’ajouter des éléments.

Les tuples sont aussi hachables (tant que chaque élément qu’ils contiennent est hachable), de sorte qu’ils peuvent servir de clés dans un dict.