# Dictionnaire



Un dictionnaire est une sorte de liste, mais qui utilise des clés à la place des index. 
C'est une collection **non ordonnée**, **modifiable** et **indexée**.



##### Créer un dictionnaire:

```python
>>> dict = {}

>>> type(dict)
<class 'dict'>
```

```python
>>> un_dict =  {
...   "marque": "Ford",
...   "modele": "Mustang",
...   "annee": 1964
... }
>>> un_dict
{'marque': 'Ford', 'modele': 'Mustang', 'annee': 1964}
```

```python
# Constructor dict()
>>> un_dict = dict(marque="Ford", modele="Mustang", annee=1964)
>>> un_dict
{'marque': 'Ford', 'modele': 'Mustang', 'annee': 1964}
```

```python
# Liste l de couples transformée en dictionnaire
>>> l = [('a',1), ('b',2)]
>>> dict(l)
{'a': 1, 'b': 2}
```

```python
>>> dict(zip('abc',range(3)))
{'a': 0, 'b': 1, 'c': 2}
```

##### Accéder à un item:

```python
>>> un_dict = dict(marque="Ford", modele="Mustang", annee=1964)
>>> un_dict
{'marque': 'Ford', 'modele': 'Mustang', 'annee': 1964}
```

```python
>>> x = un_dict["modele"]
>>> x
'Mustang'
```

```python
>>> x = un_dict.get("modele")
>>> x
'Mustang'
```

##### Récupérer une valeur (get):

```python
>>> dict = {'language': 'python', 'version': '3.7'}
>>>
>>> dict.get("language")
'python'
>>> dict.get("os", "pas de clé os")
'pas de clé os'
```

##### Modifier une valeur:

```python
>>> un_dict = dict(marque="Ford", modele="Mustang", annee=1964)
>>> un_dict["annee"] = 1965
>>> un_dict
{'marque': 'Ford', 'modele': 'Mustang', 'annee': 1965}
```

##### Y ajouter des valeurs:

```python
>>> dict["language"] = "python"
>>> dict["version"] = "3.7"
>>> dict
{'language': 'python', 'version': '3.7'}
```

##### Ajouter des valeurs (update):

```python
>>> d = {'a':0}
>>> d.update(zip('bcd',range(1,4)))
>>> d
{'a': 0, 'b': 1, 'c': 2, 'd': 3}
```

##### Vérifier la présence d'une clé (in):

```python
>>> "language" in dict
True
```

##### Supprimer une entrée (del):

```python
>>> del dict["version"]
>>> print(dict)
{'language': 'python'}
```

##### Supprimer une entrée (pop):

```python
>>> dict.pop("version")
'3.7'
>>> dict
{'language': 'python'}
```

##### Supprimer la dernière entrée (popitem):

```python
>>> dict["version"] = "3.7"
>>> dict["type"] = "interpreté"
>>> dict
{'language': 'python', 'version': '3.7', 'type': 'interprete'}
>>> dict.popitem()
('type', 'interprete')
>>> dict
{'language': 'python', 'version': '3.7'}
```

##### Supprimer un dictionnaire (del):

```python
>>> un_dict = {'language': 'python', 'version': '3.7'}
>>> del un_dict
>>> un_dict
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'un_dict' is not defined
```

##### Vider un dictionnaire (clear):

```python
>>> un_dict = {'language': 'python', 'version': '3.7'}
>>> un_dict.clear()
>>> un_dict
{}
```

##### Récupérer les clés par une boucle (keys):

```python
>>> for cle in dict.keys():
...     print(cle)
...
language
version

>>> for cle in dict:
...     print(cle)
...
language
version
```

##### Récupérer les valeurs par une boucle (values):

```python
>>> for valeur in dict.values():
...     print(valeur)
...
python
3.7

>>> for val in dict:
...     print(dict[val])
...
python
3.7
```

##### Récupérer les clés et les valeurs par une boucle (items):

```python
>>> for cle, valeur in dict.items():
...     print(cle, valeur)
...
language python
version 3.7
```

##### Vérifier si une clé existe dans un dictionnaire:

```python
>>> dict = {'language': 'python', 'version': '3.7'}
>>> if "language" in dict:
...     print("'language' est dans dict")
...
'language' est dans dict
```

##### Longueur d'un dictionnaire:

```python
>>> dict = {'language': 'python', 'version': '3.7'}
>>> print(len(dict))
2
```

##### Copier un dictionnaire (copy):

```python
>>> autre_dict = dict.copy()
>>> autre_dict
{'language': 'python', 'version': '3.7'}

>>> autre_dict['language'] = 'PYTHON'
>>> autre_dict
{'language': 'PYTHON', 'version': '3.7'}
>>> dict
{'language': 'python', 'version': '3.7'}
```

##### Fromkeys():

```python
>>> d3 = {}
>>> d3 = {}.fromkeys('abcde', 0)
>>> d3
{'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0}
```



#### Méthodes:

| Méthode              | Description                                                  |
| -------------------- | ------------------------------------------------------------ |
| d.clear()            | supprime tous les éléments de `d`                            |
| d.copy()             | shallow copie de `d`                                         |
| {}.fromkeys(s,v)     | créée un dict avec les clés de `s` et la valeur `v`          |
| d.get(k [,v])        | envoie la valeur `d[k]` si elle existe v sinon               |
| d.items()            | liste des items `(k,v)` de `d`                               |
| d.keys()             | liste des clés                                               |
| d.pop(k [,v])        | enlève `d[k]` s’il existe et renvoie sa valeur ou `v` sinon  |
| d.popitem()          | supprime un item `(k,v)` et retourne l’item sous forme de tuple |
| d.setdefault(k [,v]) | `d[k]` si elle existe sinon `v` et rajoute `d[k] = v`        |
| d.update(s)          | `s` est une liste de tuples que l’on rajoute à `d`           |
| d.values()           | liste des valeurs de `d`                                     |



#### Dictionnaires persistants:

Python permet de créer des dictionnaires persistants, grâce au module `shelve`. 

`shelve` fournit une solution de persistance de type “base de données” très simple qui sera gérée automatiquement dans un fichier.

La méthode `shelve.open('f')` crée  dans le répertoire courant de votre ordinateur, un fichier de  sauvegarde “f.db” s’il n’existe pas, et retourne un objet de type `shelve` ; un `shelve` fonctionne  comme un dictionnaire. La plupart des opérations et méthodes des  dictionnaires lui sont applicables ; toute modification appliquée au `shelve` est automatiquement sauvegardée. La méthode `shelve.close` permet de fermer le `shelve`, comme pour un fichier.

```python
>>> import shelve
>>> t = [0,1,2,3,4,5,6,7]
>>> p = (1,2,3)
>>> i = 23
>>> s = 'Bonjour'
>>> db = shelve.open('data')
>>> db['liste'] = t
>>> db['point'] = p
>>> db['entier'] = i
>>> db['chaine'] = s
>>> print(dict(db))
{'point': (1, 2, 3), 'entier': 23, 'liste': [0, 1, 2, 3, 4, 5, 6, 7], 'chaine': 'Bonjour'}
>>> db.close()
>>> exit()

~$ ls -la
-rw-r--r--    1 bruno  staff    16384 25 mar 08:55 data
  
# On relance une session Python

>>> import shelve
>>> with shelve.open('data') as db:
...     print(db['liste'])
...     for k in db:
...             print(db[k])
...
[0, 1, 2, 3, 4, 5, 6, 7]
(1, 2, 3)
23
[0, 1, 2, 3, 4, 5, 6, 7]
Bonjour
```

Si votre code modifie plusieurs fois certaines entrées lors de la même session, lors de l’ouverture du `shelve`, il est important, dans la méthode `open` associée au `shelve`, de mettre le paramètre `writeback` à vrai, comme suit :

```python
shelve.open('data', writeback=True)
```

Grâce à cette option, chaque fois qu’une modification est réalisée au `shelve`, cette modification est correctement répercutée sur la mémoire morte (le disque dur) de votre ordinateur. 

