Lire, modifier
e.get(i) se fait en temps constant : la case d’indice i est lue directement2.
Programmation · Prog 10 · Ranger les données
Une liste, un dictionnaire ou un ensemble : à chaque besoin son rangement.
Déjà à l'aise ? Aller directement au quizLes élèves d’une classe, une playlist, les notes de chacun, les inscrits d’un tournoi : on range sans cesse des données en groupe.
Mais pas toujours de la même façon.
Selon ce qu’on veut faire, on choisit un rangement différent.
Garder l’ordre, retrouver vite par un nom, éviter les doublons : une liste, un dictionnaire, un ensemble.
À chaque besoin, son rangement.
Ben oui, comment faire autrement ?
Un tableau a une taille fixe
Dans la vraie vie
Une boîte à œufs a six places, pas une de plus.
Un septième œuf ? Il faut une boîte plus grande, et y déplacer tous les autres.
new int[5]
En Java, new int[5] réserve cinq cases, pas une de plus (Prog 6). Une collection fait le déménagement pour toi : elle grandit toute seule, avec add, remove, contains…
int[] notes = new int[5];
// 5 cases, pour toujoursList<Integer> notes = new ArrayList<>();
notes.add(5); // grandit toute seuleEt en Python ?
Pas de tableau à taille fixe dans le langage de base : la list de Python grandit toute seule, comme ArrayList en Java ou Array en JavaScript.
Des éléments dans l’ordre, numérotés depuis 0
Dans la vraie vie
Dans une file au guichet, chacun a sa place : 1re, 2e, 3e…
Arriver au bout, c’est facile. Se glisser devant, c’est faire reculer tous ceux qui suivent.
liste
Une liste garde l’ordre d’arrivée et accepte les doublons. La 1re place a l’indice 0. En coulisse, une ArrayList range ses éléments dans un tableau un peu plus grand que nécessaire : sa capacité.
Où s’arrête la file.
Dans la file, le premier qui part fait avancer tout le monde ; remove(0) aussi décale toute la liste. Pour une vraie file d’attente, Java a ArrayDeque, qui retire le premier en temps constant7.
Six opérations sur une liste de capacité 4 : ajouter, insérer, agrandir, retirer, lire. Fais défiler.
Une liste vide, avec une capacité de 4 : le tableau caché a 4 cases, la taille vaut 0.
e.get(i) se fait en temps constant : la case d’indice i est lue directement2.
En temps constant « amorti » : de temps en temps, le tableau caché est plein et doit être recopié dans un plus grand.
Tous les éléments suivants se décalent : c’est proportionnel à la taille de la liste.
Python, Java, JavaScript, Go et R : touche un langage. Attention, R compte depuis 1.
eleves = []
eleves.append("Léa") # à la fin
eleves.append("Noah")
eleves.insert(1, "Zoé") # à l'indice 1
print(eleves, len(eleves)) # ['Léa', 'Zoé', 'Noah'] 3
del eleves[0] # retire l'indice 0
print(eleves[1]) # Noah
for e in eleves:
print(e)List<String> eleves = new ArrayList<>();
eleves.add("Léa");
eleves.add("Noah");
eleves.add(1, "Zoé"); // insère à l'indice 1
System.out.println(eleves); // [Léa, Zoé, Noah]
eleves.remove(0); // retire l'indice 0
System.out.println(eleves.get(1)); // Noah
for (String e : eleves) {
System.out.println(e);
}const eleves = [];
eleves.push("Léa");
eleves.push("Noah");
eleves.splice(1, 0, "Zoé"); // insère à l'indice 1
console.log(eleves.length); // 3
eleves.splice(0, 1); // retire l'indice 0
console.log(eleves[1]); // Noah
for (const e of eleves) {
console.log(e);
}eleves := []string{} // une slice vide
eleves = append(eleves, "Léa")
eleves = append(eleves, "Noah")
premier := eleves[0]
eleves = append(eleves[:0], eleves[1:]...) // retire l'indice 0
fmt.Println(premier, len(eleves))
for i, e := range eleves {
fmt.Printf("[%d] %s\n", i, e)
}eleves <- c() # vecteur vide
eleves <- c(eleves, "Léa")
eleves <- c(eleves, "Noah")
premier <- eleves[1] # en R, on compte depuis 1
eleves <- eleves[-1] # retire le 1er élément
length(eleves)Touche la bonne réponse.
notes = [4, 5.5, 6]
notes.insert(1, 3)
print(notes)List<Integer> l = new ArrayList<>(List.of(10, 20, 30));
l.remove(1);
System.out.println(l);Laquelle de ces opérations devient lente quand la liste est très longue ?
Retrouver une valeur par sa clé
Dans la vraie vie
Dans un classeur à onglets, la fiche de Tom se range sous T.
Pas besoin de feuilleter tout le classeur : on va droit au bon onglet. Tom et Tim s’y retrouvent ? On compare juste ces fiches-là.
clé → valeur
Un dictionnaire associe chaque clé (un prénom) à une valeur (sa note). À partir de la clé, il calcule un nombre, le hachage, qui désigne directement la case où chercher.
Mieux que la première lettre.
Là s’arrête le classeur : le vrai hachage tient compte de toute la clé et répartit bien mieux. Dans une HashMap de 8 cases, Tom va en case 3, Tim en case 1.
Une HashMap Java de 8 cases, avec les vrais numéros de case : quatre clés, une recherche, une collision.
Une table de 8 cases, numérotées de 0 à 7. Chaque clé ira dans la case que son hachage désigne.
Et alors, laquelle on prend ?
Un vrai programme, ligne par ligne : une liste de bulletins, un dictionnaire qui compte les voix.
votes = ["Léa", "Tom", "Léa", "Mia", "Léa", "Tom"]compte = {}for v in votes: compte[v] = compte.get(v, 0) + 1print(compte)
Six bulletins, un dictionnaire. Une liste garde les votes dans l’ordre ; le dictionnaire compte les voix de chaque prénom.
Lignes 1 à 3. La liste votes contient six bulletins, avec des doublons. compte part vide : aucune clé.
Premier tour : v vaut "Léa". La clé est absente, get(v, 0) renvoie 0 au lieu d’une erreur : compte["Léa"] vaut 1.
Deuxième tour : "Tom". Nouvelle clé, rangée après Léa : un dictionnaire Python garde l’ordre d’insertion.
Troisième tour : "Léa" encore. La clé existe : get renvoie 1, on range 2 sous la même clé. Pas de doublon de clé, la valeur est remplacée.
Les trois derniers tours : Mia, Léa, Tom. Mia entre avec 1, Léa monte à 3, Tom à 2.
Ligne 6 : l’affichage. {'Léa': 3, 'Tom': 2, 'Mia': 1}, dans l’ordre où les clés sont apparues.
Python, Java, JavaScript et Go : touche un langage pour voir les mêmes notes rangées par prénom.
notes = {"Léa": 5.5, "Tom": 4.0}
notes["Lina"] = 6.0 # ajoute une paire
notes["Léa"] = 5.0 # même clé : valeur remplacée
print(notes["Tom"]) # 4.0
print("Zoé" in notes) # False
print(notes.get("Zoé")) # None, sans erreur
for nom, note in notes.items():
print(nom, note)Map<String, Double> notes = new HashMap<>();
notes.put("Léa", 5.5);
notes.put("Tom", 4.0);
notes.put("Léa", 5.0); // valeur remplacée
System.out.println(notes.get("Tom")); // 4.0
System.out.println(notes.get("Zoé")); // null
System.out.println(notes.getOrDefault("Zoé", 0.0)); // 0.0
for (Map.Entry<String, Double> e : notes.entrySet()) {
System.out.println(e.getKey() + " : " + e.getValue());
}const notes = new Map();
notes.set("Léa", 5.5);
notes.set("Tom", 4);
notes.set("Léa", 5); // valeur remplacée
console.log(notes.get("Tom")); // 4
console.log(notes.get("Zoé")); // undefined
console.log(notes.has("Tom")); // true
for (const [nom, note] of notes) {
console.log(`${nom} : ${note}`);
}notes := map[string]float64{"Léa": 5.5, "Tom": 4.0}
notes["Léa"] = 5.0 // valeur remplacée
note, existe := notes["Zoé"] // 0 false : absente
fmt.Println(note, existe)
delete(notes, "Tom")
for nom, n := range notes { // ordre non garanti
fmt.Println(nom, n)
}Ranger une valeur sous une clé déjà présente remplace l’ancienne valeur1.
notes["Zoé"] lève KeyError en Python ; get renvoie None (Python), null (Java), undefined (JavaScript)6.
get et put prennent un temps constant tant que le hachage répartit bien les clés3. Beaucoup de collisions ralentiraient la recherche.
Une HashMap Java ne garantit aucun ordre (il faut LinkedHashMap). Un dict Python et une Map JavaScript gardent l’ordre d’insertion.
Piège Java
double x = notes.get("Zoé"); compile. Mais get renvoie null, qui ne rentre pas dans un double : NullPointerException.
Utilise getOrDefault("Zoé", 0.0), ou teste containsKey d’abord.
Que se passe-t-il ?
d = {"Léa": 5.5}
d["Léa"] = 5
print(d)d = {"Léa": 5}
print(d["Tom"])Map<String, Double> notes = new HashMap<>();
double x = notes.get("Zoé");Pas de doublon, pas d’ordre
Dans la vraie vie
Dans un album de vignettes, chaque vignette a sa place.
Un double ? Il ne rentre pas, la place est prise. Et pour savoir si tu as la 7, tu regardes directement sa case.
ensemble
Un ensemble garde chaque élément une seule fois et ne promet aucun ordre. Pas de cases numérotées visibles : le hachage choisit la place, comme dans un dictionnaire. Un HashSet Java repose d’ailleurs sur une HashMap4.
Les inscriptions arrivent : un doublon, puis deux tests d’appartenance. Fais défiler.
Un ensemble vide. Chaque pseudo inscrit y entrera une seule fois.
Et avec une liste ?
Python, Java et JavaScript : touche un langage. En Python, l’union, l’intersection et la différence s’écrivent avec |, & et -.
inscrits = set() # pas {} : c'est un dict vide
inscrits.add("Léa")
inscrits.add("Noah")
inscrits.add("Léa") # déjà là : rien ne change
print(len(inscrits)) # 2
print("Emma" in inscrits) # False
a = {"Léa", "Noah", "Emma"}
b = {"Noah", "Tom"}
print(a | b) # union : les 4 pseudos
print(a & b) # intersection : {'Noah'}
print(a - b) # différence : Léa et EmmaSet<String> inscrits = new HashSet<>();
System.out.println(inscrits.add("Léa")); // true
System.out.println(inscrits.add("Léa")); // false : déjà présent
System.out.println(inscrits.size()); // 1
System.out.println(inscrits.contains("Emma")); // falseconst inscrits = new Set(["Léa", "Noah"]);
inscrits.add("Léa"); // déjà là
console.log(inscrits.size); // 2
console.log(inscrits.has("Emma")); // falsePiège Python
{} crée un dictionnaire vide, pas un ensemble. Un ensemble vide s’écrit set()1.
En revanche, {"Léa", "Noah"}, avec des éléments, est bien un ensemble.
Trois questions pour choisir
Dans la vraie vie
Une course à pied : l’ordre d’arrivée, le coureur derrière chaque dossard, les pays représentés.
Trois besoins, trois rangements. Le pays déjà noté ne compte pas deux fois.
Arrivée, playlist, notes dans l’ordre des tests : une liste.
Le numéro d’un ami, le stock d’un article, les votes d’un candidat : un dictionnaire.
Les pays visités, les mots différents d’un texte : un ensemble.
« Rapide » veut dire un temps qui ne grandit pas avec le nombre d’éléments : O(1). « Lent », un temps proportionnel à ce nombre : O(n).
Pour garder les éléments triés en permanence, Java propose aussi TreeMap et TreeSet.
Range chaque besoin dans la bonne case.
Remets les lignes dans l'ordre. texte contient « le chat voit le chien et le chat » ; le programme doit afficher {'le': 3, 'chat': 2, 'voit': 1, 'chien': 1, 'et': 1}.
Remettre la classe dans l’ordre
Dans la vraie vie
Pour la photo de classe, le photographe range les élèves du plus grand au plus petit.
Deux élèves de même taille ? Il les laisse dans l’ordre où ils étaient.
sorted(…, key=…)
Trier, c’est choisir un critère : la taille pour la photo, la note dans le code. En Python, sorted() renvoie une nouvelle liste triée, list.sort() trie sur place. Le paramètre key dit selon quoi trier.
La même classe triée deux fois : par prénom, puis par note décroissante. Fais défiler.
L'ordre d'origine : celui dans lequel les élèves ont été ajoutés à la liste.
Trier une liste de tuples par prénom, puis par note décroissante avec key et reverse.
classe = [("Léa", 5.5), ("Noah", 4.5), ("Emma", 6),
("Tom", 4.5), ("Zoé", 5.5)]
par_nom = sorted(classe) # compare d'abord le prénom
par_note = sorted(classe, key=lambda e: e[1], reverse=True)
print([nom for nom, note in par_note])
# ['Emma', 'Léa', 'Zoé', 'Noah', 'Tom']Un tri stable.
Les tris de Python sont garantis stables : deux éléments égaux pour le critère gardent leur ordre d’origine5. Léa reste devant Zoé (5,5), Noah devant Tom (4,5). Collections.sort en Java et sort en JavaScript sont stables aussi.
La fiche en six cartes
Garde l’ordre et les doublons ; lire par indice et ajouter à la fin sont rapides, insérer au début décale tout.
Des clés uniques associées à des valeurs ; le hachage désigne la case où chercher.
KeyError avec les crochets en Python ; None, null ou undefined avec get.
Refuse les doublons et teste l’appartenance rapidement, en moyenne.
L’ordre compte : liste. On cherche par clé : dictionnaire. Pas de doublon : ensemble.
sorted(…, key=…) ; les tris de Python, Java et JavaScript sont stables.
Dix questions, zéro faute
Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.
10 questions · zéro faute · chronomètre
Les vidéos de Graven, en français, sur les listes et les dictionnaires en Java et en Python.
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Extraits exécutés : Python 3.14, Java 21, Node 25 ; les numéros de case de la HashMap ont été calculés avec Java. Extraits Go et R relus (compilateurs non disponibles).