Dictionnaires

Dictionnaires : les clefs peuvent être n'importe quel type non mutable :

• un tuple dont les éléments sont non mutables.
• un namedtuple (dont les éléments sont non mutables).
• un frozenset
• pas une liste.
• mais pas un tuple dont certains éléments sont une liste.

Un dictionnaire peut avoir une clef à None (mais bien sûr, une seule !).

Manipulations élémentaires :

• d = {} : initialisation à vide.
• on peut aussi faire d = dict().
• d = {'toto': 1, 'titi': 2} : initialisation.
• on peut aussi définir un dictionnaire avec une liste de paires (tuples à 2 valeurs) : d = dict([('a', 1), ('b', 2)])
• d['toto'] = 5 : affectation d'une valeur.
• les clefs d'un dictionnaire peuvent être des tuples (de constantes) ! (mais pas des listes)
• del d['toto'] : destruction d'une clef.
• d.keys() : renvoie un itérateur sur les clefs. Si on veut la liste des clefs, faire list(d.keys())
• 'toto' in d : test de l'existence d'une clef.
• key in d ou key not in d : également pour tester la présence d'une clef.
• len(d) : renvoie le nombre d'items dans le dictionnaire.

Pour boucler sur les clefs d'un dictionnaire :

• for x in d:
    print(x)
      

Pour boucler sur un dictionnaire en récupérant en même temps les clefs et les valeurs :

for k, v in d.items():
  print(repr(k) + ' : ' + repr(v))
  

Autres fonctions sur les dictionnaires :

• d.clear() : efface tout.
• d.copy() : shallow copie
• d.get(key) : renvoie la valeur si clef présente, sinon None
• d.get(key, defaultVal) : renvoie la valeur si clef présente, sinon defaultVal
• d.items() : renvoie un itérateur sur le dictionniare renvoyant les paires (key, value).
• d.pop(key) : enlève la clef et renvoie la valeur (KeyError si clef n'existe pas).
• d.pop(key, val) : enlève la clef si elle existe et renvoie la valeur. Renvoie val si clef n'existe pas (sans lever une exception).
• d.popitem() : renvoie une paire (key, value) au hasard et la retire du dictionnaire.
• d.values() : renvoie un itérateur sur les valeurs.
• d.setdefault(key, defaultVal) : si la clef existe, renvoie sa valeur, si la clef n'existe pas, insère la clef avec la valeur defaultVal et renvoie sa valeur.
• Pour avoir la première clef d'un dictionnaire : next(iter(myDict.keys()))

d2 = dict(d) : fait une copie indépendante du dictionnaire.

Pour rajouter 2 dictionnaires l'un à l'autre :

• d1.update(d2) : modifie d1 en rajoutant les clefs/valeurs de d2, mais ne renvoie rien (si clefs communes, c'est la valeur de d2 qui est présente à la fin).
• {k:v for d in (d1, d2) for k,v in d.items()} : renvoie le dictionnaire avec les clefs de d1 et celles de d2 (si clefs communes, ce sont les valeurs de d2)
• dict(list(d1.items()) + list(d2.items())) : autre possibilité.

Dictionnaire de compréhension : d = {x: 2 * x for x in range(4)} donne le dictionnaire {0: 0, 1: 2, 2: 4, 3: 6}.

Inversion des clefs/valeurs d'un dictionnaire :

• quand les valeurs sont uniques :

  invD = {value:key for key, value in d.items()}
    

• quand les valeurs ne sont pas uniques :

  invD = {}
  for k, v in d.items():
      invD.setdefault(v, []).append(k)
      

Pour supprimer les doublons d'une liste sans changer l'ordre : collections.OrderedDict.fromkeys(myList).keys()