Update

docs/Programmation/Python/dictionnaire.md

@@ -33,6 +33,18 @@ C'est une collection **non ordonnée**, **modifiable** et **indexée**.
 {'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
@@ -82,6 +94,15 @@ C'est une collection **non ordonnée**, **modifiable** et **indexée**.
 {'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
@@ -181,7 +202,7 @@ language python
 version 3.7
 ```
 
-Vérifier si une clé existe dans un dictionnaire:
+##### Vérifier si une clé existe dans un dictionnaire:
 
 ```python
 >>> dict = {'language': 'python', 'version': '3.7'}
@@ -191,7 +212,7 @@ Vérifier si une clé existe dans un dictionnaire:
 'language' est dans dict
 ```
 
-Longueur d'un dictionnaire:
+##### Longueur d'un dictionnaire:
 
 ```python
 >>> dict = {'language': 'python', 'version': '3.7'}
@@ -199,33 +220,96 @@ Longueur d'un dictionnaire:
 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 |
-| ------------ | ----------- |
-| clear()      |             |
-| copy()       |             |
-| fromkeys()   |             |
-| get()        |             |
-| items()      |             |
-| keys()       |             |
-| pop()        |             |
-| popitem()    |             |
-| setdefault() |             |
-| update()     |             |
-| values()     |             |
+| 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.