Aller au contenu

Parcours

I. Parcourir un dictionnaire⚓︎

Testez

Utilisons la même syntaxe que celle employée avec les listes python :

###
fermepy-undgaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}bksl-nlfor animal in fermepy-undgaston:bksl-nl print(animal)bksl-nlbksl-nl



Question

Nous disposons du dictionnaire : mon_dictionnaire.
Le parcours avec la boucle for element in mon_dictionnaire se fait :

  • sur les clés du dictionnaire.
  • sur les valeurs du dictionnaire.
  • sur les paires clé, valeur du dictionnaire.
  • sur les indices du dictionnaires
  • ✅ sur les clés du dictionnaire.
  • ❌ sur les valeurs du dictionnaire.
  • ❌ sur les paires clé, valeur du dictionnaire.
  • ❌ sur les indices du dictionnaires Il n'y a pas d'"indices" pour des dictionnaires

🐘 À retenir

Soit le dictionnaire mon_dictionnaire
Le parcours d'un dictionnaire se fait sur ses clés en écrivant :

🐍 Script Python
for cle in mon_dictionnaire :
    ...
Gaston fait ses courses

Gaston va faire ses courses dans une boutique "prix ronds". Mais comme il est passionné de Python, il a créé un dictionnaire pour représenter ses achats appelé achats et un autre pour représenter le prix de chaque article appelé prix. Exemple pour l'achat d'un kg de farine,d'une plaquette de beurre, et d'un kg de sucre.
Il connait les prix suivants :

produit 1kg de farine 1 kg de sucre 1 l de lait 1 plaquette de beurre
prix 1 3 2 2

Voici par exemple les dictionnaires :

🐍 Script Python
achats = {"farine": 2, "beurre": 1, "sucre": 2}
prix = {"farine": 1, "sucre": 3, "lait": 2, "beurre": 2}  
  • Le dictionnaire achats a pour clés les ingrédients et pour valeur le nombre d'ingrédients correspondants achetés.
    Ici Gaston achète 2kg de farine, 1 plaquette de beurre, 2 kgs de sucre.
  • Le dictionnaire prix a pour clés les ingrédients et pour valeur le prix de chacun.
    Ici 1kg de farine coûte 1 €, 1kg de sucre coûte 3 € etc.

Aidez Gaston à compléter la fonction facture qui prend en paramètres les deux dictionnaires, et renvoie le montant qu'il devra payer pour ses achats. Les valeurs du dictionnaire prix sont des entiers.

###
def facture(achats, prix) -> int:bksl-nl ...bksl-nlbksl-nlbksl-nlmespy-undachats = {"farine": 2, "beurre": 1, "sucre": 2}bksl-nlmespy-undprix = {"farine": 1, "sucre": 3, "lait": 2, "beurre": 2}bksl-nlbksl-nl# Testsbksl-nlassert facture(mespy-undachats, mespy-undprix) == 10bksl-nlbksl-nl



Solution
🐍 Script Python
def facture(achats, prix) -> int:
    a_payer = 0
    for article in achats:
        a_payer = a_payer + achats[article] * prix[article]
    return a_payer

II. Obtenir toutes les valeurs d'un dictionnaire⚓︎

Les notes d'Alice

Alice a créé un dictionnaire avec ses notes de NSI.
Par exemple notes_Alice = {"test_1": 14, "test_2": 16, "test_3": 18} Aidez-là à compléter la fonction qui renvoie une liste des notes qu'elle a obtenues

###
def notes(lespy-undnotes) -> list:bksl-nl ...bksl-nlbksl-nlbksl-nlnotespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlprint(notes(notespy-undAlice))bksl-nlbksl-nl



Solution

On peut penser à la solution suivante :

🐍 Script Python
def notes(les_notes) -> list:
    liste_notes = []
    for devoir in les_notes:
        liste_notes.append(les_notes[devoir])
    return liste_notes
Peut-être n'avez-vous pas pensé à ceci :

On peut utiliser une liste en compréhension

Solution
🐍 Script Python
def notes(les_notes) -> list:
    liste_notes = [les_notes[devoir] for devoir in les_notes]
    return liste_notes

🐘 À retenir

Soit le dictionnaire mon_dictionnaire
on peut obtenir une liste valeurs de toutes les valeurs de ce dictionnaire ainsi :

🐍 Console Python
valeurs = [mon_dictionnaire[cle] for cle in mon_dictionnaire]

Attention

🌵 🌵 Tester ci-dessous

###
def notes(lespy-undnotes) -> list:bksl-nl listepy-undnotes = [lespy-undnotes[devoir] for devoir in lespy-undnotes]bksl-nl return listepy-undnotesbksl-nlbksl-nlprint({"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18} == {"testpy-und3": 18, "testpy-und2": 16, "testpy-und1": 14})bksl-nlprint(notes({"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}))bksl-nlprint(notes({"testpy-und3": 18, "testpy-und2": 16, "testpy-und1": 14}))bksl-nlbksl-nl



👉 Il faut se souvenir qu'un dictionnaire n'est pas ordonné ...

III. Obtenir tous les couples (clé, valeur) d'un dictionnaire⚓︎

Les notes d'Alice

Alice a créé un dictionnaire avec ses notes de NSI.
Par exemple notes_Alice = {"test_1": 14, "test_2": 16, "test_3": 18}
Aidez-là à compléter la fonction qui renvoie une liste de tuples (devoir, note).

###
def bulletin(lespy-undnotes) -> list:bksl-nl ...bksl-nlbksl-nlnotespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlprint(bulletin(notespy-undAlice))bksl-nlbksl-nl



Solution

On peut penser à la solution suivante :

🐍 Script Python
def bulletin(les_notes) -> list:
    liste_notes = []
    for devoir in les_notes:
        liste_notes.append((devoir, les_notes[devoir]))
    return liste_notes
Peut-être n'avez-vous pas pensé à ceci :

On peut utiliser une liste en compréhension

Solution
🐍 Script Python
def bulletin(les_notes) -> list:
    liste_notes = [(devoir, les_notes[devoir]) for devoir in les_notes]
    return liste_notes

🐘 À retenir

Soit le dictionnaire mon_dictionnaire
on peut obtenir une liste des couples (clé, valeur) de ce dictionnaire ainsi :

🐍 Script Python
valeurs = [(cle, mon_dictionnaire[cle]) for cle in mon_dictionnaire]

Attention

🌵 🌵 Tester ci-dessous

###
def bulletin(lespy-undnotes) -> list:bksl-nl listepy-undnotes = []bksl-nl for devoir in lespy-undnotes:bksl-nl listepy-undnotes.append((devoir, lespy-undnotes[devoir]))bksl-nl return listepy-undnotesbksl-nlbksl-nlprint({"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18} == {"testpy-und3": 18, "testpy-und2": 16, "testpy-und1": 14})bksl-nlprint(bulletin({"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}))bksl-nlprint(bulletin({"testpy-und3": 18, "testpy-und2": 16, "testpy-und1": 14}))bksl-nlbksl-nl



👉 Il faut se souvenir qu'un dictionnaire n'est pas ordonné ...

IV. Présentation des trois méthodes keys, values et items⚓︎

Attention

Les objets renvoyés par les méthodes keys, values, items sont d’un type particulier, leur connaissance n’est pas au programme. Par contre les méthodes keys, values et itemsle sont.
👉 Remarquons néanmoins que l'on peut toujours se passer de ces méthodes.

Testez

###
notespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlbksl-nlprint("Parcours avec la méthode keys : ")bksl-nlfor devoir in notespy-undAlice.keys():bksl-nl print(devoir)bksl-nlbksl-nlprint("Parcours avec la méthode values : ")bksl-nlfor note in notespy-undAlice.values():bksl-nl print(note)bksl-nl bksl-nlprint("Parcours avec la méthode items : ")bksl-nlfor (devoir, note) in notespy-undAlice.items():bksl-nl print(devoir, note)bksl-nlbksl-nl



Les vues

🌵 En fait, les objets renvoyés par les méthodes keys, values et items sont des objets que l'on appelle des "vues".
👉 Testez ci-dessous et observez ce qui est renvoyé.

###
notespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlbksl-nlprint("Vue des clés : ")bksl-nlprint(notespy-undAlice.keys())bksl-nlbksl-nlprint("Vue des valeurs : ")bksl-nlprint(notespy-undAlice.values())bksl-nlbksl-nlprint("Vue des items : ")bksl-nlprint(notespy-undAlice.items())bksl-nlbksl-nl



transformer des vues en listes Python

👉 Testez ci-dessous et observez ce qui est renvoyé.

###
notespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlbksl-nlprint("Liste des clés : ")bksl-nlprint(list(notespy-undAlice.keys()))bksl-nlbksl-nlprint("Liste des valeurs : ")bksl-nlprint(list(notespy-undAlice.values()))bksl-nlbksl-nlprint("Liste des items : ")bksl-nlprint(list(notespy-undAlice.items()))bksl-nlbksl-nl



obtenir des listes de clés, valeurs, couples (clé, valeur)

On peut créer les listes de clés, de valeurs ou de couples (clé, valeur) :

Soit le dictionnaire mon_dictionnaire

  • list(mon_dictionnaire.keys()) permet d'obtenir une liste des clés de mon_dictionnaire
  • list(mon_dictionnaire.values()) permet d'obtenir une liste des valeurs de mon_dictionnaire
  • list(mon_dictionnaire.items()) permet d'obtenir une liste des tuples (clé, valeur) de mon_dictionnaire

V. La méthode keys⚓︎

Testez

###
fermepy-undgaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}bksl-nlprint("lapin" in fermepy-undgaston.keys())bksl-nlprint("dragon" in fermepy-undgaston.keys())bksl-nlbksl-nl# Vos essais ci-dessousbksl-nlbksl-nl



Ne connaissez-vous pas une autre façon de procéder ?

Nous aurions pu tout simplement écrire

Testez

###
fermepy-undgaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}bksl-nlprint("lapin" in fermepy-undgaston)bksl-nlprint("dragon" in fermepy-undgaston)bksl-nlbksl-nl# Vos essais ci-dessousbksl-nlbksl-nl



Parcourir avec la méthode keys

Testez ci-dessous

###
fermepy-undgaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}bksl-nlfor animal in fermepy-undgaston.keys():bksl-nl print(animal)bksl-nlbksl-nlbksl-nl



🐘 À retenir

Soit le dictionnaire mon_dictionnaire
mon_dictionnaire.keys() permet de parcourir toutes les clés de mon_dictionnaire

Question

ferme_gaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}

Que renvoie l'expression "cheval" in ferme_gaston.keys() ?

  • True
  • False
  • Une erreur
  • Rien
  • ✅ True
  • ❌ False
  • ❌ Une erreur
  • ❌ Rien
Question

ferme_gaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}

Quelle instruction permet de parcourir les clés de ferme_gaston ?

  • for cle in range(ferme_gaston)
  • for cle in ferme_gaston.keys
  • for cle in ferme_gaston.keys()
  • for cle in keys.ferme_gaston()
  • for cle in ferme_gaston
  • ❌ for cle in range(ferme_gaston)
  • ❌ for cle in ferme_gaston.keys Il ne faut pas oublier les parenthèses.
  • ✅ for cle in ferme_gaston.keys()
  • ❌ for cle in keys.ferme_gaston()
  • ✅ for cle in ferme_gaston

VI. La méthode values⚓︎

Testez

###
pokemons = {"Salamèche" : "Feu", "Reptincel": "Feu",bksl-nl "Carapuce": "Eau", "Chenipan": "Insecte"}bksl-nlprint("Eau" in pokemons.values())bksl-nlprint("Poison" in pokemons.values())bksl-nlbksl-nl



Parcourir avec la méthode values

Testez ci-dessous

###
pokemons = {"Salamèche" : "Feu", "Reptincel": "Feu",bksl-nl "Carapuce": "Eau", "Chenipan": "Insecte"}bksl-nlfor typepy-undpokemon in pokemons.values():bksl-nl print(typepy-undpokemon)bksl-nlbksl-nl



🐘 À retenir

Soit le dictionnaire mon_dictionnaire
mon_dictionnaire.values() permet d'accéder à toutes les valeurs de mon_dictionnaire

Question

couleurs = {"white": "blanc", "black": "noir", "red": "rouge"}

Que renvoie l'expression "vert" in couleurs.values() ?

  • True
  • False
  • Une erreur
  • Rien
  • ❌ True
  • ✅ False
  • ❌ Une erreur
  • ❌ Rien
Question
🐍 Script Python
pokemons = {"Salamèche" : "Feu", "Reptincel": "Feu",
            "Carapuce": "Eau", "Chenipan": "Insecte"}

Quelle instruction permet de parcourir les types des pokémons de ce dictionnaire ?

  • for type_pokemon in range(pokemons)
  • for type_pokemon in pokemons.values()
  • for type_pokemon in pokemons.values
  • for type_pokemon in values.pokemons()
  • for type_pokemon in pokemons
  • ❌ for type_pokemon in range(pokemons)
  • ✅ for type_pokemon in pokemons.values()
  • ❌ for type_pokemon in pokemons.values Il ne faut pas oublier les parenthèses.
  • ❌ for type_pokemon in values.pokemons()
  • ❌ for type_pokemon in pokemons Cette instruction parcourt les clés
utiliser la méthode values

Bob a constitué un dictionnaire de recettes de la façon suivante : les clés sont les noms des gâteaux, et les valeurs les listes de ingrédients pour chaque gâteau.
Aidez-le à écrire la fonction Python qui prend en paramètres un dictionnaire des recettes, un ingrédient, et qui renvoie le nombre de recettes utilisant cet ingrédient.

###
def nbrepy-undrecettes(recettes, ingredient):bksl-nl ...bksl-nlbksl-nlmespy-undrecettes = {"Gâteau au chocolat": ["chocolat", "oeuf", "farine", "sucre"," beurre"],bksl-nl "Gâteau au yaourt":["yaourt", "oeuf", "farine", "sucre"],bksl-nl "Crêpes":["oeuf", "farine", "lait", "bière"],bksl-nl "Quatre-quarts":["oeuf", "farine", "beurre", "sucre"],bksl-nl "Kouign amann":["farine", "beurre", "sucre"]}bksl-nlbksl-nl# Testsbksl-nlassert nbrepy-undrecettes(mespy-undrecettes, "sucre") == 4bksl-nlbksl-nl



Solution
🐍 Script Python
def nbre_recettes(recettes, ingredient):
    total = 0
    for ingredients in recettes.values():
        if ingredient in ingredients:
            total = total + 1
    return total
et sans la méthode values ?

Nous aurions pu écrire ceci :

🐍 Script Python
    def nbre_recettes(recettes, ingredient):
        total = 0
        for gateau in recettes:
            if ingredient in recettes[gateau]:
                total = total + 1
        return total

VII. La méthode items⚓︎

Testez

###
pokemons = {"Salamèche" : "Feu", "Reptincel": "Feu",bksl-nl "Carapuce": "Eau", "Chenipan": "Insecte"}bksl-nlprint(("Salamèche", "Feu") in pokemons.items())bksl-nlprint(("Abra", "Psy") in pokemons.items())bksl-nlbksl-nl



Parcourir avec la méthode items

Testez ci-dessous

###
pokemons = {"Salamèche" : "Feu", "Reptincel": "Feu",bksl-nl "Carapuce": "Eau", "Chenipan": "Insecte"}bksl-nlfor paire in pokemons.items():bksl-nl print(paire)bksl-nlbksl-nl



🐘 À retenir

Soit le dictionnaire mon_dictionnaire
mon_dictionnaire.items() permet d'accéder à tous les tuples (clé, valeur) de mon_dictionnaire

Question

ferme_gaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}

Que renvoie l'expression ("dragon", 2) in ferme_gaston.items() ?

  • True
  • False
  • Une erreur
  • Rien
  • ❌ True
  • ✅ False
  • ❌ Une erreur
  • ❌ Rien
Question

ferme_gaston = {"lapin": 5, "vache": 7, "cochon": 2, "cheval": 4}

Quelle instruction permet de parcourir les tuples (animal, effectif) de ferme_gaston ?

  • for paire in range(ferme_gaston)
  • for paire in items.ferme_gaston
  • for paire in ferme_gaston.items
  • for paire in ferme_gaston.items()
  • ❌ for paire in range(ferme_gaston)
  • ❌ for paire in items.ferme_gaston
  • ❌ for paire in ferme_gaston.items Il ne faut pas oublier les parenthèses.
  • ✅ for paire in ferme_gaston.items()
utiliser la méthode items

"Testez"

Alice est étourdie, elle ne se souvient plus à quel devoir elle a obtenu la note "18". Compléter ci-dessous :

###
def intitule(lespy-undnotes, note) -> str:bksl-nl ...bksl-nlbksl-nlbksl-nlnotespy-undAlice = {"testpy-und1": 14, "testpy-und2": 16, "testpy-und3": 18}bksl-nlbksl-nl# Testsbksl-nlassert intitule(notespy-undAlice, 18) == "testpy-und3"bksl-nlassert intitule(notespy-undAlice, 20) == "Cette note n'a pas été obtenue"bksl-nlbksl-nl



Solution
🐍 Script Python
def intitule(les_notes, note) -> str:
    for (nom, resultat) in les_notes.items():
        if resultat == note:
            return nom
    return "Cette note n'a pas été obtenue"
et sans la méthode items ?

Nous aurions pu écrire ceci :

🐍 Script Python
def intitule(les_notes, note) -> str:
    for nom  in les_notes :
        if les_notes[nom] == note:
            return nom
    return "Cette note n'a pas été obtenue"

Utiliser les méthodes keys, values et items

On peut parcourir les vues créées par ces méthodes, de façon analogue à ce que l'on ferait avec d'autres séquences comme des listes :

Soit le dictionnaire mon_dictionnaire

  • mon_dictionnaire.keys() permet de parcourir toutes les clés de mon_dictionnaire
  • mon_dictionnaire.values() permet de parcourir toutes les valeurs de mon_dictionnaire
  • mon_dictionnaire.items() permet de parcourir tous les couples (clé, valeur) de mon_dictionnaire

VIII. QCM final⚓︎

Question

On considère le dictionnairesymboles_hexa = {"A": 10, "B": 11, "C": 12, "D": 13, "E":14, "F":15}

Que peut afficher print(list(symboles_hexa.items())) ?

  • ["A", "B", "C", "D", "E", "F"]
  • [10, 11, 12, 13, 14, 15]
  • [(10,"A"), (11, "B") ,(12, "C"), (13, "D"), (14, "E"), (15, "F")]
  • [("A": 10), ("B": 11), ("C": 12), ("D": 13), ("E": 14), ("F": 15)]
  • [("A", 10), ("B", 11), ("C", 12), ("D", 13), ("E", 14), ("F", 15)]
  • ❌ ["A", "B", "C", "D", "E", "F"]
  • ❌ [10, 11, 12, 13, 14, 15]
  • ✅ [(10,"A"), (11, "B") ,(12, "C"), (13, "D"), (14, "E"), (15, "F")]
  • ❌ [("A": 10), ("B": 11), ("C": 12), ("D": 13), ("E": 14), ("F": 15)]
  • ✅ [("A", 10), ("B", 11), ("C", 12), ("D", 13), ("E", 14), ("F", 15)]
Liquidation

Que peut-il s'afficher si l'on exécute le script suivant :

🐍 Script Python
stock = {"kiwis": 2, "pommes": 10, "bananes": 6, "noix": 4}
for (fruit, nombre) in stock.items():
    if nombre < 5:
        stock[fruit] = 0
print(stock)
  • {"pommes": 10, "kiwis": 0, "bananes": 6, "noix": 0}
  • {"kiwis": 0, "pommes": 10, "bananes": 6, "noix": 0}
  • {"0": 2, "pommes": 10, "bananes": 6, "0": 4}
  • {"kiwis": 2, "pommes": 10, "bananes": 6, "noix": 4}
  • ✅ {"pommes": 10, "kiwis": 0, "bananes": 6, "noix": 0} Il n'y a pas d'ordre pour écrire un dictionnaire.
  • ✅ {"kiwis": 0, "pommes": 10, "bananes": 6, "noix": 0}
  • ❌ {"0": 2, "pommes": 10, "bananes": 6, "0": 4}
  • ❌ {"kiwis": 2, "pommes": 10, "bananes": 6, "noix": 4} Il faut modifier les valeurs strictement inférieures à 5 en 0.
Question

couleurs = {"white": "blanc", "black": "noir", "red": "rouge"}

Que renvoie l'expression couleurs[0] ?

  • "white"
  • "blanc"
  • Une erreur
  • ❌ "white"
  • ❌ "blanc"
  • ✅ Une erreur. On accède à une valeur avec la clé
Question

couleurs = {"white": "blanc", "black": "noir", "red": "rouge"}

Quelle instruction faut-il écrire pour modifier ce dictionnaire et obtenir :
couleurs = {"white": "blanc", "black": "noir", "red": "rouge, "green": "vert"}

  • couleurs["green"] = "vert"
  • couleurs.append("green", "vert")
  • Ce n'est pas possible
  • ✅ couleurs["green"] = "vert"
  • ❌ couleurs.append("green", "vert")
  • ❌ Ce n'est pas possible
Question

stock = {"kiwis": 2, "pommes": 10, "bananes": 6, "noix": 4}
Quelle est l'instruction qui permet d'afficher le plus grand nombre de fruits d'une variété ?

  • print(max(stock))
  • print(max(stock.values()))
  • print(max(stock.values))
  • print(max([stock[fruit] for fruit in stock]))
  • ❌ print(max(stock))
  • ✅ print(max(stock.values()))
  • ❌ print(max(stock.values)) Ne pas oublier les parenthèses
  • ✅ print(max([stock[fruit] for fruit in stock]))

😊 Si vous avez bien réussi ces QCM, vous pouvez passer aux exercices dans la section suivante ...