le tuple est un type built-in très proche de la liste: c'est une séquence, on peut donc y appliquer les opérations telles que:

• le test d'appartenance avec in,
• accéder aux éléments avec [],
• 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é.

Pour créer un objet de type tuple on utilise les parenthèses:

>>> t1 = ()
 
>>> type(t1)
tuple

Ci-dessus instanciation d'un tuple vide.

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:

# 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

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:

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

Une autre caractéristique importante pour la définition d'un tuple est que les parenthèses sont facultatives:

# un tuple
>>> t1 = (1, 2, 'trois', '4', 5.0)
>>> type(t1)
tuple
 
# cette instruction définie également un tuple:
>>> t2 = 'un', 2, 3.0, '4', 5 
>>> type(t2)
tuple

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:

>>> t2 = 'un', 2, 3.0, '4', 5
>>> type(t2)
tuple
 
>>> l2 = list(t2)
>>> l2
['un', 2, 3.0, '4', 5]

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

>>> l2[0] = 1
>>> t2 = tuple(l2)
 
>>> type(t2)
tuple
 
>>> t2
(1, 2, 3.0, '4', 5)

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

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:

a, b = [12, 33]

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:

>>> 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)

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:

>>> l1 = [ 1, 2, 3.0,
        'quatre', True, 
      ]
 
>>> for index,value in enumerate(l1): 
        print(f"{index:2d} = {value}")

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:

liste = [1, 2, 3]
[gauche, milieu, droit] = liste
print('élément gauche', gauche, 'élément central', milieu, ' élément droit', droit)

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.

C'est un manière simple d' isoler des éléments dans une séquence:

>>> l1 = list(range(10))
 
>>> x, *y = l1
 
>>> x
0
 
>>> y
[1, 2, 3, 4, 5, 6, 7, 8, 9]

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:

>>> t1 = (1,2,3)
 
>>> id(t1)
140325857254400
 
>>> t1 += (4, 5, 6)
 
>>> t1
 (1, 2, 3, 4, 5, 6)
 
>>> id(t1)
140325853457664

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.