Chapitre 1 : Les p-uplets (tuples)¶

Programme officiel (B.O.)¶

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
p-uplets. p-uplets nommés	Écrire une fonction renvoyant un p-uplet de valeurs.

1. Qu'est-ce qu'un p-uplet ?¶

1.1 Définition¶

Un p-uplet (ou tuple en anglais) est une collection ordonnée et non modifiable de valeurs. On dit qu'un tuple est immuable (immutable).

>>> coordonnees = (3, 7)
>>> couleur_rgb = (255, 128, 0)
>>> eleve = ("Dupont", "Marie", 16)

Un p-uplet peut contenir des éléments de types différents : entiers, flottants, chaînes, booléens, etc.

1.2 Vocabulaire¶

Le nom « p-uplet » vient de la généralisation des mots courants :

Nombre d'éléments	Nom
2	couple (ou paire)
3	triplet
4	quadruplet
n	n-uplet
p	p-uplet (cas général)

1.3 Syntaxe en Python¶

On crée un tuple avec des parenthèses (ou même sans, grâce à la virgule) :

>>> t1 = (1, 2, 3)
>>> t2 = 1, 2, 3        # les parenthèses sont facultatives
>>> t3 = (42,)           # tuple d'un seul élément : la virgule est obligatoire
>>> t4 = ()              # tuple vide
>>> type(t1)
<class 'tuple'>

Attention

(42) n'est pas un tuple, c'est juste le nombre 42 entre parenthèses. Pour un tuple à un seul élément, il faut écrire (42,) avec la virgule.

2. Accéder aux éléments¶

2.1 Indexation¶

Comme pour les chaînes de caractères, on accède aux éléments par leur indice (en commençant à 0) :

>>> eleve = ("Dupont", "Marie", 16)
>>> eleve[0]
'Dupont'
>>> eleve[1]
'Marie'
>>> eleve[2]
16

Les indices négatifs permettent de compter depuis la fin :

>>> eleve[-1]
16
>>> eleve[-2]
'Marie'

2.2 Longueur¶

La fonction len() renvoie le nombre d'éléments :

>>> len(eleve)
3

2.3 Parcours¶

On peut parcourir un tuple avec une boucle for :

couleurs = ("rouge", "vert", "bleu")
for c in couleurs:
    print(c)

3. Immuabilité¶

Un tuple est non modifiable : on ne peut ni ajouter, ni supprimer, ni modifier un élément.

>>> point = (3, 7)
>>> point[0] = 5
TypeError: 'tuple' object does not support item assignment

C'est la différence fondamentale avec les listes (tableaux), qui sont modifiables.

Pourquoi utiliser des tuples ?

Pour protéger des données qui ne doivent pas changer (coordonnées, constantes, clés de dictionnaire).
Pour renvoyer plusieurs valeurs depuis une fonction.
Pour documenter l'intention : un tuple dit « ces données vont ensemble et ne changeront pas ».

4. Déballage (unpacking)¶

On peut affecter chaque élément d'un tuple à une variable en une seule ligne. C'est le déballage (unpacking) :

>>> coordonnees = (3, 7)
>>> x, y = coordonnees
>>> x
3
>>> y
7

Le nombre de variables doit correspondre au nombre d'éléments :

>>> nom, prenom, age = ("Dupont", "Marie", 16)
>>> print(f"{prenom} {nom}, {age} ans")
Marie Dupont, 16 ans

Astuce

Le déballage permet d'échanger deux variables sans variable temporaire :

>>> a, b = 5, 10
>>> a, b = b, a
>>> a
10
>>> b
5

5. Fonctions renvoyant un tuple¶

Un tuple est le moyen naturel de renvoyer plusieurs valeurs depuis une fonction :

def min_max(liste):
    """Renvoie le minimum et le maximum d'une liste."""
    return (min(liste), max(liste))

resultat = min_max([4, 7, 1, 9, 3])
print(resultat)         # (1, 9)

# Avec déballage :
petit, grand = min_max([4, 7, 1, 9, 3])
print(petit)            # 1
print(grand)            # 9

Autre exemple :

def division_euclidienne(a, b):
    """Renvoie le quotient et le reste de a divisé par b."""
    return (a // b, a % b)

q, r = division_euclidienne(17, 5)
print(f"17 = 5 x {q} + {r}")    # 17 = 5 x 3 + 2

6. Opérations sur les tuples¶

Même si un tuple est immuable, certaines opérations sont possibles car elles créent un nouveau tuple :

>>> (1, 2) + (3, 4)         # concaténation
(1, 2, 3, 4)

>>> (1, 2) * 3              # répétition
(1, 2, 1, 2, 1, 2)

>>> 3 in (1, 2, 3, 4)       # appartenance
True

>>> (1, 2, 3).index(2)      # position d'un élément
1

>>> (1, 2, 2, 3, 2).count(2)  # nombre d'occurrences
3

7. P-uplets nommés¶

7.1 Problème¶

Avec un tuple classique, il faut se souvenir de la position de chaque information :

eleve = ("Dupont", "Marie", 16, "1ere3")
# eleve[0] = nom ? prenom ? On ne sait plus...

7.2 Solution : les p-uplets nommés¶

Python propose les namedtuples du module collections, qui associent un nom à chaque champ :

from collections import namedtuple

Eleve = namedtuple("Eleve", ["nom", "prenom", "age", "classe"])

e = Eleve("Dupont", "Marie", 16, "1ere3")

print(e.nom)       # Dupont
print(e.prenom)    # Marie
print(e.age)       # 16
print(e.classe)    # 1ere3

On accède aux champs par leur nom (plus lisible) tout en conservant l'accès par indice :

>>> e[0]
'Dupont'
>>> e.nom
'Dupont'

7.3 Avantages¶

Le code est plus lisible : e.nom est plus clair que e[0].
Le tuple reste immuable : on ne peut pas modifier e.nom.
On peut l'utiliser comme un tuple classique (parcours, déballage, etc.).

8. Résumé¶

Propriété	Tuple
Syntaxe	`(a, b, c)` ou `a, b, c`
Ordonné	Oui (indice 0, 1, 2...)
Modifiable	Non (immuable)
Types mélangés	Oui
Accès par indice	`t[0]`, `t[-1]`
Déballage	`x, y = (3, 7)`
Usage principal	Renvoyer plusieurs valeurs, données constantes
P-uplet nommé	`namedtuple` : accès par nom (`e.prenom`)