Cours sur les dictionnaires

Définition et propriétés de base

Un dictionnaire en python est un type construit qui se définit par une collection d' items constitué d'une clef (key) associée à une valeur (value).

Syntaxe :

dictionnaire = {}   # dictionnaire vide lors d'une initialisation 
dictionnaire["premier"] = "first"    # crée l'item ("premier" : "first") ou donne la valeur "first" à l'item pré-existant de clef "premier"
print(dictionnaire)   # affiche     {"premier" : "first"}
dictionnaire["second"] = "second"
print(dictionnaire)   # affiche     {"premier" : "first", "second" : "second"}
dictionnaire["Troisième"] = "third"
print(dictionnaire)   # affiche     {"premier" : "first", "second" : "second", "troisième" : "third"}   # trois items# taille du dictionnaire :len(dictionnaire)   affiche ici   3
# modification possible d'un item
dictionnaire["Troisième"] = "3th"
print(dictionnaire)   # affiche     {"premier" : "first", "second" : "second", "troisième" : "3th"}

Méthodes associées à l'objet dict

Trois méthodes permettent de construire des itérateurs sur le dictionnaire :

Les méthodes d'un objet sont des fonctions permettant soit d'obtenir (get) des informations sur l'objet, soit de modifier un ou plusieurs attributs de l'objet.

Trois méthodes sont particulièrement utiles pour accéder aux éléments d'un dictionnaire ; elles permettent de construire un itérateur utilisable dans une boucle for ; un itérateur est une sorte de liste à usage unique

• dict.keys() : "liste" des clefs
• dict.values() : "liste" des valeurs
• dict.items() : "liste" des items : (clef, valeur) de type tuple

Construction et accès aux items, clefs et valeurs

Un dictionnaire peut se construite par comprehension ; c'est à dire que l'on peut le construire en une seule étape (ligne de code) en écrivant un mini programme entre ses accolades :

Construction classique :

d = dict()  # d = {}   initialisation
liste_clefs = ["un", "deux"]
liste_valeurs = [1,2]
for i in range(len(liste_clefs)) :  
    d[liste_clefs[i]] = liste_valeurs[i]
    print("Le dictionnaire, après l'ajout de l'item ({}:{}) devient {}"
    		.format(liste_clefs[i]] , liste_valeurs[i], d)
		

Construction par comprehension :

liste_clefs = ["un", "deux", "trois"]
liste_valeurs = [1,2,3]	
d = [ liste_clefs[i]] : liste_valeurs[i] for i in range(len(liste_clefs)) ]  # pas d'initialisation préalable !
		

Accès à une valeur par la clef

d["un"] renvoie la valeur 1

d["deux"] renvoie la valeur 2

d["quatre"] est simplement créé comme ceci
d["quatre"] = 4

Accès aux clefs, valeurs et items à l'aide d'une boucle

for clef in d.keys() :
    print("Clef = ", clef)
		

for valeur in d.values() :
    print("valeur = ", valeur)		
		

TP

Codage de César : coder une fonction qui renvoie le texte en entrée codé par un décalage de n dans l'alphabet.

Outils PYTHON à utiliser

Les fonctions builtins

• ord('a) renvoie le code unicode du caractère a, soit 97;
  ord('b') renvoie le code unicode du caractère b, soit 98;
  ord('c') renvoie le code unicode du caractère c, soit 99;
  ord('d') renvoie le code unicode du caractère d, soit 100;
  ord('A') renvoie le code unicode du caractère A, soit 65;
  N.B. : l'ordre alphabétique est préservé et cela permet de classer les mots entre eux par ordre alphabétique : ("fille" < "mère" == True).
• chr(97) renvoie le caractère 'a' ;
  chr(97 + i) renvoie les caractères de 'a' à 'z' si i ∈ [0 ; 25]. chr(ord('a') + i) renvoie la même chose de manière plus explicite (97 n'évoque rien à priori !)
  chr(ord('a') + (i + decalage) % 26) renvoie un des 26 caractères, cela dépend des valeurs de i et de decalage.

Traducteur automatique :

dic = {"un": "one", "arbre" :"tree"}

texte = "un arbre"

mots = texte.split(' ')

words = []
for mot in mots :
    words.append(dic[mot])
text = " ".join(words)   # concatène les éléments de words en les séparant par un " "
On obtient : "one tree"