Un tableau permet d'organiser des données en associant un item à un indice.

tableau[indice] ⇒ item de rang i

jours = ["dim", "lun", "mar", "mer", "jeu", "ven", "sam"]

Avec ce tableau on obtient facilement le jour d'indice 5 :

>>> jours[5]
"ven"

Mais comment faire des associations de type différent ?

Par exemple, on souhaite associer le nom d'une commune avec son gentilé (nom des habitants) :

gentilés = [
    ("Paris", "Parisien"),
    ("Marseille", "Marseillais"),
    ("Saint-Denis", "Dionysien"),
    ("Château-Thierry", "Castelthéodoricien")
]

Comment obtenir le gentilé pour "Saint-Denis" ?

C'est possible mais cela suppose de parcourir le tableau à la recherche de "Saint-Denis". On irait plus vite si on pouvait écrire quelque chose comme gentile["Saint-Denis"]

def ville_to_gentile(ville):
    for v, g in gentile:
        if v == ville:
            return g
    return None # pas trouvé

Cette méthode fonctionne mais trouver le gentilé associé à une ville peut prendre du temps puisqu'il faut parcourir le tableau jusqu'à trouver la ville.

Un dictionnaire consiste justement à créer de telles associations. On pourra écrire :

gentile = {
    "Paris":"Parisien",
    "Marseille":"Marseillais",
    "Saint-Denis":"Dionysien",
    "Château-Thierry":"Castelthéodoricien"
}

Et pour obtenir le gentilé de Saint-Denis il suffit d'écrire

>>> gentile["Saint-Denis"]
"Dionysien"

Attention : Dans le dictionnaire, les deux éléments d'une paire n'ont pas le même rôle.

La partie à gauche de : est la clé, à droite c'est la valeur

>>> gentile.keys()
['Paris', 'Marseille', 'Saint-Denis', 'Château-Thierry']
>>> gentile.values()
['Parisien', 'Marseillais', 'Dionysien', 'Castelthéodoricien']

Et donc cette commande renvoie une erreur :

>>> gentile["Dionysien"]
KeyError: "Dionysien"

car "Dionysien" est une valeur, pas une clé !

On retrouve la différence entre indice et valeur dans un tableau. L'indice d'un tableau est toujours un nombre entier naturel. Une clé de dictionnaire est comme l'indice mais la clé peut être autre chose qu'un entier.

En Python, la clé peut être de types int, float, str, tuple.

On poursuit les exemples avec

gentile = {
    "Paris":"Parisien",
    "Marseille":"Marseillais",
    "Saint-Denis":"Dionysien",
    "Château-Thierry":"Castelthéodoricien"
}

>>> len(gentile)
4

in permet de savoir si une clé est présente.

>>> "Paris" in gentile
True
>>> "Lille" in gentile
False
>>> "Dionysien" in gentile
False

Attention, "Dionysien" est bien dans le dictionnaire mais en tant que valeur, pas en tant que clé.

On retrouve la même syntaxe que pour les p-uplets et les tableaux

>>> gentile["Château-Thierry"]
'Castelthéodoricien'
>>> gentile["Lille"]
KeyError

Pour éviter les erreurs, on peut aussi utiliser :

>>> gentile.get("Château-Thierry")
'Castelthéodoricien'
>>> gentile.get("Lille")

le dernier ne renvoie rien (renvoie None) car "Lille" n'est pas une clé du dictionnaire. Ne lève pas d'erreur.

>>> gentile["Lille"] = "Lillois"
>>> gentile["Paris"] = "Parisienne"

Dans le premier cas, c'est une création de paire clé-valeur, dans le deuxième cas, c'est une modification.

>>> del gentile["Château-Thierry"]

Parcourir les éléments d'un dictionnaires. Comme pour un tableau, on peut désirer parcourir les clés, les valeurs ou les deux à la fois.

for key in gentile:
    # boucle se répète pour chaque clé
    # key prendra les valeurs "Paris", "Saint-Denis"...

Attention ! Dans un dictionnaire, l'ordre n'est pas garanti ! Ce n'est pas parce que on a créé le dictionnaire ainsi :

gentile = {
    "Paris":"Parisien",
    "Marseille":"Marseillais",
    "Saint-Denis":"Dionysien",
    "Château-Thierry":"Castelthéodoricien"
}

que les clés seront parcourues dans l'ordre "Paris", "Marseille", "Saint-Denis,.... L'ordre est imprévisible.

Peu utile.

for item in gentile.values():
    # répété pour chaque paire, ordre imprévisible
    # item prend les valeurs "Parisien", "Marseillais"...

for key, item in gentile.items():
    # parcours simultané des clé et valeurs
    # key vaut la clé, item la valeur associée
    # toujours dans un ordre imprévisible...

C'est l'équivalent de la situation rencontrée avec les tableaux :

for indice, item in enumerate(tableau):
    # parcours simultané des indices et valeurs

Le programme de NSI fait référence à des tuples nommés.

Ce type de donnée n'existe pas nativement en Python (il faut importer une bibliothèque)

L'idée du programme est simplement d'utiliser, dans certains cas, des dictionnaires comme des tuples.

Cependant attention : un dictionnaire est mutable mais pas un tuple (on ne peut pas modifier un tuple une fois créé), c'est d'ailleurs ce qui fait la différence entre un tuple et un tableau.

Comme on l'a dit, on pourrait créer un tableau de paires de valeurs ce qui permettrait, en parcourant le tableau, de retrouver tout ce que l'on veut :

gentile = [
    ("Paris", "Parisien"),
    ("Marseille", "Marseillais"),
    ("Saint-Denis", "Dionysien"),
    ("Château-Thierry", "Castelthéodoricien")
]

Mais (déjà dit) pour trouver le gentilé de "Saint-Denis" (par exemple) il faut parcourir le tableau. Cela peut-être long si le tableau est grand.

Dans le cas d'un tableau, par exemple :

jours = ["dim", "lun", "mar", "mer", "jeu", "ven", "sam"]

L'accès à un élément par son indice est direct :

>>> jours[5]
"ven"

C'est à dire qu'il n'est pas nécessaire de parcourir "dim", "lun", etc. pour atteindre "ven", le programme saute directement à la bonne position.

Le dictionnaire permet de faire la même chose.

>>> hash("Paris")
7211877366768910205

>>> hash("Paris") % 3
2

[ [],
  [("Saint-Denis", "Dionysien")],
  [("Paris", "Parisien"), ("Marseille", "Marseillais")]
]