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