Pratique... mais il faut se souvenir QUE l'indice 0 = la première hauteur, l'indice 1 = la deuxième, etc. Et si on rangeait par NOM plutôt que par numéro ?

Au lieu d'un numéro de position, on range et on retrouve par une CLÉ - le nom du tiroir. La clé est entre guillemets, la valeur peut être de n'importe quel type.

La languette qui dépasse, c'est la clé - le nom qu'on lit de l'extérieur. Ce qui est rangé dans la case, c'est la valeur. Un dictionnaire, c'est une rangée de ces cases étiquetées.

L'opération la plus courante : on connaît la clé, on lit sa valeur avec arbre["taille"] et on la range souvent dans une variable pour s'en servir. C'est une simple lecture - le dictionnaire n'est pas modifié.

La syntaxe est la même pour modifier (clé existante) et pour ajouter (nouvelle clé). Si la clé n'existe pas encore, Python crée un nouveau tiroir.

.items() donne chaque paire (clé, valeur) d'un coup. Mais parcourir toutes les clés est en fait assez rare : d'habitude on connaît la clé et on y va directement (arbre["taille"]). On parcourt surtout quand on ne connaît pas les clés d'avance - déboguer du code qui crée des clés à la volée, ou inspecter des données reçues d'une fonction qu'on n'a pas programmée.

Même structure, trois points de vue : le mot Python, l'idée générale et la machinerie. Retrouver une valeur par sa clé reste presque aussi rapide, que le dictionnaire contienne 10 ou 10 000 entrées.

Le point commun : on retrouve une valeur par un nom, pas par une position. On regarde chaque cas avec un tableau d'exemples.

On manipule des noms simples (ROUGE) ; le dictionnaire garde le code exact. Ce code n'est écrit qu'une seule fois - un seul endroit à corriger si on change de teinte.

Le site affiche textes[langue]["accueil"]. Changer de langue = changer de dictionnaire, sans toucher au reste du code. C'est le coeur de tout site multilingue.

Deux dictionnaires miroirs : l'un pour aller, l'autre pour revenir. On peut même fabriquer l'inverse automatiquement : inverse = {nom: sym for sym, nom in symboles.items()}.

Quand tous les dictionnaires partagent les mêmes clés, ces clés deviennent les colonnes. Une liste de dictionnaires = les lignes d'un fichier CSV ou d'un tableur Excel.

Un formulaire se lit tout naturellement comme un dictionnaire : chaque champ est une clé, chaque réponse est sa valeur. C'est exactement la forme que renvoie un formulaire web.

La clé est l'élément, la valeur est son compteur. Si l'élément est nouveau, on part de zéro ; sinon on lui ajoute 1. Un classique pour analyser un texte, des votes ou des ventes.

La même recette de comptage sur une vraie question : combien de lunchs de chaque sorte ? Chaque plat (la clé) garde son total (la valeur). Idéal pour une commande de groupe, un sondage ou un inventaire.

Chaque carte porte ses attributs nommés (couleur, valeur) - bien plus clair que de retenir « l'indice 0 = la couleur ». Une main, c'est tout simplement une liste de dictionnaires.

La boucle for visite chaque carte (chaque dictionnaire) de la liste. Pour chacune, on lit ses champs par leur nom. C'est le motif liste de dictionnaires + boucle qu'on retrouve partout : une main de cartes, un tableur, des résultats d'expérience.

Une constante (en MAJUSCULES) nomme une valeur fixe, écrite une seule fois. Fini les fautes de frappe, l'éditeur complète pour toi. Regrouper ces couleurs liées, c'est exactement l'idée de enum.Enum en Python - mais ça commence ici : nommer l'ensemble des valeurs possibles.

Encore un tableau associatif : la couleur (la clé, une donnée interne comme "coeur") donne le symbole à afficher (la valeur, ♥️). On transforme une donnée du programme en quelque chose de joli à l'écran - et on combine ça avec les constantes ou l'enum d'à côté.

Un Enum rassemble sous un seul nom (Couleur) toutes les valeurs possibles. On écrit Couleur.COEUR : lisible, vérifié par Python, et la valeur réelle reste accessible avec .value.

Les deux valent mieux que des chaînes nues. Constantes : simples, parfaites pour débuter ou pour quelques valeurs. Enum : plus sûr et structuré quand l'ensemble des valeurs compte vraiment (couleurs, états, jours de la semaine...).

Un tableau 2D = une liste de listes. foret[ligne][colonne] donne la cellule exacte. Parfait pour modéliser une carte, une grille de parcelles, une image pixel par pixel.

Visiter ne sert pas qu'à afficher : on peut accumuler un total, compter des cases, chercher un maximum... La double boucle voit chaque cellule une fois, et on additionne au passage.

Un plateau de tic-tac-toe, c'est un tableau 2D. grille[ligne][colonne] = "O" écrit dans une case ; grille[ligne][colonne] la relit. Lignes et colonnes sont numérotées à partir de 0 - le centre, c'est [1][1].

NumPy applique l'opération à chaque élément automatiquement (la vectorisation). Attention : sur une liste Python, hauteurs * 2 recopie la liste au lieu de doubler les nombres - c'est tout l'intérêt de NumPy.

Une seule opération - + 10, / 10, * 2... - s'applique à chaque case en même temps, sans aucune boucle. Idéal pour mettre des mesures à l'échelle, convertir des unités (°F → °C) ou normaliser des données.

Moyenne, écart-type, somme, min, max... NumPy offre directement les outils d'analyse de données - exactement ce qu'il faut pour traiter des mesures dans le Projet 2 et le Projet 3.

Même idée que le tableau 2D, mais NumPy l'écrit foret[ligne, colonne] et connaît sa forme avec .shape. Parfait pour les images, les grilles et les matrices scientifiques.

NumPy a ses propres types, conçus pour le calcul rapide. Ils s'utilisent comme des nombres normaux (addition, comparaison...), mais ce ne sont pas les int / float de Python, et un tableau n'est pas une list. Si un code hors NumPy exige un vrai entier ou flottant Python, on convertit : int(valeur) ou float(valeur).

La clé : quel type de question pose-t-on ? "Quel est le 3e ?" (liste), "Quel est l'âge ?" (dict), "La cellule ligne 1, colonne 2 ?" (tableau 2D), "La moyenne de 10 000 mesures ?" (NumPy).

Tape un dictionnaire ou une grille et regarde la mémoire se construire pas à pas :

Essaie : colle ton dictionnaire arbre ou ton tableau 2D foret et clique sur "Visualize Execution".