(1ADS-07) Autres Structures de Données

Autres structures de données.
1ADS Algorithm in Python
© SUPINFO Interna/onal University – h8p://www.supinfo.com

Objec&fs de ce module
• Présenter des structures de données non

séquen/elles :
– dic/onnaires.
– ensembles.

• Apprendre à stocker de façon non temporaire
des données dans un fichier texte.

Plan de ce module
1. Ensembles.
2. Dic/onnaires.
3. Fichiers.

1. ENSEMBLES.

1. Ensembles.
Plan de ce chapitre
a. Types « set » et « frozenset ».

b. Opéra/ons communes à ces deux types.
c. Itéra/on sur les éléments.
d. Opéra/ons spécifiques aux « set ».
e. Ensembles définis « en compréhension ».
f. Exercice.

1. Ensembles.
a. Types “set” et “frozenset”.

• Python possède des structures de données implémentant
la no/on d’ensemble mathéma&que.
• Par “ensemble” on entend ici une collec&on d’éléments

dis&ncts.
• On aura deux types pour ce faire :
– “set” qui sera une structure muable.

– “frozenset” qui elle sera immuable.

1. Ensembles.

• Ces structures de données ne sont pas séquen&elles,
l’accès à un élément ne se fera donc pas par sa posi/on.
• Comme en mathéma/ques, un ensemble ne pourra pas

contenir deux fois le même élément.
• Lors de la créa/on d’un ensemble ou lors de sa mise à

j o u r , l e s d o u b l o n s s e r o n t d o n c s u p p r i m é s
automa/quement.

1. Ensembles.

Un ensemble de plusieurs éléments :

Un
Un autre
élément élement
Encore un
élément

1. Ensembles.

Syntaxe de la déclara&on d’un ensemble “set” :
monSetVide = set()
monSet = {élément1,élément2,...,élémentN}
monSet = set(séquence)

1. Ensembles.

Exemple :

>>> s = {1, 3, 5, 7, 9}
>>> s
{9, 3, 1, 5, 7}
s = set('barbara')
>>> s
{'r', 'b', 'a'}
>>> s = set(range(10,21,2))
>>> s
{10, 12, 14, 16, 18, 20}

1. Ensembles.

Un pe&t dessin de l’ensemble précédent pour fixer les
idées :

3
7
5
1
9

1. Ensembles.

Syntaxe de la déclara&on d’un ensemble “frozenset” :
monFrozenSetVide = frozenset()
monFrozenSet = frozenset(séquence)

1. Ensembles.

Exemple :

>>> s = frozenset('barbara')
>>> s
frozenset({'r', 'b', 'a'})
>>> s = frozenset([1, 5, 666])
>>> s
frozenset({1, 666, 5})
>>> s = frozenset({5, 12, 777})
>>> s
frozenset({777, 12, 5})

1. Ensembles.
b. Opéra&ons communes.
• Les opéra/ons communes aux types “set” et “frozenset”
sont celles des ensembles en mathéma&ques :
– Test d’appartenance
– Test d’inclusion
– Union
– Intersec/on
– Différence
– Différence symétrique

1. Ensembles.
Opéra&ons d’appartenance :
Opéra&on Résultat
x in s Teste si x appar/ent à s
x not in s Teste si x n’appar/ent pas à s
len(s) Nombre d’éléments de s
s.isdisjoint(t) True si l’intersec/on de s et t est vide
s.issubset(t) True si s est inclus dans t
s <= t
s.issuperset(t) True si t est inclus dans s
s >= t

1. Ensembles.
Exemple :
>>> s = {1, 3, 5, 7, 9}
>>> s.isdisjoint([2, 4, 6, 9])
False
>>> s.isdisjoint({2, 4, 6, 8})
True
>>> s.issubset(range(10))
True
>>> s.issuperset(range(1, 6, 2))
True

1. Ensembles.
Opéra&ons classiques sur les ensembles :
Opéra&on Résultat
s.union(t) Union de s et t
s | t
s.intersec/on(t) Intersec/on de s et t
s & t
s.difference(t) Difference de s par t
s -‐ t
s.symmetric_difference(t) Différence symétrique de s et t
s ^ t

1. Ensembles.
Exemple :
>>> s = {1, 3, 5, 7, 9}
>>> t = frozenset({2, 4, 6, 8})
>>> u = s | t
>>> u
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> u.symmetric_difference(range(6,16))
{1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15}
>>> u.difference(range(3),[5, 6],'e')
{3, 4, 7, 8, 9}

1. Ensembles.
c. Itéra&on sur les éléments.

• Il est tout à fait possible d’itérer sur les éléments d’un
“set” ou d’un “frozenset”.
• Leurs éléments n’étant pas mémorisés de façon

séquen/elle, l’ordre de parcours sera par contre indéfini
et imprévisible.

1. Ensembles.
c. Itéra&on sur les éléments.

Exemple :
>>> s = {1, 3, 5, 7, 9}
>>> for x in s:
... print(x**2)
...
81
9
1
25
49

1. Ensembles.
d. Opéra&ons spécifiques aux “set”.

Opéra&ons de mise à jour d’un ensemble :
Opéra&on Résultat
s.update(t) s mis à jour vers
s |= t l’union de s et t
s.intersec/on_update(t) s mis à jour vers
s &= t l’intersec/on de s et t
s.difference_update(t) s mis à jour vers
s -‐= t la difference de s par t
s.symmetric_difference(t) s mis à jour vers
s ^= t la différence symétrique de s et t

1. Ensembles.

Exemple :
>>> s = set('barbara')
>>> s
{'r', 'b', 'a'}
>>> s.update('boris')
>>> s
{'o', 'i', 'b', 'a', 'r', 's'}
>>> s.intersection_update('brio')
>>> s
{'o', 'r', 'b', 'i'}

1. Ensembles.

Opéra&ons d’ajouts et de suppressions d’éléments :
Opéra&on Résultat
s.add(x) Ajoute l’élément x à s
s.remove(x) Supprime l’élément x de s, retourne une
erreur s’il est absent
s.discard(x) Supprime l’élément x de s s’il est présent,
ne retourne rien s’il est absent
s.pop() Supprime et retourne un élément de s
quelconque
s.clear() Supprime tous les éléments de s

1. Ensembles.

Exemple :
>>> s = set()
>>> s.add(666)
>>> s.add('VL')
>>> s.remove(777)
Traceback (most recent call last):
File "<console>", line 1, in <module>
KeyError: 777
>>> s.discard(777)
>>> s.pop()
666
>>> s
{'VL'}
1. Ensembles.
e. Ensembles définis en compréhension.

Syntaxe générale : le principe est exactement le même que
celui des listes définies en compréhension
{expression for x in sequence if conditionnelle}

1. Ensembles.
e. Ensembles définis en compréhension.

Exemple : ensemble cons/tué des carrés des en/ers pairs
entre 0 et 20
>>> s = {x**2 for x in range(21) if x%2 == 0}

>>> s
{0, 64, 4, 324, 144, 256, 16, 400, 196, 100,
36}

1. Ensembles.
f. Exercice.
Exercice : écrire une fonc/on prenant en paramètre une liste
“L” et qui retourne “True” ou “False” selon que ce8e liste
soit une permuta/on de {0,1,2,...,n-‐1}, où n est le nombre
d’éléments de la liste “L”.


1. Ensembles.
f. Exercice.
Solu&on :
def permut(L):
return set(L) == set(range(len(L)))

1. Ensembles.
Fin de ce chapitre
Avez – vous des ques/ons ?

2. DICTIONNAIRES.

2. Dic/onnaires.
Plan de ce chapitre
a. Principe.
b. Construc/on d’un dic/onnaire.
c. Opéra/ons sur les dic/onnaires.
d. Itéra/on sur les éléments.
e. Dic/onnaires définis « en compréhension ».
f. Exercice.

2. Dic/onnaires.
a. Principe.
• Un dic/onnaire est une structure de données non
séquen&elle, muable, perme8ant de mémoriser des
couples clé : valeur.
• L’accès à une valeur se fait via sa clé.
• Les clés doivent nécessairement être d’un type immuable

(int, str, t-‐uple,etc.) et sont toutes différentes.
• Les valeurs sont par contre de n’importe quel type.

2. Dic/onnaires.
a. Principe.
• Contrairement aux séquences, l’accès à une valeur ne se
fait donc pas par sa posi&on mais par une clé.
• Autre différence, les données ne sont pas stockées en

mémoire les unes à la suite des autres.
• Ce8e structure de données n’est donc pas séquen&elle.

2. Dic/onnaires.
a. Principe.
0 1 2 n-2 n-1
-n -(n – 1) -(n – 2) -2 -1
Encore une clé

Une séquence
Une clé

versus
Une autre clé

un dic&onnaire

2. Dic/onnaires.
b. Construc&on d’un dic&onnaire.

Syntaxe de la déclara&on d’un dic&onnaire :
monDicoVide = dict()
monDicoVide = {}
monDico = {clé1:val,clé2:val,...,cléN,val}

2. Dic/onnaires.

Syntaxe de la déclara&on d’un dic&onnaire :
monDico = dict([(clé1,val),...,(cléN,val)])
monDico = dict(((clé1,val),...,(cléN,val)))
monDico = dict(zip([clé1,...,cléN],
[val,...,val]))

2. Dic/onnaires.

Ajout d’un élément ou modifica&on d’une valeur :

monDico[maClé] = maValeur

• Si la clé maClé ne fait pas par/e du dic/onnaire, il y a

créa/on d’un couple maClé : maValeur.
• Si elle en faisait par/e, sa valeur associée est mise à jour
vers maValeur.

2. Dic/onnaires.

Exemple : à par/r d’un dic/onnaire vide
>>> rs = {}
>>> rs['Mick'] = 71
>>> rs['Keith'] = 71
>>> rs['Charlie'] = 83
>>> rs
{'Mick': 71, 'Charlie': 83, 'Keith': 71}
>>> rs['Charlie'] = 73
>>> rs
{'Mick': 71, 'Charlie': 73, 'Keith': 71}

2. Dic/onnaires.

Un pe&t dessin du dic&onnaire précédent pour fixer les
idées :
Mick
Charlie
71
73
Keith
71

2. Dic/onnaires.

Autre exemple :
>>> rs = dict([('Mick',71),('Keith',71),
('Charlie',73)])
>>> rs
{'Mick': 71, 'Keith': 71, 'Charlie': 73}
>>> b = dict(zip(['John','Paul','Ringo'],
[40,72,74]))
>>> b
{'Paul': 72, 'Ringo': 74, 'John': 40}

2. Dic/onnaires.
c. Opéra&ons sur les dic&onnaires.

Opéra&ons “habituelles” :
Opéra&on Résultat
x in d Teste si la clé x appar/ent à d
x not in d Teste si la clé x n’appar/ent pas à d
len(d) Nombre d’éléments de d
d[x] Si x est une clé, retourne d[x] sinon renvoie
une erreur
del d[x] Si x est une clé, supprime d[x] sinon
renvoie une erreur
d.clear() Supprime tous les éléments de d
d.update(e) Met à jour d avec e
2. Dic/onnaires.

Exemples :
>>> rs = dict([('Mick',71),('Keith',71)])
>>> rs.update({'Charlie':73,'Ron':67})
>>> rs
{'Ron': 67, 'Mick': 71, 'Keith': 71,
'Charlie': 73}
>>> rs['Keith']
71
>>> del rs['Ron']
>>> rs
{'Mick': 71, 'Keith': 71, 'Charlie': 73}

2. Dic/onnaires.

Opéra&on Résultat
d.get(x) si x est une clé retourne d[x] sinon None
d.get(x,y) si x est une clé retourne d[x] sinon y
si x est une clé retourne d[x] et supprime le
d.pop(x)
couple x : d[x], sinon renvoie une erreur
si x est une clé retourne d[x] et supprime le
d.pop(x,y)
couple x : d[x], sinon retourne y
d.popitem() Si le dic/onnaire est vide retourne une
erreur, sinon retourne un couple arbitraire
de d et le supprime
d.setdefault(x,y) si x est une clé retourne d[x] sinon retourne
y et insère le couple x : y
2. Dic/onnaires.

Exemples :
>>> rs = {'Mick': 71, 'Keith': 71,
'Charlie': 73}
>>> rs.get('Mick')
71
>>> rs.get('Ron',"Pas là")
'Pas là'
>>> rs.pop('Keith')
71
>>> rs.setdefault('Ron',67)
67
>>> rs
{'Ron': 67, 'Mick': 71, 'Charlie': 73}
2. Dic/onnaires.

Obten&on d’une “vue” sur les éléments d’un dic&onnaire :
Opéra&on Résultat
Permet d’avoir une « vue » sur l’ensemble
d.keys()
des clés de d
d.values()
des valeurs de d
d.items()
des couples clé : valeur de d

2. Dic/onnaires.

Exemple :
>>> rs = {'mick':71,'Keith':71,'Charlie':
73,'Ron':67}
>>> c = rs.keys()
>>> list(c)
['mick', 'Charlie', 'Keith', 'Ron']
>>> del rs['Ron']
>>> list(c)
['mick', 'Charlie', 'Keith']
>>> tuple(rs.items())
(('mick', 71), ('Charlie', 73), ('Keith',
71))

2. Dic/onnaires.
d. Itéra&on sur les éléments.

• Il est tout à fait possible d’itérer sur les éléments d’un
dic/onnaires. Plus précisément on peut itérer sur les clés,
sur les valeurs ou sur les couples clé : valeur.
• De même que pour les ensembles, les éléments n’étant

pas mémorisés de façon séquen/elle, l’ordre de parcours
sera par contre indéfini et imprévisible.

2. Dic/onnaires.

Exemple : itéra/on sur les clés, deux possibilités
rs = {'mick':71,'Keith':71,'Charlie':
73,'Ron':67}
for nom in rs:
print(nom,end=' ')
73,'Ron':67}
for nom in rs.keys():
print(nom,end=' ')

2. Dic/onnaires.

Exemple : itéra/on sur les valeurs
73,'Ron':67}
total = 0
for age in rs.values():
total += age
print("âge cumulé :",total,'ans')

2. Dic/onnaires.

Exemple : itéra/on sur les couples clé : valeur
73,'Ron':67}
for nom,age in rs.items():
print(nom,':',age,'ans')

2. Dic/onnaires.
e. Dict. définis “en compréhension”.

Syntaxe générale : le principe est exactement le même que
celui des listes ou ensembles définis en compréhension
{cx,y:vx,y for x,y in sequence if conditionnelle}

2. Dic/onnaires.

Exemple :
>>> d = {chr(i+64):i for i in range(1,5)}

>>> d
{'B': 2, 'C': 3, 'A': 1, 'D': 4}
>>> dd = {v:c for c,v in d.items()}
>>> dd
{1: 'A', 2: 'B', 3: 'C', 4: 'D'}

2. Dic/onnaires.

Exemple :
>>> d = {(x,y):x+y for x in range(4) for y

in range(3) if x!=y}
>>> d
{(0, 1): 1, (1, 2): 3, (3, 2): 5, (2, 0):
2, (3, 0): 3, (1, 0): 1, (3, 1): 4, (0,
2): 2, (2, 1): 3}
>>> dd = {x:x**2 for x in range(6)}
>>> dd
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

2. Dic/onnaires.
f. Exercice.
Exercice : à par/r de ce8e liste de t-‐uple
scrabbleT = [ (1, "EAINORSTUL"), (2, "DMG"), (3, "BCP"), (4,
"FHV"), (8, "JQ"), (10, "KWXYZ")]
Construire un dic/onnaire qui aura pour clés chacune des
le8res de l’alphabet, et pour valeur celle des règles du
scrabble.

2. Dic/onnaires.
f. Exercice.
Solu&on :
scrabbleT = [ (1, "EAINORSTUL"), (2,

"DMG"), (3, "BCP"), (4, "FHV"), (8,
"JQ"), (10, "KWXYZ")]
scrabbleD = { lettre:valeur for valeur,

listeLettres in scrabbleT for lettre in
listeLettres }

2. Dic/onnaires.
Fin de ce chapitre

3. FICHIERS.

3. Fichiers.
Plan de ce chapitre
a. Généralités.
b. Ouverture d’un fichier.
c. Fermeture d’un fichier.
d. Lecture dans un fichier.
e. Écriture dans un fichier.


3. Fichiers.
a. Généralités.
Objec&f de la ges&on de fichiers :
• Pouvoir conserver des données en mémoire de façon

durable.
• Pour l’instant nos données ne sont disponibles que

pendant l’exécu/on du programme.
• Pour nous, un fichier sera donc un support pour conserver
une masse de données.

3. Fichiers.
a. Généralités.
Deux principaux types de fichiers :

• Fichier texte : fichier organisé sous la forme d’une suite de
lignes, chacune étant composée d’un certain nombres de
caractères et terminée par ‘\n’.
• Fichier binaire : suite d’octets, pouvant représenter toutes

sortes de données.

3. Fichiers.

Syntaxe de l’ouverture d’un fichier :

monFichier = open(‘NomDuFichier’,’mode’)

• Le nom du fichier con/ent également son extension
(.txt, .csv, …).
• Le mode est la façon selon laquelle on va ouvrir le fichier.

3. Fichiers.

Remarque :

• Par défaut on considère que le fichier est situé dans le
même répertoire que notre script.
• Dans le cas contraire, on devra préciser son emplacement,

par exemple avec un chemin absolu (du style C:\ … sous
windows).

3. Fichiers.

Trois modes d’ouverture possibles :

• ‘r’ : lecture. On peut lire le contenu du fichier mais pas y
écrire. Le fichier doit exister auparavant.
• ‘w’ : écriture. Si le fichier existait, son contenu est effacé,
sinon il est créé.
• ‘a’ : ajout. Si le fichier existait on peut écrire à la fin de

celui-‐ci sans effacer son contenu. Sinon il est créé.

3. Fichiers.
c. Fermeture d’un fichier.

Syntaxe de la fermeture d’un fichier :

monFichier.close()

• Cela permet de libérer la mémoire allouée à ‘monFichier’.
• Cela permet également à d’autres applica&ons d’accéder

au fichier en ques/on.

3. Fichiers.

Syntaxe pour lire l’intégralité d’un fichier :

monFichier.read()

• Ce8e instruc/on retourne l’intégralité du fichier sous la
forme d’un ‘str’.

3. Fichiers.

Remarque :

• Si l’on passe un paramètre en/er à la fonc/on ‘read’, on
ne lira alors que ce nombre précis de caractère.
• On sera alors posi/onné à cet endroit pour une lecture

ultérieure.

3. Fichiers.

Exemple : imaginons que nous ayons ce
fichier texte dans notre répertoire courant.

3. Fichiers.

Exemple (suite) :
>>> monFichier = open('sympathy.txt','r')

>>> monTexte = monFichier.read()
>>> print(monTexte)
Please allow me to introduce myself
I'm a man of wealth and taste
I've been around for a long, long year
Stole many a man's soul to waste

3. Fichiers.

Remarque :

• Si le fichier est volumineux lire l’intégralité de celui-‐ci d’un
“seul coup” peut provoquer des débordements de
mémoire.
• Il sera préférable alors de passer un paramètre à la

fonc/on “read”.

3. Fichiers.

Syntaxe pour lire une ligne d’un fichier :

monFichier.readline()

Syntaxe pour créer une liste cons&tuée de toutes les lignes
d’un fichier :

monFichier.readlines()

3. Fichiers.

Exemple : avec le même fichier que précédemment, refermé
entre temps.

>>> ligne1 = monFichier.readline()
>>> print(ligne1)
Please allow me to introduce myself
>>> ligne2 = monFichier.readline()

>>> print(ligne2)
I'm a man of wealth and taste

3. Fichiers.

entre temps.

>>> maListe = monFichier.readlines()
>>> print(maListe)
['Please allow me to introduce myself\n',
"I'm a man of wealth and taste\n", "I've
been around for a long, long year\n",
"Stole many a man's soul to waste"]

3. Fichiers.

Itéra&on sur les lignes d’un fichier :
for maLigne in monFichier:

traitement de la ligne maLigne

3. Fichiers.

entre temps.
monFichier = open('sympathy.txt','r')
for ligne in monFichier:
print(ligne.upper(),end='')
monFichier.close()

3. Fichiers.

Syntaxe pour écrire dans un fichier :

monFichier.write(‘le texte à écrire’)

• Si on u/lise plusieurs fois ce8e fonc/on, on écrira les
différents textes les uns à la suite des autres.
• Le paramètre est nécessairement du type ‘str’, il faut donc

éventuellement conver&r les variables numériques.

3. Fichiers.

entre temps.
monFichier = open('sympathy.txt','a')
monFichier.write('And I was round when
Jesus Christ\n')
monFichier.write('Had his moment of doubt
and pain')
monFichier.close()

3. Fichiers.

Exemple : suite de l’exemple précédent, en mode ‘w’ on
efface l’ancien contenu
monFichier = open('sympathy.txt','w')
monFichier.write('plus de texte...')
monFichier.close()

3. Fichiers.
Fin de ce chapitre

Interfaces graphiques.

(1ADS-07) Autres Structures de Données

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

(1ADS-07) Autres Structures de Données

Transféré par

Droits d'auteur :

Formats disponibles

Autres structures de données.

1ADS Algorithm in Python

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Objec&fs de ce module

• Présenter des structures de données non

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Plan de ce module

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Plan de ce chapitre

a. Types « set » et « frozenset ».

a. Types “set” et “frozenset”.

• Par “ensemble” on entend ici une collec&on d’éléments

• On aura deux types pour ce faire :

– “set” qui sera une structure muable.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

• Comme en mathéma/ques, un ensemble ne pourra pas

• Lors de la créa/on d’un ensemble ou lors de sa mise à

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. Types “set” et “frozenset”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

c. Itéra&on sur les éléments.

• Leurs éléments n’étant pas mémorisés de façon

© SUPINFO Interna/onal University – h8p://www.supinfo.com

c. Itéra&on sur les éléments.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Opéra&ons spéciﬁques aux “set”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Opéra&ons spéciﬁques aux “set”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Opéra&ons spéciﬁques aux “set”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Opéra&ons spéciﬁques aux “set”.

e. Ensembles déﬁnis en compréhension.

{expression for x in sequence if conditionnelle}

© SUPINFO Interna/onal University – h8p://www.supinfo.com

e. Ensembles déﬁnis en compréhension.

>>> s = {x**2 for x in range(21) if x%2 == 0}

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Fin de ce chapitre

Avez – vous des ques/ons ?

© SUPINFO Interna/onal University – h8p://www.supinfo.com

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Plan de ce chapitre

• L’accès à une valeur se fait via sa clé.