> Les bases > Le langage > Tuples
Tuples
Un tuple, c'est comme une liste, sauf que les éléments ne peuvent pas être changés (non mutable) : t = ('a', 'b'); t[0] = 'c' renvoie une erreur.
Intérêt des tuples : ils peuvent être utilisés comme clefs dans les dictionnaires, alors que les listes ne le peuvent pas.
Définition d'un tuple :
- t = ('a', 'b', 2)
- tuple à 0 élément : t = ()
- tuple à 1 élément : t = ('a',) ou t = 'a', avec la virgule dans les 2 cas !
- tuple à 2 éléments : t = ('a', 'b') ou t = 'a', 'b'
On accède au 2ème élément par t[1] (comme pour les listes).
Sequence packing et unpacking :
- sequence packing : t = x, y, z
- sequence unpacking : x, y, z = t : t doit avoir 3 éléments dans ce cas.
- 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 :
- on fixe t = ('a', 'b', 'c', 'd') (mais cela pourrait aussi être une liste ou même une string, donc n'importe quelle séquence).
- (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 est une liste, pas un tuple).
- (*x, y, z) = t : on peut faire l'affectation dans l'autre sens, donc ici x = ['a', 'b'], y = 'c', z = 'd'.
- on peut aussi faire (x, *y, z) = t. L'important, c'est de ne pas avoir 2 étoiles à la fois, sinon erreur.
Sur une liste de paires (par exemple), on peut faire :
myList = [(1, 2), (3, 4), (5, 6)]
for (x, y) in myList:
print(x)
print(y)
Pour échanger les valeurs de 2 variables : (a, b) = (b, a)
Une fonction peut renvoyer plusieurs valeurs :
- il suffit qu'elle renvoie un tuple, par exemple return a, b
- on peut alors l'appeler en stockant le résultat directement dans un tuple avec le bon nombre de variables : x, y = myFunc()
tuples de compréhension :
- on peut aussi faire (x ** 2 for x in [1, 2, 3, 4]), mais ça retourne un générateur.
- pour avoir un tuple, il suffit de faire : tuple(x ** 2 for x in [1, 2, 3, 4]). Ca donne donc (1, 4, 9, 16).
- on peut aussi faire : tuple([x ** 2 for x in [1, 2, 3, 4]).
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
Copyright python-simple.com
programmer en python, tutoriel python, graphes en python, Aymeric Duclert