Introduction
En programmation, il est fréquent de devoir regrouper plusieurs données associées. Pour cela, les langages proposent diverses structures, dont les p-uplets. Un p-uplet est un ensemble de valeurs ordonnées, immuables, qui peuvent être de types différents. Le terme « p-uplet » est une généralisation de « couple » (2-uplet), « triplet » (3-uplet), etc. : la lettre « p » désigne simplement le nombre d’éléments contenus. Cette structure, essentielle dans l’organisation des données, joue un rôle transversal dans tout le programme de NSI, en particulier dans les fonctions, les structures de données ou l’exploration de tables.
Regrouper plusieurs valeurs dans un p-uplet
Un p-uplet permet de regrouper plusieurs éléments dans un ordre précis. En Python, on l’écrit avec des parenthèses, les éléments étant séparés par des virgules.
Exemples :
personne = ('Alice', 17, True)
coordonnees = (42.1, -3.5)
couleurs = ('rouge', 'vert', 'bleu')
Un p-uplet peut contenir des éléments de même type ou de types différents. Dans l’exemple personne, on trouve une chaîne de caractères, un entier et une valeur booléenne. Les éléments sont accessibles par indice :
print(personne[0]) # 'Alice'
print(coordonnees[1]) # -3.5
Contrairement aux listes, les p-uplets sont immuables : une fois créés, leurs éléments ne peuvent pas être modifiés.
Exemple :
coordonnees[0] = 50.0 # Erreur : le p-uplet ne peut pas être modifié
Cette propriété les rend fiables lorsqu’il s’agit de manipuler des données qui ne doivent pas changer, notamment dans le cadre de fonctions.
À retenir
Un p-uplet est une structure ordonnée et immuable pouvant contenir des éléments de types différents. On y accède par indice, mais on ne peut pas en modifier les valeurs après sa création.
Créer et utiliser des fonctions qui renvoient des p-uplets
Le programme officiel précise que les élèves doivent savoir écrire une fonction renvoyant un p-uplet de valeurs. Cette capacité est essentielle pour structurer efficacement les retours d’une fonction.
Exemple :
def statistiques(liste_notes):
moyenne = sum(liste_notes) / len(liste_notes)
minimum = min(liste_notes)
maximum = max(liste_notes)
return (moyenne, minimum, maximum)
On peut récupérer les résultats avec un dépaquetage (ou unpacking) :
moy, mini, maxi = statistiques([10, 14, 17, 8])
print(moy) # 12.25
print(maxi) # 17
Le dépaquetage permet de stocker directement chaque valeur dans une variable distincte. Attention : il faut que le nombre de variables à gauche corresponde au nombre d’éléments du p-uplet.
Ce procédé rend le code plus clair et plus concis, mais devient difficilement lisible avec un grand nombre de valeurs.
À retenir
Une fonction peut retourner plusieurs résultats regroupés dans un p-uplet. Grâce au dépaquetage, chaque élément peut être récupéré dans une variable distincte, tant que leur nombre est respecté.
Mieux nommer les éléments avec les p-uplets nommés
Lorsque les p-uplets deviennent plus longs, il peut être difficile de se rappeler ce que chaque position représente. Pour y remédier, Python permet de créer des p-uplets nommés (ou named tuples) via le module collections.
Exemple :
from collections import namedtuple
Etudiant = namedtuple('Etudiant', ['prenom', 'age', 'admis'])
e1 = Etudiant('Emma', 18, True)
print(e1.prenom) # 'Emma'
print(e1.age) # 18
Chaque champ peut être accédé par son nom, ce qui rend le code bien plus lisible. Il est aussi possible d’accéder à la documentation du p-uplet nommé avec ._fields :
print(Etudiant._fields) # ('prenom', 'age', 'admis')
Les namedtuple sont immuables comme les p-uplets classiques. Ils constituent un bon compromis entre la simplicité des p-uplets et la lisibilité des dictionnaires.
Pour explorer davantage ces structures, l’élève peut utiliser la commande help(namedtuple) dans l’interpréteur Python.
À retenir
Les p-uplets nommés offrent une meilleure lisibilité grâce à l’accès par nom de champ. Ils sont immuables et particulièrement utiles pour représenter des objets simples sans classe.
Étude de cas : créer une base d’élèves
Supposons qu’on veuille représenter des élèves dans une table, chaque élève ayant un prénom, un âge et une note.
Une première version utilise un simple tableau de p-uplets :
eleves = [
('Léo', 16, 14.5),
('Emma', 17, 15.0),
('Noé', 16, 13.0)
]
On peut afficher les prénoms de tous les élèves admis (note ≥ 14) :
for eleve in eleves:
if eleve[2] >= 14:
print(eleve[0])
Mais la version avec des p-uplets nommés rend le code plus lisible :
from collections import namedtuple
Eleve = namedtuple('Eleve', ['prenom', 'age', 'note'])
eleves = [
Eleve('Léo', 16, 14.5),
Eleve('Emma', 17, 15.0),
Eleve('Noé', 16, 13.0)
]
for e in eleves:
if e.note >= 14:
print(e.prenom)
Cette utilisation des p-uplets est directement liée à l’axe « Explorer des données en table » du programme NSI. Une table est une liste de p-uplets qui partagent la même structure. Ce lien entre les axes de programme permet de donner du sens aux structures étudiées.
À retenir
Les p-uplets permettent de structurer les lignes d’une table. Combinés aux boucles et aux conditions, ils servent à traiter efficacement les données. Les p-uplets nommés améliorent encore la clarté du traitement.
Choisir les p-uplets : avantages et limites
Les p-uplets sont bien adaptés lorsque :
Le nombre d’éléments est fixé à l’avance.
Les données ne doivent pas être modifiées.
On veut transmettre plusieurs résultats sans complexifier la structure.
Ils sont plus compacts et plus rapides que des dictionnaires, mais moins explicites quand on utilise de simples indices. Dès qu’on dépasse trois ou quatre éléments, il devient préférable de passer aux p-uplets nommés.
En revanche, les p-uplets ne conviennent pas si :
Les données doivent être modifiées (préférer les listes ou dictionnaires).
Le nombre d’éléments varie.
Les données ont besoin d’être commentées ou décrites (préférer les classes ou dictionnaires).
À retenir
Les p-uplets sont utiles pour regrouper des données fixes, de manière compacte. Pour plus de clarté, surtout quand les données sont nombreuses, les p-uplets nommés sont à privilégier.
Conclusion
Les p-uplets sont une brique de base pour structurer les données en Python. Ils permettent de regrouper des valeurs hétérogènes, d’échanger plusieurs résultats entre fonctions ou de modéliser simplement des données. Leur usage s’étend à la manipulation de tables, à l’analyse de fichiers ou à la construction de structures plus complexes. Comprendre les p-uplets, c’est acquérir un outil fondamental pour organiser proprement l’information dans un programme.