Chapitre 3: Dictionnaires

Programme

Contenus Capacités attendues Commentaires

Dictionnaires par clés et valeurs

Contenus	Capacités attendues	Commentaires
Dictionnaires par clés et valeurs	Construire une entrée de dictionnaire Itérer sur les éléments d’un dictionnaire.	Il est possible de présenter les données EXIF d’une image sous la forme d’un enregistrement. En Python, les p-uplets nommés sont implémentés par des dictionnaires. Utiliser les méthodes `keys()`, `values()` et `items()`

Construire une entrée de dictionnaire

Itérer sur les éléments d’un dictionnaire.

Il est possible de présenter les données EXIF d’une image sous la forme d’un enregistrement.

En Python, les p-uplets nommés sont implémentés par des dictionnaires.

Utiliser les méthodes keys(), values() et items()

Dans un dictionnaire les valeurs de la collection ne sont pas repéré par un index, mais par une clé. Ils ne possèdent donc pas d’ordre a priori, c’est une structure non-ordonnée. Les dernières versions de Python assurent cependant un ordre lors de leur itération.

Les dictionnaires en Python sont ce que l'on appelle un tableau associatif.

1 Syntaxe

Les dictionnaires sont entourés d’accolades {}. Les clés doivent être des objets imuables, typiquement des str.

{'clé_1': valeur_1, 'clé_n': valeur_n, ...'clé_n': valeur_n}

D = { 'nom': 'Lagaffe' , 'prenom': 'Gaston', 'age': 22 }
type(D)

dict

Pour accéder aux éléments du dictionnaire, il suffit d’appeler la clé correspondante, d’autre part la fonction len() est également disponible.

len(D)

D['nom']

'Lagaffe'

D['age']

2 Ajout et suppression d’éléments

Les dictionnaires étant mutables, on peut ajouter des éléments au dictionnaire en **assignant* des clés paire valeur à notre guise.

D["expression"] = "M'enfin"
D

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'age': 22, 'expression': "M'enfin"}

On peut au contraire supprimer des éléments du dictionnaire avec la méthode pop().

D.pop("age")
D

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'expression': "M'enfin"}

3 Autres méthodes des dictionnaires

Les méthodes des dictionnaires sont décrites dans la documentation ou grâce à l’appel help(tuple), outre les méthodes d’itération il peut être utile de connaitre la méthode get(clé) qui renvoie la valeur associée à l clé ou None si la clé n’existe pas.

Cela permet d’éviter les exceptions du type KeyError si la clé n’existe pas.

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'expression': "M'enfin"}

Par exemple, la clé age n’existe plus donc la syntaxe d’accés par clé renvoir une erreur.

print(D["nom"])
print(D["prenom"])
print(D["age"])

>>sortie

Lagaffe
Gaston

>>sortie

KeyError: 'age'

Par contre, la méthode get() ne générera pas la KeyError et renverra None la clé n’existe pas.

print(D.get("nom"))
print(D.get("prenom"))
print(D.get("age"))

>>sortie

Lagaffe
Gaston
None

En plus: Documentation des dictionnaires

help(dict)

>>sortie

Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Built-in subclasses:
 |      StgDict
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      
 |      If the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |  
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |      
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |  
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |      
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  __class_getitem__(...) from builtins.type
 |      See PEP 585
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Create a new dictionary with keys from iterable and values set to value.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

4 Itération sur les dictionnaires

Les dictionnaires étant des associations de clés(keys) et de valeurs(values), il existe trois méthodes pour itérer sur les clés, les valeurs ou les deux.

4.1 Itération sur les clés: `keys()`

for key in D.keys():
    print(key)

>>sortie

nom
prenom
expression

Ou plus simplement.

for key in D:
    print(key)

>>sortie

nom
prenom
expression

4.2 Itération sur les valeurs: `values()`

for value in D.values():
    print(value)

>>sortie

Lagaffe
Gaston
M'enfin

4.3 Itération sur les paires clé, valeurs: `items()`

for key, value in D.items():
    print(key, '=>', value)

>>sortie

nom => Lagaffe
prenom => Gaston
expression => M'enfin

5 p-uplets nommés

Il est possible de créer des p-uplets nommés afin de pouvoir accéder aux éléments de la collection par clé. Contrairement aux dictionnaires, ils sont immutables et donc potentiellement plus performants, ils sont cependant peu utilisés et nécessite d’être importé par le module collections avant d’être utilisé.

from collections import namedtuple

Eleve = namedtuple('Eleve', 'nom, age, classe, spécialité')
e = Eleve("John", 17, "1g", "nsi" )
e

Eleve(nom='John', age=17, classe='1g', spécialité='nsi')

L’accès peut se faire en ajoutant un point et le nom de la clé. Il s’agit d’une notation pointée comme dans le cas d’appel de méthodes, cependant il n’y a pas de parenthèses, car il s’agit de valeurs et non de fonctions(On parle d’attributs de l’objet).

e.age

e.spécialité

'nsi'

6 Structures imbriquées avec les dictionnaires

Tout comme nous avons vu les tableaux de tableau dans le chapitre précédent, il est possible d’imaginer des structures imbriquées avec des dictionnaires.

On va s’intéresser plus particulièrement à une liste de dictionnaire qui pourrait être obtenue par lecture d’un fichier de données csv.

1 Syntaxe

2 Ajout et suppression d’éléments

3 Autres méthodes des dictionnaires

4 Itération sur les dictionnaires

4.1 Itération sur les clés: keys()

4.2 Itération sur les valeurs: values()

4.3 Itération sur les paires clé, valeurs: items()

5 p-uplets nommés

6 Structures imbriquées avec les dictionnaires

4.1 Itération sur les clés: `keys()`

4.2 Itération sur les valeurs: `values()`

4.3 Itération sur les paires clé, valeurs: `items()`