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. Public domain via Wikimedia Commons
1 Syntaxe
Les dictionnaires sont entourés d’accolades {}. Les clés doivent être des objets imuables, typiquement des str.
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.
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__(self, key, /)
| Return self[key].
|
| __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__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| 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é.
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
17
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.
