T-uplet en Python☘

Un t-uplet est une séquence immuable d'éléments. On retrouve avec les objets de type tuple une grande partie des propriétés communes aux séquences d'éléments en Python (chaînes et tableaux).

Convention

Comme pour les tableaux, on veillera à ce que tous les éléments contenus dans le tuple soient de même type.

Définir un tuple directement☘

On définit un tuple de façon directe en écrivant son contenu entre parenthèses :

>>> a = (2, 3, 4)

>>> a
(2, 3, 4)

Cas particuliers

Pour définir un tuple vide, on peut uniquement affecter un couple de parenthèses :
```
>>> a = ()

>>> a
()

>>> type(a)
<class 'tuple'>
```
Pour éviter les confusions, il est aussi possible de forcer le typage grâce à la fonction tuple() :
```
>>> a = tuple()

>>> a
()

>>> type(a)
<class 'tuple'>
```
Pour définir un tuple ne contenant qu'un seul élément (simplet), il faut faire suivre cet élément par une virgule dans les parenthèses :
```
>>> a = (2,)

>>> a
(2,)

>>> type(a)
<class 'tuple'>

>>> b = (2)

>>> b
2

>>> type(b)
<class 'int'>
```

Nombre d'éléments☘

La longueur d'un tuple est le nombre d'éléments de ce tuple.
On l'obtient avec la fonction len().

>>> a = (2, 3)

>>> len(a)
2

>>> b = (3.0, 4.1, 5.2)

>>> len(b)
3

Numérotation des éléments☘

Les éléments d'un tuple sont indexés (numérotés) de 0 jusqu'à longueur(tuple)-1.

>>> a = (3, 8)

>>> a[0]
3

>>> a[1]
8

>>> b = (2, 3, 4, 5, 6, 7)

>>> b[0]
2

>>> b[len(b)-1]
7

Attention

Comme pour les tableaux ou les chaînes de caractères, on accède à un élément en écrivant son indice entre crochets.

Pythonnerie

On peut aussi faire référence :

au dernier élément d'un tuple avec l'indice -1,
à l'avant dernier élément avec l'indice -2,
etc...

>>> b = (2, 3, 4, 5, 6, 7)

>>> b[-1]
7

>>> b[-2]
6

>>> b[-6]
2

On retiendra que b[-1] est une abréviation de b[len(b)-1] et, de façon plus générale, b[len(b)-i] = b[-i] pour tout entier i compris entre 1 et len(b).

Exemple☘

On définit le tuple a = (2, 4, 8, 16, 32, 64).

Quelle est la valeur de a[5]?
Quelle est la valeur de len(a)?
Quelle est la valeur de a[len(a)]?
Quelle est la valeur de a[len(a)-1]?

Réponses

a[5] désigne l'élément d'indice 5 du tuple donc a[5] = 64.
len(a) est la longueur du tuple, c'est-à-dire son nombre d'éléments, soit 6.

Aucune.
L'élément d'indice len(a) n'existe pas (le dernier indice est len(a)-1). L'instruction a[len(a)] conduit à une erreur out of range.

>>> a[len(a)]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range

a[len(a)-1] est le dernier élément de la liste, donc a[len(a)-1] = 64.

Immuabilité☘

Comme les chaînes de caractères, un t-uplet est immuable : une fois qu’il est défini, il n’est plus possible de le modifier.

Exemple

Essayons de redéfinir l'élément d'indice 2 par une affectation :

>>> a = (2, 3, 4)

>>> a
(2, 3, 4)

>>> a[2] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

On obtient une erreur qui indique qu'il n'est pas possible de modifier la valeur d'un élément contenu dans un tuple ('tuple' object does not support item assignment).

Concaténation☘

On peut construire un nouveau t-uplet par concaténation (ajouter bout à bout) de t-uplets déjà définis en utilisant l'opérateur d'addition « + ».

>>> a = ("bonjour", "tout")

>>> b = ("le", "monde")

>>> c = a + b

>>> c
('bonjour', 'tout', 'le', 'monde')

Comme avec les chaînes de caractères, l'affectation d'une expression concaténée permet de construire un nouvel objet de type tuple.

Exemple

>>> a = (3, 1)

>>> a =  a + (4, 5)

>>> a
(3, 1, 4, 5)

Les instructions ci-dessus ne modifient pas le tuple initial (3, 1).

Explications :

Ligne 1 :
- On construit d'abord l'objet (3, 1).
- Puis on attribue l'étiquette a à cet objet (une affectation se lit toujours de droite à gauche : on construit l'objet qui se trouve à droite, puis on lui attribue l'étiquette qui se trouve à gauche).
Ligne 3 :
- On concatène les tuples (3, 1) et (4, 5), ce qui crée le nouvel objet (3, 1, 4, 5).
- Puis on lui attribue l'étiquette a (on la décolle de (3, 1) pour la coller sur (3, 1, 4, 5)).

Vérification

Nous avons déjà vu qu'en Python, chaque objet a un identifiant (que l'on peut voir comme son emplacement en mémoire). Cet identifiant se visualise grâce à la fonction id() :

>>> a = (3, 1)

>>> id(a)
140491492586824

>>> a = a + (4, 5)

>>> id(a)
140491492598072

L'instruction id(a) renvoie l'identifiant de l'objet étiqueté a : on peut constater que a ne désigne pas le même objet en ligne 3 et en ligne 8 (l'objet étiqueté n'est pas stocké au même emplacement mémoire en machine).