3.2. Tuples

Un tuple est tout à fait similaire à une liste : il s’agit d’une collection d’objets [1] . On crée un tuple en séparant les objets par des des virgules , et en les encadrant éventuellement par des parenthèses (...).

In [1]: type((1,2,3))
Out[1]: tuple

In [2]: a = 1,2,3

In [3]: type(a)
Out[3]: tuple

Quand faut-il encadrer un tuple avec des parenthèses ? Par exemple si l’on crée une liste dont certains arguments sont des tuples.

In [4]: [(1, 2), (3, 4)]
Out[4]: [(1, 2), (3, 4)]

In [5]: [1, 2, 3, 4]
Out[5]: [1, 2, 3, 4]

In [6]: [(1, 2), (3, 4)] == [1, 2, 3, 4]
Out[6]: False

Ou bien quand on on apelle une fonction dont un ou plusieurs arguments sont des tuples.

f((1, 2), (3, 4))   # fonction de deux arguments (deux tuples)
f(1, 2, 3, 4)       # fonction de quatre arguments (quatre entiers)

Les opérateurs + et += fonctionnent comme pour les listes.

In [7]: (1,2) + (3,4)
Out[7]: (1, 2, 3, 4)

In [8]: a = (1,2)

In [9]: a += (3,4)

In [10]: a
Out[10]: (1, 2, 3, 4)

On peut accéder aux éléments d’un tuple de la même manière qu’on accède aux éléments d’une liste.

In [11]: a = (1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e', 6, 'f')

In [12]: a[3]
Out[12]: 'b'

In [13]: a[2:]
Out[13]: (2, 'b', 3, 'c', 4, 'd', 5, 'e', 6, 'f')

In [14]: a[:5]
Out[14]: (1, 'a', 2, 'b', 3)

In [15]: a[-3]
Out[15]: 'e'

In [16]: a[2:9:2]
Out[16]: (2, 3, 4, 5)

In [17]: a[8:1:-3]
Out[17]: (5, 'c', 2)

Par contre, on ne peut pas modifier un tuple : on ne peut ni modifier ses éléments, ni en ajouter, ni en enlever.

In [18]: s = (1, 2, 3)

In [19]: s[0] = 4
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[19], line 1
----> 1 s[0] = 4

TypeError: 'tuple' object does not support item assignment

A nouveau, la fonction len renvoie la longueur d’un tuple.

In [20]: len((1.23, 'abc', 45))
Out[20]: 3

Affectations multiples

Les tuples permettent d’affecter des valeurs à plusieurs variables en même temps [2].

In [21]: a, b, c = 1, 2, 3

In [22]: a
Out[22]: 1

In [23]: b
Out[23]: 2

In [24]: c
Out[24]: 3

Cela permet notamment d’échanger élégamment les valeurs de deux variables [3].

In [25]: a, b = 1, 2

In [26]: a
Out[26]: 1

In [27]: b
Out[27]: 2

In [28]: a, b = b, a

In [29]: a
Out[29]: 2

In [30]: b
Out[30]: 1

Notes

[1]

Il s’agit exactement de la notion de uplet en mathématiques. L’appellation tuple provient en fait de l’anglais. En effet, en anglais, on parle de « quadruple », « quintuple », etc.. et plus généralement de \(n\)-tuple tandis qu’en français, on emploie les termes « quadruplet », « quintuplet », etc.. et de manière générale \(n\)-uplet. Néanmoins, la terminologie anglo-saxonne s’est imposée en ce qui concerne Python.

[2]

On peut également procéder à des affectations multiples à l’aide de listes.

In [31]: [a, b, c] = [1, 2, 3]

In [32]: a
Out[32]: 1

In [33]: b
Out[33]: 2

In [34]: c
Out[34]: 3

[3]

A nouveau, on peut également utiliser des listes pour échanger les valeurs de deux variables.

In [35]: [a, b] = [1, 2]

In [36]: a
Out[36]: 1

In [37]: b
Out[37]: 2

In [38]: [a, b] = [b, a]

In [39]: a
Out[39]: 2

In [40]: b
Out[40]: 1