Types construits : tuples, tableaux et dictionnaires
Première · NSI · Représentation des données
Représentation des données
p-uplets et tableaux : ranger des valeurs en séquence
Les types simples (int, float, bool, str) ne stockent qu'une valeur à la fois. Dès qu'on veut manipuler les notes d'une classe, les coordonnées d'un point ou les lignes d'un fichier, il faut regrouper plusieurs valeurs dans un même objet : ce sont les types construits. Ils se distinguent par deux questions simples : comment accède-t-on à un élément, et peut-on le modifier ?
Indexation et tranches
Si L = [10, 20, 30, 40], alors L[0] vaut 10, L[1] vaut 20 et L[3] vaut 40. Le dernier indice valide est donc len(L) − 1, soit 3 ici : demander L[4] déclenche une erreur IndexError.
Python autorise aussi les indices négatifs, qui comptent depuis la fin : L[-1] est le dernier élément (40), L[-2] l'avant-dernier (30). Très pratique pour éviter d'écrire L[len(L)-1].
Enfin, une tranche (slice) extrait un sous-tableau : L[1:3] donne [20, 30]. Attention, la borne de gauche est incluse et celle de droite exclue — la tranche contient donc 3 − 1 = 2 éléments.
| Critère | p-uplet (tuple) | Tableau (liste) | Dictionnaire |
|---|---|---|---|
| Notation | (3, 7) | [3, 7] | {"x": 3, "y": 7} |
| Accès à un élément | par indice : t[0] | par indice : L[0] | par clé : d["x"] |
| Modifiable après création | non | oui | oui |
| Ordre garanti | oui | oui | oui (ordre d'insertion) |
| Usage typique | regrouper des données hétérogènes qui vont ensemble | collection d'éléments de même nature, que l'on parcourt | associer une information à un identifiant |
Représentation des données
Dictionnaires et tableaux à deux dimensions
Un tableau range les valeurs par position. Mais pour retrouver la note de Léa, la position ne sert à rien : ce qu'on veut, c'est chercher par nom. C'est exactement le rôle du dictionnaire, qui remplace l'indice numérique par une clé choisie par le programmeur.
Les opérations utiles sur un dictionnaire
| Écriture | Effet | Sur notes = {"Lea": 15, "Sam": 12} |
|---|---|---|
| notes["Lea"] | Lit la valeur associée à la clé | renvoie 15 |
| notes["Zoe"] | Lit une clé absente | déclenche une erreur KeyError |
| notes.get("Zoe", 0) | Lit avec une valeur par défaut | renvoie 0, sans erreur |
| "Sam" in notes | Teste la présence d'une CLÉ | renvoie True |
| len(notes) | Compte les couples | renvoie 2 |
| notes.keys() | Donne les clés | "Lea", "Sam" |
| notes.values() | Donne les valeurs | 15, 12 |
| notes.items() | Donne les couples (clé, valeur) | ("Lea", 15), ("Sam", 12) |
Le parcours mérite une attention particulière : la boucle for k in notes: parcourt les clés, pas les valeurs. Pour disposer des deux à la fois, on écrit for cle, valeur in notes.items():, qui décompose chaque couple en deux variables.
Grand avantage du dictionnaire : la recherche par clé est quasi immédiate, quelle que soit la taille du dictionnaire, alors que chercher une valeur dans un tableau oblige à le parcourir élément par élément.
Les tableaux à deux dimensions
Pour représenter une grille, une image ou un plateau de jeu, on utilise un tableau de tableaux : chaque élément du tableau principal est une ligne.
T = [[1, 2, 3], [4, 5, 6]]
Ici len(T) = 2 (deux lignes) et len(T[0]) = 3 (trois colonnes). L'accès se fait avec deux indices, ligne d'abord, colonne ensuite : T[1][2] vaut 6, car T[1] est la ligne [4, 5, 6] et son élément d'indice 2 est 6.
Le parcours complet se fait avec deux boucles imbriquées : for i in range(len(T)): for j in range(len(T[i])): et l'on traite T[i][j].
Exercices corrigés
En Python, à quel type correspond l'objet (3, 7) ?
- A.Un tableau (liste), modifiable
- B.Un dictionnaire à deux clés
- C.Un p-uplet (tuple), non modifiableBonne réponse
- D.Une chaîne de caractères
Réponse : C — Un p-uplet (tuple), non modifiable
Les parenthèses signalent un p-uplet, ou tuple : une séquence ordonnée dont on ne peut plus changer le contenu une fois créée. Les crochets, eux, désignent une liste (modifiable) et les accolades un dictionnaire. Retiens le repère visuel : parenthèses = figé, crochets = évolutif.
On pose L = [10, 20, 30, 40]. Que vaut L[2] ?
- A.40
- B.10
- C.20
- D.30Bonne réponse
Réponse : D — 30
Comptons en partant de 0 : L[0] vaut 10, L[1] vaut 20, L[2] vaut 30 et L[3] vaut 40. L'indice 2 désigne donc le TROISIÈME élément, c'est-à-dire 30. Répondre 20, c'est le réflexe naturel de compter à partir de 1 — c'est le décalage le plus classique en début d'année, à corriger vite.
Quelle opération est IMPOSSIBLE sur un p-uplet (tuple) ?
- A.Modifier la valeur d'un de ses élémentsBonne réponse
- B.Lire un de ses éléments par son indice
- C.Connaître son nombre d'éléments avec len
- D.Le parcourir avec une boucle for
Réponse : A — Modifier la valeur d'un de ses éléments
Un tuple est non modifiable : écrire t[0] = 5 déclenche une TypeError. En revanche, tout ce qui relève de la LECTURE fonctionne parfaitement — accès par indice, len, parcours, tranche. Le tuple n'est donc pas un type au rabais : il est simplement figé, ce qui garantit que personne ne modifiera les données par accident.
On pose d = {"a": 1, "b": 2}, puis on exécute d["c"] = 3. Que se passe-t-il ?
- A.Le couple "c" : 3 est ajouté au dictionnaireBonne réponse
- B.Une erreur KeyError, car la clé "c" n'existe pas
- C.La valeur associée à "a" est remplacée par 3
- D.Rien, car un dictionnaire n'est pas modifiable
Réponse : A — Le couple "c" : 3 est ajouté au dictionnaire
L'affectation d[cle] = valeur a deux effets possibles : si la clé existe déjà, la valeur est remplacée ; si elle n'existe pas, le couple est ajouté. Le dictionnaire vaut donc désormais {"a": 1, "b": 2, "c": 3}. L'erreur KeyError ne survient qu'en LECTURE d'une clé absente, comme d["c"] tout seul à droite d'une affectation. C'est une distinction essentielle : lire une clé absente échoue, l'écrire la crée.
Quelle expression construit par compréhension le tableau des carrés des entiers de 0 à 4, soit [0, 1, 4, 9, 16] ?
- A.[i * 2 for i in range(5)]
- B.[i ** 2 for i in range(5)]Bonne réponse
- C.[i ** 2 for i in range(4)]
- D.[i ** 2 in range(5)]
Réponse : B — [i ** 2 for i in range(5)]
L'opérateur puissance en Python est **, donc i ** 2 donne le carré. Et range(5) produit 0, 1, 2, 3, 4 : cinq valeurs, la borne étant exclue. Le résultat est bien [0, 1, 4, 9, 16]. Le distracteur i * 2 donnerait les doubles [0, 2, 4, 6, 8], une confusion très fréquente. Avec range(4) il manquerait le 16, et la dernière écriture n'est pas syntaxiquement valide, faute du mot-clé for.
On exécute for k in d: avec d un dictionnaire. Que prend successivement la variable k ?
- A.Les valeurs du dictionnaire
- B.Les couples (clé, valeur)
- C.Les indices 0, 1, 2, …
- D.Les clés du dictionnaireBonne réponse
Réponse : D — Les clés du dictionnaire
Par convention, parcourir un dictionnaire directement parcourt ses CLÉS — c'est équivalent à for k in d.keys(). Si tu veux les valeurs, écris for v in d.values() ; si tu veux les deux à la fois, écris for k, v in d.items(), qui décompose chaque couple en deux variables. Un dictionnaire n'a pas d'indices numériques, à moins que ses clés ne soient elles-mêmes des entiers.
On pose T = [[1, 2, 3], [4, 5, 6]]. Que vaut T[1][2] ?
- A.2
- B.6Bonne réponse
- C.3
- D.5
Réponse : B — 6
On lit les indices de gauche à droite : d'abord la ligne, ensuite la colonne. T[1] est la deuxième ligne, soit [4, 5, 6]. Puis on y prend l'élément d'indice 2, c'est-à-dire le troisième : 6. Répondre 3, c'est avoir inversé les indices et lu T[0][2] ; répondre 5, c'est avoir compté les colonnes à partir de 1. Répète-toi la formule : T[ligne][colonne].
On construit T = [[0] * 4 for i in range(3)]. Que valent len(T) et len(T[0]) ?
- A.len(T) = 4 et len(T[0]) = 3
- B.len(T) = 12 et len(T[0]) = 4
- C.len(T) = 3 et len(T[0]) = 4Bonne réponse
- D.len(T) = 3 et len(T[0]) = 3
Réponse : C — len(T) = 3 et len(T[0]) = 4
Décortiquons : la compréhension for i in range(3) fabrique trois lignes, donc len(T) = 3. Chaque ligne vaut [0] * 4, c'est-à-dire [0, 0, 0, 0], soit quatre colonnes : len(T[0]) = 4. La grille compte au total 3 × 4 = 12 cases, mais len(T) ne compte que les lignes, jamais les cases — c'est le sens du distracteur 12. Retiens la lecture : len(T) donne le nombre de LIGNES, len(T[0]) le nombre de COLONNES.
On écrit T = [[0] * 3] * 2 puis T[0][0] = 1. Que vaut T ensuite ?
- A.[[1, 0, 0], [0, 0, 0]]
- B.[[1, 0, 0], [1, 0, 0]]Bonne réponse
- C.[[1, 1, 1], [0, 0, 0]]
- D.Une erreur est déclenchée
Réponse : B — [[1, 0, 0], [1, 0, 0]]
L'expression [0] * 3 crée bien une ligne [0, 0, 0]. Mais le second * 2 ne la duplique pas : il place DEUX FOIS la référence vers la même et unique ligne. T[0] et T[1] désignent donc le même objet en mémoire. Modifier T[0][0] modifie mécaniquement T[1][0], et le tableau devient [[1, 0, 0], [1, 0, 0]]. C'est le piège n° 1 des tableaux à deux dimensions. La construction correcte est T = [[0] * 3 for i in range(2)] : la compréhension évalue [0] * 3 à chaque tour et crée donc une ligne neuve à chaque fois.
Quel est l'indice du premier élément d'un tableau en Python ?
- A.1
- B.0Bonne réponse
- C.-1
- D.Cela dépend de la longueur du tableau
Réponse : B — 0
En Python, comme dans la grande majorité des langages, l'indexation commence à 0. Le premier élément est donc L[0] et le dernier L[len(L) − 1]. L'indice -1 est valide, mais il désigne le DERNIER élément, pas le premier : c'est la notation d'indice négatif, qui compte depuis la fin.
Que renvoie len([4, 7, 2, 9]) ?
- A.4Bonne réponse
- B.3
- C.9
- D.22
Réponse : A — 4
La fonction len compte le NOMBRE d'éléments du tableau : il y en a quatre, donc elle renvoie 4. Répondre 3 confond avec le plus grand indice valide (les indices vont de 0 à 3). Répondre 9 donne le plus grand élément, et 22 en calcule la somme : ce ne sont pas du tout le rôle de len.
Dans un dictionnaire, comment accède-t-on à une valeur ?
- A.Par sa position dans le dictionnaire
- B.En parcourant tout le dictionnaire jusqu'à la trouver
- C.Par un indice entier commençant à 0
- D.Par sa clé, écrite entre crochetsBonne réponse
Réponse : D — Par sa clé, écrite entre crochets
C'est toute la différence avec un tableau : le dictionnaire remplace l'indice numérique par une clé choisie par le programmeur. On écrit notes["Sam"] pour obtenir la valeur associée à "Sam". L'écriture notes[0] ne fonctionne que si 0 est lui-même une clé du dictionnaire, ce qui est rare. Et l'accès est direct, sans avoir à parcourir quoi que ce soit.
S'entraîner sur ce chapitre
Ce chapitre compte 35 exercices corrigés dans l'application, avec le suivi de ta progression.
Commencer les exercices