[Mise à jour le : 31/1/2022]

• Source
  • Documentation sur Python.org : référence du langage, tuples et séquences, types séquentiels list, tuple, range, fonctions natives (built-in)

• Mots-clés : immuable, unpacking, tuple

• Fonctions natives (built-in)¹⁾ utilisées dans les exemples : list(), print(), range(), tuple().

Le tuple est une séquence. Comme la liste, il référence des objets hétérogènes. On peut lui appliquer le test d'appartenance avec in, accéder aux différents éléments avec un crochet, faire du slicing etc. La raison d'être principale du type tuple est de construire des objets globalement immuables.

Exemple

*.py

# Affectation simple
>>> tp =  "a","b",4 # Création d'un tuple à 3 éléments 
>>> tp = () # Création d'un tuple vide (peu d'intérêt)
>>> tp = 6, # un seul élément nécessite une virgule !!!
 
# Les parenthèses sont obligatoires dès que l'écriture d'un tuple est contenu dans une expression plus longue.
>>> tp = 3,(1,True,4.5,8, "a") # différent types
>>> tp # renvoie (3, (1, True, 4.5, 8, 'a'))
 
# Tuple contenant des tuples
>>> t2d = (1,"a"), (2,"b") # équivalent à (1,"a"),
                           #              (2,"b")
 
# Affectation  multiple = tuple unpacking
>>> a,b,c = 1,2,3 # a=1, b=2, c=3

Les indices permettent d'accéder aux différents éléments d'un tuple. Pour accéder à un élément d'indice i d'un tuple t, la syntaxe est t[i]. L'indice i peut prendre les valeurs entières de 0 à n-1 ou n est la longueur du tuple.

*.py

# Accès à une valeur en lecture
tp = "a",2,8,7,"b"
>>> tp # renvoie ('a', 2, 8, 7, 'b')
>>> len(tp) # renvoie 5
>>> tp[2] # renvoie 8
# i peut être négatif !
>>> tp[-1] # renvoie "b" car on parcourt le tuple en partant de la fin

• Issue d'une concatenation avec +

Exemple

*.py

>>> tuple1 = (1, 2,)
>>> tuple2 = (3, 4,)
>>> print('Resultat:', tuple1 + tuple2) # Résultat: (1, 2, 3, 4)

• Issue d'une concaténation avec *

Exemple

*.py

>>> tuple3 = 3*tuple1 # Renvoie (1,2,1,2,1,2)

• Issue d'une liste

Exemple

*.py

>>> liste = list(range(10)) # résultat[0,1,2,3,4,5,6,7,8,9]
>>> liste[9] = 'Inconnu' # résultat[0,1,2,3,4,5,6,7,8,'Inconnu']
>>> del liste [2:5] # résultat : [0, 1, 5, 6, 7, 8, 'Inconnu']
>>> mon_tuple = tuple(liste) # résultat : (0, 1, 5, 6, 7, 8, 'Inconnu')

Pour tester l'appartenance d'un élément à un tuple, on utilise l'opérateur in.

*.py

>>> t = "a","b","c"
>>> "c" in  t # renvoie True
>>> "d" in  t # renvoie False

Exemple

*.py

>>> tp = "a",2,8,7,"b"
>>> tp # renvoie ('a', 2, 8, 7, 'b')
>>> tp[2] = 3 # Renvoie une erreur car un tuple est immuable
              # Traceback (most recent call last):
              #       File "<stdin>", line 1, in <module>
              #  TypeError: 'tuple' object does not support item assignment
>>> lst = list(tp)
>>> lst # renvoie la liste ['a', 2, 8, 7, 'b']
>>> lst[2] = 3 # modification de la liste
>>> tp = tuple(lst) # conversion en un tuple
>>> tp # renvoie le tuple ('a', 2, 3, 7, 'b')

Les affectations multiples (§2) s'utilisent souvent dans les fonctions renvoyant un tuple.

Exemple : calcul des longueurs des trois côtés d'un triangle.

*.py

from math import sert
 
# Déclaration de la fonction
def longueurs(A,B,C):
    xA,yA = A
    xB,yB = B
    xC,yC = C
    ďAB = sqrt((xB - xA)**2 + (yB- yA)**2)  
    ďBC = sqrt((xC - xB)**2 + (yC- yB)**2)
    ďAC = sqrt((xC - xA)**2 + (yC- yA)**2)
    return dAB,dBC,dAC
 
# Utilisation    
M = (3.4,7.8)
N = (5,1.6)
P = (-3.8,4.3)
dMN, dNP, dMP = longueurs(M,N,P)
dMN # renvoie 6.4031...

Exemple 1

*.py

couple = (100, 'spam')
gauche, droite = couple
print('gauche:', gauche, 'droite:', droite) # résultat gauche: 100 droite: spam

Exemple 2

*.py

# membre droit: une liste
liste = [1, 2, 3]
# membre gauche : un tuple
gauche, milieu, droit = liste
print('gauche:', gauche, 'milieu:', milieu, 'droit:', droit) # gauche: 1 milieu: 2 droit: 3

Exemple 3

*.py

entrees = [(1, 2), (3, 4), (5, 6)]
for a, b in entrees:
    print(f"a={a} b={b}") 
 
'''
a=1 b=2
a=3 b=4
a=5 b=6
'''

Exemple 1

*.py

reference = [1, 2, 3, 4, 5]
a, *b, c = reference
print(f"a={a} b={b} c={c}") # a=1 b=[2, 3, 4] c=5

Cela peut s'avérer pratique, lorsque par exemple on s'intéresse seulement aux premiers éléments d'une structure :

Exemple 2

*.py

# si on sait que data contient prenom, nom, 
# et un nombre inconnu d'autres informations
data = [ 'Jean', 'Dupont', '061234567', '12', 'rue du four', '57000', 'METZ', ]
 
# on peut utiliser la variable _
# ce n'est pas une variable spéciale dans le langage,
# mais cela indique au lecteur que l'on ne va pas s'en servir
prenom, nom, *_ = data
print(f"prenom={prenom} nom={nom}") # résultat : prenom=Jean nom=Dupont

Cette technique n'est utilisée en pratique que pour les parties de la structure dont on n'a que faire dans le contexte. Dans ces cas-là, il arrive qu'on utilise le nom de variable _.

Exemple 3

*.py

entree = [1, 2, 3]
# 
_, milieu, _ = entree
print('milieu', milieu) # résultat : milieu 2
 
ignored, ignored, right = entree
print('right', right)   # résultat :right 3

• Python List and Tuples Quiz

• Write Pythonic and Clean Code With namedtuple