Les tuples

Les tuples sont des séquences non mutables d’objets séparés par une virgule, et délimitées par des parenthèses ( et ).

Les tuples peuvent être formés :

en évaluant l’expression tuple() ou (). On obtient le tuple vide.
En combinant des éléments (elt0, elt1, …, eltn), ou en convertissant une séquence par tuple(seq).

en “compréhension”, par tuple(expr for indice in iterable), ou tuple(expr for indice in iterable if condition) ;
on peut également utiliser la syntaxe plus générale suivante, (cf “listes en compréhension”).

tuple( expression for indice_1 in iterable_1 [if condition_1]

for indice_2 in iterable_2 [if condition_2]

...

for indice_n in iterable_n [if condition_n] )

Quelques remarques :

Les parenthèses aux extrémités sont facultatives (l’important, ce sont les virgules) mais recommandées pour la lisibilité.
Pour former un tuple à un seul élément, il faut faire suivre cet élément d’une virgule.
Les opérations sur les séquences non mutables s’appliquent aux tuples : appartenance (avec in t et not in t), concaténation (avec t + t’) et répétition (avec t * n), longueur avec len(t), accès indexés et coupes (avec t [ i ], t [ i : j ], t [ i : j : k ]), minimum/maximum (max et min), recherche de valeur x par t.index(x) et occurences par t.count(x).
Les tuples sont indiqués pour “packer” ensemble des données, si on ne souhaite pas les modifier individuellement (ce qui serait de toutes façons impossible ici pour cause de “non mutabilité”) ni augmenter ou diminuer leur nombre.
Tout comme les listes et les chaînes, les tuples sont itérables, et peuvent donc être parcourus par une boucle for.

Commençons par un premier exemple de tuple défini “en extension” :

>>> t = (123, 'abc', 3.14); type(t) # on définit un tuple de longueur 3

>>> t[1] # on accède en lecture à l'élément en position 1

'abc'

>>> t[1] = 'uvw' # impossible de modifier un élément !!!

<...> TypeError: 'tuple' object does not support item assignment

Voici quelques exemples de manipulations d’un tuple t défini en compréhension :

>>> t = tuple(x*x for x in range(1,9)); t # un tuple défini en compréhension

(1, 4, 9, 16, 25, 36, 49, 64)

>>> t[::-1] # le même tuple, mais à l'envers

(64, 49, 36, 25, 16, 9, 4, 1)

>>> id(t) # voici l'adresse de t en mémoire

4361652568

>>> t = t + (2013,); t # on ajoute l'élément 2013 (NB la virgule!)

(1, 4, 9, 16, 25, 36, 49, 64, 2013)

>>> id(t) # mais attention, c'est un tout nouvel objet!!!

4361652432

>>> t[1:6:2] # le tuple (t[1],t[3],t[5])

(4, 16, 36)

>>> t[-1] # le dernier élément du tuple t

2013

Terminons par quelques opérations possibles sur les tuples :

>>> (1,2,3)+(4,5) # concaténation de deux tuples

(1, 2, 3, 4, 5)

>>> (1,2,3),(4,5) # on forme un '2uple' (un '3uple' puis un '2uple')

((1, 2, 3), (4, 5))

>>> (0,)*5 # le '1uple' (0) répété 5 fois

(0, 0, 0, 0, 0)

>>> x,y,z = (5,6,7) # on 'dépacke' un tuple

>>> z, y, x # on repacke, mais en changeant l'ordre

(7, 6, 5)

>>> tuple('pqrs') # transforme 'pqrs' (chaîne donc itérable) en tuple

('p', 'q', 'r', 's')

>>> tuple([1,2,3,4]) # transforme une liste (donc itérable) en tuple

(1, 2, 3, 4)

Les tuples

Retour à l’accueil du cours Python/Numpy

Sommaire du chapitre 5