P-uplets et p-uplets nommés : cours de NSI en Première

Imagine que tu veuilles représenter un point sur une carte. Une seule valeur ne suffit pas : il en faut au moins deux, une abscisse et une ordonnée. Imagine maintenant que tu doives décrire un élève dans un fichier : son nom, sa classe, sa moyenne. Là encore, plusieurs informations vont ensemble et il serait maladroit de les stocker dans des variables séparées, sans lien entre elles.

C'est exactement le rôle du p-uplet : regrouper, dans un seul objet, plusieurs valeurs qui forment un tout. Les mathématiciens l'utilisent depuis longtemps, par exemple pour les coordonnées ; les informaticiens l'ont repris pour manipuler des données structurées. Dans ce cours, tu vas apprendre à le définir, à le créer en Python, à lire ses composantes, puis à passer au p-uplet nommé, qui permet de retrouver une information par son nom plutôt que par sa position.

Le cours suit une progression simple :

• d'abord l'idée mathématique de p-uplet, avec son vocabulaire ;
• ensuite le type tuple de Python et la façon de l'écrire ;
• puis la comparaison avec les listes, que tu étudieras en détail ensuite ;
• enfin les p-uplets nommés et leur usage pour représenter une table de données, celle d'un fichier CSV par exemple.

Ce chapitre prépare directement les tableaux et listes puis les dictionnaires : tout ce que tu vois ici te servira à ce moment-là.

Deux mots de cette définition méritent qu'on s'y arrête.

Ordonné : la position de chaque composante compte. Le premier élément reste le premier, le deuxième reste le deuxième. Changer l'ordre revient à obtenir un autre p-uplet.

Fini : un p-uplet contient un nombre précis de composantes, ni plus ni moins. Tu peux toujours dire combien il y en a.

On parle tantôt de « n-uplet », tantôt de « p-uplet » : la lettre n'a aucune importance, elle désigne simplement le nombre de composantes. Les deux notations désignent la même chose, et ton programme de NSI emploie « p-uplet ».

Cette propriété se vérifie facilement avec un exemple : $(1, 2)$ et $(1, 2, 3)$ commencent de la même façon, mais le premier a deux composantes et le second trois. Ils sont donc différents. De même, $(1, 2)$ et $(2, 1)$ ont la même taille, mais pas les mêmes composantes à la même place : ils sont différents aussi, puisque l'ordre compte.

Les p-uplets sont partout en mathématiques. Les coordonnées sont des n-uplets : un point de l'espace ordinaire correspond à un triplet de nombres réels ⁵. Un p-uplet peut aussi regrouper les arguments d'une fonction à plusieurs variables ⁵.

Cette dernière précision est très utile : contrairement à ce que l'on voit parfois en mathématiques, où l'on regroupe souvent des nombres, un tuple Python peut mélanger des entiers, des flottants, des chaînes de caractères, et même d'autres tuples. Les composantes n'ont donc pas besoin d'être du même type.

Ce qui fait le tuple, ce sont donc les virgules, pas les parenthèses. Les parenthèses servent à rendre le code lisible, et à lever des ambiguïtés. Par exemple, pour écrire un p-uplet qui contient lui-même un autre p-uplet, les parenthèses sont nécessaires ². Quand le p-uplet fait partie d'une expression plus longue, elles aident aussi à la lecture ².

Comme un p-uplet est ordonné, on peut repérer chacun de ses éléments par un indice, c'est-à-dire sa position. Cette idée de suite de valeurs repérées par des indices est à l'origine des p-uplets et des listes en Python ².

Un usage très courant consiste à regrouper les coordonnées d'un point. Les ressources officielles donnent l'exemple d'une fonction qui reçoit en paramètres trois p-uplets représentant les coordonnées de trois points, après avoir importé la fonction racine carrée sqrt ². On peut s'en inspirer pour calculer une distance dans le plan.

Cet exemple montre l'intérêt du p-uplet : la fonction reçoit deux paramètres seulement, a et b, alors que chaque point porte deux nombres. Sans p-uplet, il faudrait écrire une fonction à quatre paramètres, et se souvenir de leur ordre.

En informatique générale, on retrouve aussi les n-uplets dans les types de données de type enregistrement ⁵. Cette idée d'enregistrement, c'est-à-dire d'une « fiche » regroupant des informations, conduit naturellement aux p-uplets nommés.

Tu connais peut-être déjà le type list. Une liste ressemble à un p-uplet : c'est un ensemble ordonné d'éléments, repérés par des indices ². On retrouve donc l'idée d'ordre et de position.

Pourquoi alors disposer de deux types ? Parce que les usages diffèrent. Un p-uplet sert plutôt à regrouper un petit nombre de valeurs hétérogènes qui forment un tout : un point, une date, une fiche. Une liste sert plutôt à ranger une suite de valeurs de même nature, que l'on parcourt. Le chapitre suivant, consacré aux tableaux et listes, développera ce point.

Retiens pour l'instant ce critère de choix : si tu te demandes « de quoi est fait cet objet, et dans quel ordre ? », pense p-uplet. Si tu te demandes « combien d'éléments de ce genre ai-je à traiter ? », pense liste.

Prenons une fiche d'élève : « Lina, 1re, 14 ». Avec un p-uplet ordinaire, tu écrirais ("Lina", "1re", 14) et tu devrais te rappeler que la note est à l'indice 2. Avec un p-uplet nommé, tu appelles la composante par son nom : le champ note. Le code devient bien plus lisible : eleve["note"] se comprend sans commentaire, alors que eleve[2] oblige à se souvenir de l'organisation.

Ce type figure au programme de Première de NSI surtout pour simplifier la manipulation de données, comme les tables ¹. Un fichier de données est en effet fait de lignes qui ont toutes les mêmes champs : chaque ligne est un p-uplet nommé.

Le mot immuable signifie qu'on ne peut pas modifier l'objet une fois créé. Le mot mutable signifie le contraire. Il y a donc un léger écart entre le p-uplet nommé « idéal », qui ne change pas, et son imitation par un dictionnaire, qui reste modifiable. Il faut donc être discipliné : en tant que programmeur, tu t'interdis de modifier les champs d'un enregistrement que tu considères comme un p-uplet nommé.

Le grand intérêt des p-uplets nommés apparaît quand on traite une table, c'est-à-dire un ensemble de lignes qui partagent les mêmes champs. Un fichier CSV en est l'exemple typique : sa première ligne donne le nom des colonnes ¹, et chaque ligne suivante décrit un enregistrement.

La démarche consiste à écrire une fonction qui extrait les données et les range dans un tableau de p-uplets nommés ¹. On obtient alors un tableau de p-uplets sous forme de dictionnaires, dont les clés nomment les champs ³.