Cours : Les Tuples

Auparavant, nous avons déjà rencontré un type de donnée construit : les tableaux, implémentés par le type list en Python. Il existe d'autres séquences en Python : les tuples en sont un exemple.

Définition et points communs avec les listes Python

Un tuple (ou n-uplets) est un collection ordonnée de n objets séparés par des virgules.

t = (1, 2)

On peut tout à fait créer un tuple sans utiliser les parenthèses mais leur présence facilite la lecture. De plus ils peuvent contenir des données de natures différentes.

• Il est possible que le tuple ne contienne aucun élément ou encore un seul élément

>>> t = ()
>>> t = (1, )  # on pourrait aussi écrire   1, sans les parenthéses

• Comme pour les listes, les tuples sont des séquences ordonnées. On peut accéder aux éléments par leur indice de position (le premier élément à toujours l'indice 0) ou encore accéder aux nombres d'éléments présents.

• On peut également accéder à des tranches du tuple avec la même notation que celle vue pour les chaînes de caractères ou les listes

• On peut bien évidemment les parcourir.

D'autres propriétés sont communes aux listes, aux chaînes de caractères et aux tuples : la création par compréhension, et beaucoup des méthodes déjà rencontrées (à condition qu'elles ne modifient pas le tuple)

Particularités des tuples

Les tuples peuvent être considérés comme des listes non modifiables (immuables)

• Une fois le tuple créé, il est impossible de changer un élément présent à l'intérieur

• Il est cependant possible de concaténer des tuples

>>> (1, 2) + (3, 4)
(1, 2, 3, 4)

• On peut également disperser un tuple c'est à dire le "casser" en plusieurs variables. C'est une propriété très pratique notamment pour réaliser des affectations multiples

>>> x, y, z = (15, 50, 20)
>>> x
15
>>> y
50
>>> z
20

Pourquoi utiliser un tuple plutôt qu'une liste?

• Lorsque les données ne doivent pas être modifiées : un tuple est plus judicieux.
  Imaginons des données personnelles immuables concernant un individu (nom, prenom, date de naissance) : on ne souhaite pas qu'elles soient modifiées par inavertance. Rappelez vous de la mutabilité des listes, aucune chance que cela ne se produise avec un tuple

• Lorsqu'on souhaite calculer plusieurs valeurs dans une fonction le tuple peut être un type de données utilsé comme valeur de retour.

Exemple de la division euclidienne

def division (a, b):
""" Effectue la division euclidienne de a par b
:param int a: dividende
:param int b: diviseur
:return: un couple (quotient, reste)
"""
    return (a // b, a % b)

quotient, reste = division(5, 2)

Ici la valeur de retour est un tuple. Lorsqu'on appelle la fonction, il suffit de disperser le tuple pour récupérer le quotient et le reste dans deux variables indépendantes.

Questionnaire QCM

Voici quelques QCM pour voir si vous avez bien compris. N'hésitez pas à relire ce qui précède si vous avez un doute.

QCM 1

def ma_fonction(x) :
    a = x * 2
    b = x * 3

QCM 2

mon_tuple = (4,5,3,7,8)

• [ ] remplace l'élément 2 par 4
• [x] léve une exception
• [ ] remplace par 4 l'élément d'indice 2
• [ ] remplace l'élément 5 par 4

QCM 3

Soit la liste suivante : notes_eleves = [('Marie', 10), ('Lucas', 15), ('Lea', 19), ('Theo', 8)]

• [ ] int
• [x] list
• [ ] tuple
• [ ] autre chose

QCM 4

a = 3
b = a + 1
print((a**2 + b**2)**0.5)

QCM 5

a = 22
b = 5
print((a // b) + (a % b))