dict en Python : associationkeys, values et items, test in. Comparaisond = {"alice": 17, "bob": 16}.d = ()]]>d = []]]>d = {}]]>d = dict().]]>d = dict[]]]>"nom" dans led = {"nom": "Alice"} ?]]>KeyError, onif "nom" in d: avantd["nom"]. Le test"age" in d vaut False si le"age".]]>d(nom)]]>d.nom]]>d["nom"]]]>KeyError.]]>d->nom]]>"age": 17 à un dictionnaire dd.append("age", 17)]]>append n'existed.put("age", 17)]]>d.add("age": 17)]]>add n'existe pasd["age"] = 17]]>len(d) == 0 revientif d: est plusd.length]]>length n'existelen(d)]]>lend.size()]]>size n'existecount(d)]]>count n'est pasfor x in d:, où d est unfor cle, valeur in d.items():
print(cle, valeur)Cette construction est très
pratique pour parcourir un
dictionnaire tout en conservant
l'association entre clé et
valeur.
for k, v in d.items():.]]>for x in d.keys():. Pourfor v in d.values():.for k, v in d.items():.]]>d.values().]]>"nom" existe dans led ?]]>valeur in d.values(). Cetted["nom"]]]>KeyError si la clé estd.has("nom")]]>has n'existe pashas_key existait en Pythond.contains("nom")]]>contains n'existe"nom" in d]]>in testé sur und = {"a": 1, "b": 2}. Que vautlist(d.keys()) ?]]>keys() (lesvalues() (les valeurs) et items() (lesd revient àd.keys().]]>[1, 2]]]>d.values(). La méthode keys ne fournit que['a', 'b']]]>d.keys() fournit les clés dulist(...) les range dans une liste. C'estfor k in d:.]]>[('a', 1), ('b', 2)]]]>(clé, valeur) sontd.items(), pas par keys.]]>['a', 1, 'b', 2]]]>keys nevalues que les valeurs.]]>nom = "Alice"
d = {"Alice": 17}
print(d[nom])d["Alice"]), une variable (d[nom])d[nom] (valeur de lad["nom"] (chaîne littérale) éviteKeyError.]]>KeyError, car nom n'est pas une clé de d]]>nom, qui vaut"Alice". C'est cette chaîne qui sert de clé,17]]>d[nom] équivaut àd["Alice"], puisque nom contient la chaîne"Alice". La valeur associée, $17$, estAlice]]>Alice n'estnom.]]>KeyError, car il manque les guillemets autour de nom]]>d["nom"]"nom", absente, et c'estKeyError surviendrait. Sansnom est une variable dont la"Alice" sert de clé.]]>mots ?]]>in évite la KeyErrorc = {}
for m in mots:
if m in c:
c[m] = c[m] + 1
else:
c[m] = 1]]>m in c distingue lac = {}
for m in mots:
c[m] = c[m] + 1]]>c[m] + 1 lit c[m] avant d'écrire.KeyError.if m in c.]]>c = {}
for m in mots:
if m in c:
c[m] = c[m] + 1
else:
c[m] = 0]]>["a", "b", "a"], on{"a": 1, "b": 0} au lieu de{"a": 2, "b": 1}.]]>c = {}
for m in mots:
c[m] = 1]]>d = {"fruits": ["pomme"]}
d["fruits"].append("poire")
print(d)d["fruits"] renvoie l'objet lui-même, les{'fruits': ['pomme', 'poire']}]]>d["fruits"] renvoie la listeappend allonge donc cette liste, etd.]]>{'fruits': ['pomme']}]]>d["fruits"] ne copie pas laappend agit sur l'objet même qui est{'fruits': ['poire']}]]>append ajoute un élément à la fin ded["fruits"] = ["poire"]AttributeError, car un dictionnaire n'a pas de méthode append]]>dd["fruits"], qui est une liste. Uneappend.]]>d.items() ?]]>keys() pour lesvalues() pour lesitems() pour lesd.keys(). Laitems renvoied.values(). La méthodeitems renvoie les paireslen(d).]]>(clé, valeur)]]>for k, v in d.items():.]]>str (chaîne)]]>tuple, à condition que tous ses éléments soient eux-mêmes utilisables comme clés]]>list (liste)]]>d[[1, 2]] = 5 provoqueTypeError.]]>int (entier)]]>{"chat": "cat", "chien": "dog"}]]>traduction["chat"]"cat".]]>("chat", "cat")]]>["chat", "cat", "chien", "dog"]]]>chat = "cat"; chien = "dog"]]>noms = ["Lou", "Max"]
ages = [16, 17]
d = {}
for i in range(len(noms)):
d[noms[i]] = ages[i]
print(d)range(len(noms)) permetd[cle] = valeur remplit le{'Lou': 16, 'Max': 17}]]>noms[i] fournitages[i] la valeur de même rang.d[cle] = valeur crée l'entrée{16: 'Lou', 17: 'Max'}]]>d[noms[i]] = ages[i],{0: 'Lou', 1: 'Max'}]]>i ne sert qu'à lire les deuxnoms[i], une chaîne.]]>KeyError, car les clés 'Lou' et 'Max' n'existent pas encore]]>KeyError ne concerne que lad, et l'affectation crée la clé si ellestock = {"pommes": 12, "poires": 5, "kiwis": 8}
def quantite(fruit):
return stock[fruit]
print(sorted(stock, key=quantite))Qu'affiche ce programme ?
]]>sorted appliqué à un dictionnaire trie ses clés. Avec unequantite, qui renvoie la valeur associée['poires', 'kiwis', 'pommes']]]>sorted(stock) trie les clés, etkey=quantite les compare selon la valeur[5, 8, 12]]]>sorted renvoie donc des noms de fruits ;['kiwis', 'poires', 'pommes']]]>sorted(stock) sans fonction clé. Ici, quantite[('poires', 5), ('kiwis', 8), ('pommes', 12)]]]>stock.items().sorted(stock, key=quantite) ne trie que les clés etinscrits associe à chaque atelier la liste deTrue exactementinscrits ne contient aucune entrée ?]]>len,len({}) vaut $0$. Comparer unlen(inscrits) == 0]]>len renvoie le nombre d'entréesinscrits == []]]>False, y compris pour {}.]]>inscrits[0] == 0]]>inscrits[0] cherche la clé 0. Sur unKeyError.]]>inscrits.values() == 0]]>values() renvoie les valeurs duFalse.]]>RuntimeError si la taille change, ou queRuntimeError au lieu deRuntimeErrorfor k in list(d):.]]>in teste la présence d'une clé, pas celle d'une valeur]]>k in dk parmi lesv in d.values().]]>d[k] = v avec une clé k déjà présente remplace l'ancienne valeur]]>items() permet de parcourir les couples (clé, valeur)]]>for k, v in d.items():stock = {"stylo": 5, "cahier": 12, "gomme": 3}sum(stock.values()) ?]]>d.keys() (les clés), d.values() (les valeurs)d.items() (les couples). Combinées avec lessum, max, min ou len,values agit sur les valeurs, pas sursum accepte parfaitementvaluesstock.values() renvoie une vue[5, 12, 3], et sum calculelen(stock)).d auxinv où les clés et les valeurs sontinv[v] = k écrase celle déjà rangée sous cetteinv = {}
for k in d:
inv[v] = k]]>for k in d ne fournit quek ; la variable v n'est définie nulleNameError. Il fautd[k] ou par items().]]>inv = {}
for v in d.values():
inv[v] = d[v]]]>d, et d[v] cherche une valeur parmi lesKeyError dès le premier tour.d.]]>inv = {}
for k, v in d.items():
inv[v] = k]]>items() fournit chaque couple(clé, valeur), dépaqueté dans k et v.inv[v] = k range le coupleinv = {}
for k, v in d.items():
inv[k] = v]]>inv[k] = v recopied, pas son inverse ; il fautinv[v] = k.]]>couples = [("rouge", 1), ("vert", 2), ("bleu", 3)]
couleurs = {}
for c in couples:
couleurs[c[1]] = c[0]
print(couleurs[2])Qu'affiche ce programme ?
]]>couleurs[c[1]] = c[0], l'expression entre crochets estvert]]>c[1] est le numéro et c[0] le nom,{1: 'rouge', 2: 'vert', 3: 'bleu'}. La clé 2 est"vert".]]>bleu]]>couleurs[2] ne désigne pas la troisième2, soit "vert".]]>2]]>2 est la clé cherchée, pas la valeur.couleurs[c[1]] = c[0] associe à chaqueKeyError]]>couleurs[c[1]] = c[0] prend les numéros2 existe bien.]]>d[valeur] = True danssaisie in d,saisie in d retrouve la cléd = {[1, 2]: "premier"} provoque uneTypeError. En revanche,d = {(1, 2): "premier"} est acceptée. Pourquoi cette{"nom": "Dupont", "age": 17}]]>("nom", "Dupont", "age", 17)]]>["nom", "age"]]]>"nom=Dupont;age=17"]]>photo = {"largeur": 4000, "hauteur": 3000, "iso": 200, "date": "2026-07-14"}Quelle expression donne la hauteur de la photo ?
]]>photo["hauteur"] vaut $3000$. Les données EXIFphoto["hauteur"]]]>photo[1]]]>KeyError. Un dictionnaire ne se lit pas parphoto.hauteur]]>AttributeError : unphoto("hauteur")]]>TypeError.]]>eleves = [{"nom": "Lina", "note": 14},
{"nom": "Noah", "note": 9},
{"nom": "Ava", "note": 17}]
meilleur = eleves[0]
for e in eleves:
if e["note"] > meilleur["note"]:
meilleur = e
print(meilleur["nom"])
Qu'affiche ce programme ?
]]>note)nom.]]>Ava]]>meilleur prend l'enregistrement de plus hauteAva a $17$.]]>Lina]]>Lina est seulement le point de départ ; elleAva au troisième tour.]]>17]]>nom de{"nom": "Ava", "note": 17}]]>print reçoit meilleur["nom"], une chaîne, pasd = {1: "un", "1": "one"}
print(len(d), d[1])input, toujours une chaîne,2 un]]>1 et la chaîne "1" sont deuxd[1]1 one]]>2 one]]>d[1] sans guillemets vise la clé entière, associée"un".]]>1 et "1" n'ont pas la même écriture ni le mêmegrille[(2, 3)] = "rouge". Pourquoi ce"2, 3"]]>d = {0.3: "trois dixièmes"}
print(0.1 + 0.2 in d)False, 0.1 + 0.2 n'étant pas exactement 0.3]]>True, les deux valeurs étant égales à 0.3]]>0.1 + 0.2 n'est pas exactement 0.3.]]>trois dixièmes, la valeur associée]]>in renvoie un booléen, pas une valeur.]]>stock = {"pommes": 10, "poires": 4, "pommes": 25}
print(len(stock), stock["pommes"])2 25]]>"pommes" remplace la première. Il reste deux clés.]]>3 10]]>2 10]]>for cle in d: parcourt-il les clés d'unsorted(d).]]>notes = {"Lou": 12, "Sami": 9, "Inès": 15}
n = 0
for prenom in notes:
if notes[prenom] > 10:
n = n + 1
print(n)d[cle] est le2]]>notes[prenom] et compte celles qui dépassent 10.]]>3]]>0]]>prenom étant une clé et non une note]]>notes[prenom] donne bien la note associée à la clé.]]>prix = {"stylo": 2, "cahier": 5, "gomme": 1}
pas_cher = {}
for article, p in prix.items():
if p < 3:
pas_cher[article] = p
print(pas_cher){'stylo': 2, 'gomme': 1}]]>items fournit chaque couple clé-valeur ; les{'cahier': 5}]]>['stylo', 'gomme']]]>pas_cher est un dictionnaire, les valeurs sont{'stylo': 2, 'cahier': 5, 'gomme': 1}]]>if écarte le cahier.]]>