{{tag>dev python}}

====== Python: le type tuple =====


le **tuple** (traduit couple ou n-uplets) est un type builtin très proche de la liste mais **immuable**: c'est une séquence, on peut donc y appliquer les opérations telles que:

  * Accéder aux éléments avec l’opérateur d'indexation **[]** ;
  * Le test d'appartenance avec **in** ;
  * Faire du slicing etc

La différence fondamentale entre la liste et le tuple est que le tuple est un objet **immuable**: une fois l'objet créé en mémoire il ne sera pas modifié.

<note>
Il est important d'appréhender les spécificités et les comportements du tuple car il participe à certains mécanismes importants dans python (clés de dictionnaires et tuple unpacking notamment).
</note>

Un tuple est généralement défini par une paire de parenthèses contenant les éléments séparés par des virgules. Comme une liste, un tuple peut contenir des éléments de types différents.

<code python>
>>> (1, 2, 3)
(1, 2, 3)

>>> ('a', 'b', 'c')
('a', 'b', 'c')

>>> (42, '!')
(42, '!')
</code>

On notera tout de même que les parenthèses sont facultatives, c’est la virgule qui définit réellement un tuple. Comme pour les opérations arithmétiques, les parenthèses servent en fait à gérer les priorités et mettre en valeur le tuple.

<code python>
>>> 1, 2, 3
(1, 2, 3)

>>> 1, 2, 3 * 3
(1, 2, 9)

>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
</code>


Attention à la syntaxe lors de la création d'un tuple contenant un seul élément. Il doit bien être obligatoirement suivi par la virgule afin que l’interpréteur ne considère pas
les parenthèse comme un groupement d'opérations c'est à dire un changement de priorité mais bien comme la création d'un objet de type tuple:           

<code python>
>>> # Ces instructions NE créent PAS de tuple!
>>> t1 = (3)
>>> type(t1)                                                                                    
int

>>> t2 = ('4')
>>> type(t2) 
str

# Alors que celles-ci OUI
>>> t1 = (3,)
>>> type(t1)
tuple

>>> t2 = '4',
>>> type(t2)
tuple
</code>

<note warning>
Comme montré ci-dessus, pour un tuple singleton, c'est à dire un tuple d'un seul élément il ne faut pas oublier de placer la virgule.
</note>

Par ailleurs, il est possible de définir un tuple vide à l’aide d’une simple paire de parenthèses (il n’y a dans ce cas pas de confusion avec d’autres utilisations possibles des parenthèses).

<code python>
>>> tp = ()

>>> type(tp)
<class 'tuple'>
</code>

Pour cette raison, pour lever toute ambiguïté et se conformer aux recommandations, il vaut mieux toujours terminer les lignes de définitions des tuples et listes par une virgule et répartir les éléments sur plusieurs lignes n’excédant pas 79 caractères.

Ci-dessous un exemple de définition conforme:
<code python>
t1 = ( 1, 2, 3, 
       4, 5, 6, 
     )
</code> 

===== Ordonnancement =====

Les tuples sont ordonnables les uns par rapport aux autres, de la même manière que les listes.

<code python>
>>> (1, 2, 3) < (1, 2, 4)
True

>>> (1, 2, 3) <= (1, 2, 2)
False
</code>

Les fonctions **''len''**, **''min''**, **''max''**, **''all''**, **''any''** etc. sont aussi applicables aux tuples.

<code python>
>>> len(values)
3

>>> min(values)
4

>>> max(values)
6

>>> all((True, True, False))
False

>>> any((True, True, False))
True
</code>

===== Conversion de types =====

On peut facilement passer d'un tuple à une liste grace à la fonction built-in list() qui renvoie une référence à une liste à partir d'un objet de type tuple:
<code python>
>>> t2 = 'un', 2, 3.0, '4', 5
>>> type(t2)
tuple

>>> l2 = list(t2)
>>> l2
['un', 2, 3.0, '4', 5]
</code>

On peut par exemple opérer sur la liste puis créer à nouveau un tuple avec la fonction built-in tuple():

<code python>
>>> l2[0] = 1
>>> t2 = tuple(l2)

>>> type(t2)
tuple

>>> t2
(1, 2, 3.0, '4', 5)
</code>

Le tuple étant immuable, on a bien créé une liste à partir du tuple, modifié la liste puis créer un nouvel objet tuple.


===== Cas d'usage du tuple =====

On peut parfois se demander quand utiliser un tuple et quand utiliser une liste. Le tuple étant comparable à une liste non modifiable, il peut donc être utilisé pour toutes les opérations attendant une liste et ne cherchant pas à la modifier. Il est même préférable de l’utiliser si l’on sait qu’il ne sera jamais question de modification, ou si l’on veut empêcher toute modification.

Mais il y a aussi des opérations qui ne sont possibles qu’avec les tuples. **Étant non modifiables, ils peuvent être utilisés en tant que clés de dictionnaires**.

<code python>
>>> worldmap = {(0, 0): 'x', (0, 1): '.', (1, 0): '.', (1, 1): 'x'}
>>> worldmap[(1, 0)]
'.'

>>> worldmap[(1, 1)] = ' '
>>> worldmap
{(0, 0): 'x', (0, 1): '.', (1, 0): '.', (1, 1): ' '}


>>> # Les parenthèses sont encore une fois facultatives lors des accès.
>>> worldmap[0, 0]
'x'
</code>

Cette structure permet ainsi de représenter d’une grille de données où chaque case est associée à ses coordonnées.

Si un tuple contient une liste, rien n’empêche d’ajouter des éléments à cette liste.

<code python>
>>> events = ('29/05/2019', ['anniversaire', 'soirée'])
>>> events[1].append('rdv coiffeur')
>>> events
('29/05/2019', ['anniversaire', 'soirée', 'rdv coiffeur'])
</code>

**Un tel tuple ne pourra donc pas être utilisé comme clé de dictionnaire**, parce qu’il contient une liste qui ne peut pas être utilisée comme tel.

<code python>
>>> {events: None}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
</code>

Mais beaucoup d’utilisations des tuples sont tous simplement implicites. C’est en effet une manière de faire des assignations multiples de variables.

<code python>
>>> a, b = 1, 2
>>> a
1

>>> b
2
</code>

Techniquement, cela revient à écrire (a, b) = (1, 2), ou encore :
<code python>
>>> tmp = (1, 2)
>>> (a, b) = tmp
</code>


===== tuple unpacking =====

Le tuple unpacking est une opération largement utilisée en python. C'est une affectation entre les éléments d'un tuple et d'un objet quelconque de type séquence:

(a, b) = [12, 33]

Après exécution de l'instruction ci-dessus, la variable a référencera la valeur entière 12 et la variable b la valeur entière 33.

Comme les parenthèses sont facultatives on peut réécrire l'instruction précédente comme suit:
<code python>
a, b = [12, 33]
</code>

Pour que l'unpacking puisse se faire, le nombre d’éléments dans le tuple doit correspondre au nombre d'éléments de la séquence. Le code ci-dessous lève une exception:

<code python>
>>> a, b, c = ['un', 'deux', 'trois', 'quatre']                                                 
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-48-ed7192e8ea5b> in <module>
----> 1 a, b, c = ['un', 'deux', 'trois', 'quatre']

ValueError: too many values to unpack (expected 3)
</code>

Le tuple unpacking rend le code produit plus concis et le rapproche du langage naturel que la manipulation d'indices facilitant ainsi la maintenance. C'est ce mécanisme qui est aussi à l’œuvre dans l'expression ci-dessous:
<code python>
>>> l1 = [ 1, 2, 3.0,
        'quatre', True, 
      ]
      
>>> for index,value in enumerate(l1): 
        print(f"{index:2d} = {value}")
</code>

Dans l'exemple ci-dessus, à chaque tour de boucle, la fonction enumerate() retourne une séquence de 2 éléments affectés aux variables index et values grâce au mécanisme de tuple unpacking.

L'unpacking fonctionne également avec les listes:
<code python>
liste = [1, 2, 3]
[gauche, milieu, droit] = liste
print('élément gauche', gauche, 'élément central', milieu, ' élément droit', droit)
</code>

Pour que l'unpacking fonctionne il faut:
  * Que le terme à droite du signe '=' soit un itérable,
  * Que le terme à gauche du signe '=' soit un tuple ou une liste
  * les deux termes aient la même longueur ou utilisent la notation *arg voir section extend unpacking.


Une propriété amusante de l'unpacking de tuples est qu’elle permet facilement d’échanger les valeurs de deux variables. En effet, il suffit de construire un tuple avec les valeurs des deux variables puis de le déconstruire vers ces deux mêmes variables en les inversant.

<code python>
>>> a = 3
>>> b = 5

>>> a, b = b, a

>>> a
5

>>> b
3
</code>


===== Extended tuple unpacking =====

C'est un manière simple d' isoler des éléments dans une séquence:
<code python>
>>> l1 = list(range(10))
 
>>> x, *y = l1

>>> x
0

>>> y
[1, 2, 3, 4, 5, 6, 7, 8, 9]
</code>

===== Addition de tuples =====

Le tuple est immuable mais il est tout a fait possible de faire des opérations comme l'addition sur des tuples. L'opération aboutit sur la création d'un nouveau tuple:

<code python>
>>> t1 = (1,2,3)

>>> id(t1)
140325857254400

>>> t1 += (4, 5, 6)

>>> t1
 (1, 2, 3, 4, 5, 6)

>>> id(t1)
140325853457664
</code>
On voit bien ici que la variable t1 ne référence plus le même objet en mémoire après l'opération d'addition.

===== Références =====

  * [[https://zestedesavoir.com/tutoriels/2514/un-zeste-de-python/4-types/4-tuples/|Tutoriel un zeste de Python - Les tuples]]