316 lines
7.0 KiB
Markdown
316 lines
7.0 KiB
Markdown
# 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.
|
||
|