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. Les tuples prennent aussi un peu moins de mémoire que les listes.

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 attention, ça ne retourne pas un tuple, ca 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