Tuples et ensembles - Des relevés immuables et des espèces uniques

Bienvenue ! En expédition, tu tombes sur des données pour lesquelles une liste n'est pas le meilleur choix. Premier exemple : les coordonnées d'un point d'eau, une paire de nombres qui ne devrait jamais changer. Si une fonction en écrasait une par erreur, toute l'équipe chercherait de l'eau au mauvais endroit. Deuxième exemple : le registre des espèces vues aujourd'hui. Un zèbre est passé cinq fois devant le camp, mais cela reste une seule espèce, alors qu'une liste l'enregistrerait cinq fois.

Python a deux outils pour ces situations. Un tuple est un relevé qu'on ne peut pas modifier. Un ensemble (set) est une collection dans laquelle chaque élément n'apparaît qu'une seule fois.

Le tuple - une entrée à l'encre

Une liste ressemble à des notes au crayon, que tu peux effacer et compléter. Un tuple est une entrée à l'encre dans ton journal : une fois écrite, elle reste pour toujours. Tu le crées avec des parenthèses et tu sépares les éléments par des virgules :

1waterhole = (-2.33, 34.83)
2lion_record = ("Lion", 190, True)
3print(waterhole[0])    # -2.33
4print(lion_record[1])  # 190

L'indexation fonctionne exactement comme dans une liste, à partir de zéro. Un tuple peut aussi mélanger les types de données : lion_record stocke un nom, un poids et l'information indiquant si l'animal est dangereux.

C'est la virgule qui fait le tuple

Il y a un détail sur lequel beaucoup de débutants trébuchent : c'est la virgule, et non les parenthèses, qui crée un tuple. On le voit le mieux avec un tuple d'un seul élément, vérifié avec la fonction type() du premier module :

1single = ("Lion",)
2not_a_tuple = ("Lion")
3print(type(single))       # <class 'tuple'>
4print(type(not_a_tuple))  # <class 'str'>

Sans la virgule, Python voit un simple texte entre parenthèses, comme celles des calculs mathématiques. Pour la même raison, écrire point = 10.5, 20.3 crée aussi un tuple. Les parenthèses sont alors facultatives, mais je te recommande de toujours les écrire, car on voit tout de suite qu'il s'agit d'un tuple.

L'immuabilité

Essayons de corriger une coordonnée du point d'eau comme nous le ferions dans une liste :

1waterhole = (-2.33, 34.83)
2waterhole[0] = -2.40  # TypeError!

Python lève une erreur TypeError, car un tuple ne peut pas être modifié après sa création. Ce n'est pas un défaut mais une garantie : les coordonnées ne changeront pas à cause d'une faute de frappe dans une autre partie du programme. C'est pourquoi un tuple n'a pas de méthodes append(), remove() ni sort(). Il ne lui reste que deux méthodes, qui se contentent de lire les données : count() et index().

Le dépaquetage d'un tuple

Tu peux décomposer un tuple d'enregistrement en variables séparées d'un seul geste. À gauche du signe =, tu donnes autant de noms que le tuple a d'éléments :

1name, weight, dangerous = lion_record
2print(name)    # Lion
3print(weight)  # 190

Chaque variable a reçu l'élément de la même position, et le tuple lui-même est resté inchangé. Si le nombre de noms ne correspond pas au nombre d'éléments, Python lève une ValueError. Tu connais d'ailleurs déjà le dépaquetage grâce à la boucle for key, value in catalog.items(), car la méthode items() fournit justement des tuples avec une clé et une valeur.

Alors, quand choisir un tuple et quand une liste ? Ma règle : si les données décrivent une seule chose à la structure fixe, comme des coordonnées ou la fiche d'un animal, choisis un tuple. Si c'est une collection qui grandit et rétrécit, comme les observations du jour, choisis une liste.

L'ensemble - le registre des espèces uniques

Revenons au zèbre qui a visité le camp cinq fois. Un ensemble fonctionne comme une liste d'appel au point d'eau : tu coches chaque espèce une seule fois, même si elle est venue boire dix fois. Le plus simple pour en construire un est de passer une liste dans la fonction set() :

1sightings = ["Zèbre", "Lion", "Zèbre", "Éléphant", "Zèbre"]
2species = set(sightings)
3print(species)       # {'Lion', 'Zèbre', 'Éléphant'}
4print(len(species))  # 3

Les doublons ont disparu, et la liste sightings contient toujours cinq entrées, car la fonction set() a construit une nouvelle collection. L'ordre à l'affichage peut être différent chez toi, parce qu'un ensemble ne retient pas l'ordre de ses éléments. Pour cette raison, il n'a pas d'indices, et species[0] se termine par une erreur.

Créer et modifier un ensemble

Tu peux aussi écrire un ensemble directement, entre accolades. Attention à un piège : des accolades vides {} créent un dictionnaire vide, pas un ensemble, donc un ensemble vide s'écrit set().

1visitors = {"Zèbre", "Lion"}
2visitors.add("Éléphant")
3visitors.add("Zèbre")
4print(len(visitors))       # 3
5print("Lion" in visitors)  # True

Contrairement au tuple, l'ensemble est mutable. La méthode add() a ajouté l'éléphant, mais le second zèbre n'a rien changé, car il était déjà dans le registre. L'opérateur in vérifie la présence très rapidement, même dans un énorme ensemble. Deux méthodes servent à supprimer : remove(), qui lève une erreur quand l'élément manque, et discard(), qui dans ce cas ne fait simplement rien. Avec des données incertaines, je te recommande discard().

Les opérations sur les ensembles

La vraie force des ensembles n'apparaît que lorsque tu compares deux registres. Le matin et le soir, l'équipe note les espèces au point d'eau, et trois opérateurs répondent à trois questions différentes :

1morning = {"Zèbre", "Lion", "Éléphant"}
2evening = {"Zèbre", "Hippopotame", "Éléphant"}
3print(morning & evening)  # {'Zèbre', 'Éléphant'}
4print(morning | evening)  # {'Zèbre', 'Lion', 'Éléphant', 'Hippopotame'}
5print(morning - evening)  # {'Lion'}

L'opérateur & est l'intersection, c'est-à-dire les espèces vues le matin et le soir. L'opérateur | est l'union : tout ce qui est apparu dans la journée, sans répétition. L'opérateur - est la différence, c'est-à-dire les espèces du matin absentes le soir. Aucun d'eux ne modifie les ensembles morning ou evening, chacun construit un nouvel ensemble avec le résultat. Pour la différence, l'ordre compte : evening - morning donne {'Hippopotame'}. Tout fonctionne de la même manière avec des nombres, donc {1, 2, 3} & {2, 3, 4} renvoie {2, 3}.

Quelle structure choisir ?

Tu connais maintenant quatre structures de données, et chacune a sa place dans l'équipement d'un explorateur :

• liste - ordonnée et modifiable, accepte les doublons, comme un journal d'observations,
• tuple - ordonné et non modifiable, comme des coordonnées ou une fiche fixe,
• ensemble - sans ordre et sans doublons, comme un registre d'espèces uniques,
• dictionnaire - des paires clé et valeur, comme un catalogue de découvertes avec des fiches.

Quand tu as besoin d'éléments uniques, choisis un ensemble au lieu de surveiller à la main les doublons d'une liste.

Retiens : un tuple est une entrée à l'encre que tu ne peux pas modifier, et un ensemble est un registre dans lequel chaque espèce n'apparaît qu'une seule fois. Dans la prochaine leçon, Darwin te présentera les compréhensions de liste, et dans le projet de fin de module, les tuples et les ensembles t'aideront à analyser le journal d'expédition.