Le mapping est une collection d’éléments qui sont identifiés par des clés uniques. Il n’y a donc dans ce cas aucune notion d’ordre comme dans les listes. La notation est la même que pour les séquences, et l’élément e du mapping map associé à la clé cle se récupère par la commande :
On peut utiliser les mêmes primitives que pour les séquences sur un mapping, soit
max, min et len. En réalité, ces opérations s’appliqueront sur la séquence équivalente à l’ensemble des clés qui composent le mapping.
>>> hash('some string') -604248944
>>> hash('some string') -604248944
>>> hash(12) 12
>>> hash([1, 2])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> 1 in [1, 2, 3] # complexité O(n*n) True
>>> 1 in set([1, 2, 3]) # complexité O(n) True
e = map[cle]
Python propose un type de mapping dict (appelé dictionnaire), sachant qu’il est tout à fait possible d’implémenter son propre type de mapping comme le module array de la bibliothèque standard le fait pour les séquences.
Dans les dictionnaires, la clé associée à un élément doit être un objet de type immuable, comme un entier ou une chaîne de caractères. Il est possible d’utiliser un tuple comme clé à condition que les éléments qui le composent soient tous immua-bles. Cette contrainte permet aux mécanismes internes du dictionnaire de traduire la clé en une valeur constante, en utilisant hash, qui sera ensuite utilisée pour accélérer tous les accès aux éléments.
Chaque élément d’un dictionnaire est séparé par une virgule et l’ensemble est entouré par des accolades. Un dictionnaire vide se note donc {}. Pour représenter un élément de dictionnaire, on le préfixe de sa clé suivie de deux points. L’élément e de clé cle se note donc cle: e, et un dictionnaire composé de deux éléments cle1: e1 et cle2: e2 se note: {cle1: e1, cle2: e2}
Exemples de dictionnaire
Tout comme les listes, les objets de type dictionnaire proposent un certain nombre de méthodes regroupées dans le tableau ci-dessous :
>>> dico1 = {'a': 1, 2: 'b'}
>>> dico1['a']
1
>>> dico1[2]
'b'
>>> len(dico1) 2
>>> dict() {}
>>> dict((('a', 1), ('b', 2), ('c', 3))) {'a': 1, 'c': 3, 'b': 2}
Tableau 4–3 Méthodes pour les dictionnaires
Nom Description Exemple
clear() Supprime tous les éléments du diction-naire.
>>> dico1 = {'a': 1, 'b': 2}
>>> dico1.clear()
>>> dico1 {}
copy() Renvoie une copie par références du dic-tionnaire.
Lire la remarque sur les copies un peu plus bas.
>>> dico2['2'] # dico2 est aussi impacté
[1, 2, 'E']
has_key(cle) Renvoie vrai si la clé fournie existe. Équiva-lent à la notation :
cle in dictionnaire. cle not in dictionnaire est l’équivalent de l’inverse, soit not has_key(cle).
items() Renvoie sous la forme d’une liste de tuples, des couples (clé, valeur) du dictionnaire.
Les objets représentant les valeurs sont des copies complètes et non des référen-ces.
>>> a = {'a': 1, 'b': 1}
>>> a.items()
[('a', 1), ('b', 1)]
keys() Renvoie sous la forme d’une liste l’ensem-ble des clés du dictionnaire. L’ordre de ren-voi des éléments n’a aucune signification ni constance et peut varier à chaque modi-fication du dictionnaire.
>>> a = {(1, 3): 3, 'Q': 4}
>>> a.keys() ['Q', (1, 3)]
values() Renvoie sous forme de liste les valeurs du dictionnaire. L’ordre de renvoi n’a ici non plus aucune signification mais sera le même que pour keys() si la liste n’est pas modifiée entre-temps, ce qui permet de faire des manipulations avec les deux listes.
>>> a = {(1, 3): 3, 'Q': 4}
>>> a.values() [4, 3]
iteritems() Fonctionne comme items() mais renvoie un itérateur sur les couples (clé, valeur).
>>> l = {1: 'a', 2: 'b', 3: 'c'} Tableau 4–3 Méthodes pour les dictionnaires (suite)
Nom Description Exemple
iterkeys() Fonctionne comme keys() mais renvoie
itervalues() Fonctionne comme values() mais ren-voie un itérateur sur les valeurs.
Renvoie la valeur identifiée par la clé cle. Si la clé n’existe pas, renvoie la valeur default fournie. Si aucune valeur n’est fournie, renvoie None.
Renvoie la valeur identifiée par la clé cle et retire l’élément du dictionnaire. Si la clé n’existe pas, pop se contente de renvoyer la valeur default. Si le paramètre default n’est pas fourni, une erreur est levée.
File "<stdin>", line 1, in ? KeyError: 18
popitem() Renvoie le premier couple (clé, valeur) du dictionnaire et le retire. Si le dictionnaire est vide, une erreur est renvoyée. L’ordre de retrait des éléments correspond à l’ordre des clés retournées par keys() si la liste n’est pas modifiée entre-temps.
Tableau 4–3 Méthodes pour les dictionnaires (suite)
Nom Description Exemple
update(dic,
**dic)
Update permet de mettre à jour le dic-tionnaire avec les éléments du dicdic-tionnaire dic. Pour les clés existantes dans la liste, les valeurs sont mises à jour, sinon créées.
Le deuxième argument est aussi utilisé pour mettre à jour les valeurs.
Fonctionne comme get() mais si cle n’existe pas et default est fourni, le couple (cle, default) est ajouté à la liste.
>>> l = {1: 'a', 2: 'b', 3: 'c'}
Génère un nouveau dictionnaire et y ajoute les clés fournies dans la séquence seq. La valeur associée à ces clés est default si le paramètre est fourni, None le cas échéant.
>>> l = {}
>>> l.fromkeys([1, 2, 3], 0) {1: 0, 2: 0, 3: 0}
Tableau 4–3 Méthodes pour les dictionnaires (suite)
Nom Description Exemple
À RETENIR Copie légère et copie complète
Les copies de type shallow sont littéralement des copies légères. Chaque référence aux objets du diction-naire est recopiée et les changements des objets modifiables sont donc visibles dans chaque copie origi-nelle du dictionnaire.
À l’inverse, les copies complètes, notées deepcopy, fabriquent une copie conforme en scrutant et reco-piant récursivement tous les éléments contenus dans les objets modifiables du dictionnaire. Pour la méthode items, une copie complète est effectuée dans la liste résultante, ce qui n’est pas le cas de copy.
Nous verrons dans les exercices du chapitre 9 qu’il existe un système générique de copie complète, dans le module copy, qui offre la possibilité d’implémenter ce mécanisme pour tout type d’objet.
À SAVOIR Les itérateurs
Les itérateurs, qui seront plus largement abordés dans la partie de description de la fonction yield, et les générateurs, sont des objets qui permettent de parcourir une séquence sans que les éléments qui la constituent ne soient connus au préalable. Le principe est équivalent à un curseur de données placé sur la première donnée et qui découvre les éléments au fur et à mesure de l’avancée dans la séquence. Ce mécanisme permet d’optimiser grandement la vitesse d’exécution pour des cas d’utilisation spécifiques.