Université Abdelmalek Essadi Master SIM-MBD

Faculté des Sciences et Techniques –Tanger Semestre 1 2021-2022

Département Génie Informatique Module : POO en Python

Mémo sur les tuples - Python

Les tuples sont des séquences, assez semblables aux listes, sauf qu'on ne peut modifier un tuple
après qu'il ait été créé. Cela signifie qu'on définit le contenu d'un tuple (les objets qu'il doit contenir)
lors de sa création, mais qu'on ne peut en ajouter ou en retirer par la suite : Les tuples sont des listes
immuables(non mutable).

A quoi sert les tuples ? Il peut être utile de travailler sur des données sans pouvoir les modifier. Ils
peuvent être utilisés aussi comme clefs dans les dictionnaires.

Un tuple se définit comme une liste, sauf qu'on utilise comme délimiteur des parenthèses au lieu des
crochets.
tuple à 0 élément : >>> t = ( )
tuple à 1 élément : >>> t = ('a',) ou >>> t = 'a', avec la virgule dans les 2 cas !
>>> t = (1,) ou >>> t = 1,
tuple à 2 éléments : >>> t = ('a', 'b') ou >>> t = 'a', 'b'
tuple à 3 éléments : >>> t = (1, 2, 5)
>>> t = ('a', 'b', 2)
>>> type(t)
<class 'tuple'>
>>>
On peut ensuite se référer aux valeurs d'un groupe en utilisant leurs positions (en commençant à
zéro):
>>> p = (10, 15)
>>> p[0] # première valeur
10
>>> p[1] # deuxième valeur
15

Remarque : si on veut créer un tuple contenant un unique élément, on doit quand même mettre une
virgule après celui-ci. Sinon, Python va automatiquement supprimer les parenthèses et on se
retrouvera avec une variable lambda et non une variable contenant un tuple.

Sequence packing et unpacking (emballage,déballage):

sequence packing : >>> t = x, y, z

sequence unpacking : >>> x, y, z = t (t doit avoir 3 éléments)

on peut faire >>> (x, y, z) = (1, 2, 3) pour affecter à x, y et z les

valeurs.

Unpacking de tuples ou de listes avec des étoiles :

>>>t=('a','b','c','d') (mais cela pourrait aussi être une liste ou même une string, donc
n'importe quelle séquence : t=['a','b','c','d'] ou t=”abcd”)
>>>(x,y,z,u)=t : affecte à chaque variable la valeur (x = 'a', y = 'b', z = 'c', u = 'd').
>>>(x,y,*z)=t → x et y prennent les 2 première valeurs et z prend le reste : z = ['c', 'd']
(attention, z sera une liste, pas un tuple).
>>>(*x,y,z)=t → x = ['a','b'],y =’c',z='d'.
>>>(x,*y,z)=t → x=’a’,y=['b','c'], z=’d’.
L'important, c'est de ne pas avoir 2 étoiles à la fois, sinon erreur.

Sur une liste de paires :

>>> t = [(1, 2), (3, 4), (5, 6)]

>>> for (x, y) in t:
... print(x)
... print(y)
...
1
2
3
4
5
6
# Remarque
>>> t = [(1, 2), (3, 4), (5, 6)]
>>> x,y,z=t
>>> x
(1, 2)
>>> type(x)
<class 'tuple'>

Echanger les valeurs de 2 variables :

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

Une fonction peut renvoyer plusieurs valeurs

Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs objets à la
fois. En réalité Python ne renvoie qu'un seul objet, mais celui-ci peut être séquentiel, c'est-à-dire
contenir lui même d'autres objets :
# renvoie un objet de type tuple # renvoie un objet de type liste
>>> def carre_cube1(x): >>> def carre_cube2(x):
... return x**2, x**3 ... return [x**2, x**3]
... ...
>>> carre_cube1(2) >>> carre_cube2(3)
(4, 8) [9, 27]
>>> z1, z2 = carre_cube1(2) >>> z1, z2 = carre_cube2(3)
>>> z1 >>> z1
4 9
>>> z2 >>> z2
8 27

# Cela permet de récupérer plusieurs valeurs renvoyées par une fonction

et de les affecter à la volée à des variables différentes.
Unpacking en python3 pour les retours de fonction : si une fonction f renvoie (1, 2, 3) :
>>> *x,= f() donne x = [1, 2, 3]
>>> x,*y = f() donne x = 1 et y = [2, 3]
>>> *x,y = f() donne x = [1, 2] et y = 3

Tuples de compréhension

>>> t=tuple(x ** 2 for x in [1, 2, 3, 4])

>>> t
(1, 4, 9, 16)
>>> type(t)
<class 'tuple'>

combiner des tuples:

>>> names = ("user1", "user2")
>>> details = (27, 28)
>>> names + details
('user1', 'user2', 27, 28)

Un tuple peut aussi contenir un autre tuple, par exemple un point sur une carte peut-être groupé
comme ceci:
>>> point = ("Pizzeria", (longitude, latitude))