Les structures de données
Une structure de données est, comme son nom l'indique, une structure contenant plusieurs valeurs. On stocke cette structure dans une variable. On pourra y retrouver des entiers, des chaînes de caractères, des booléens ... Bref, tout type utilisé en programmation, même des objets.
Nous nous focaliserons sur 2 structures distinctes : les listes et les dictionnaires.
Les listes
Une liste est une structure de données dite linéaire, chaque élément la comportant est rangée à une position spécifique, appelée indice.
Les différents usages des listes :
- Création
- Accès aux éléments
- Méthodes
- Parcours
On définit une liste grâce aux opérateurs [ ], que l'on stocke dans une variable. Cette liste peut être vide, ou remplie :
On accède aux éléments d'une liste grâce à un indice, qui est un entier. L'indice correspond à la position d'un élément dans la liste.
Le premier indice est toujours la valeur 0.
Pour accéder à un élément d'une liste, il faut mettre la variable de la liste, suivie d'un indice entre crochets :
On peut également accéder à une sous-liste de la liste principale en mettant [début:fin]. début correspond au premier indice que l'on prend, et fin au dernier indice exclu. Si début n'est pas précisé, on prendra le tout premier indice. Si fin n'est pas précisé, on prendra jusqu'au dernier indice.
Les listes sont des objets, et possèdent un ensemble de méthodes permettant d'effectuer diverses manipulations sur celles-ci :
append(element) : ajoute element dans la liste.
pop() : supprime et retourne le dernier élément de la liste. Il est possible de mettre un indice en paramètre.
remove(element) : supprime element de la liste, si celui-ci existe.
len(liste) : retourne la taille de la liste en paramètre.
Il existe 2 façons distinctes de parcourir une liste : soit par itérateur, soit par élément.
Itérateur :
On utilise une variable qui va s'incrémenter à chaque tour de boucle, et on se sert de cette variable comme indice pour la liste.
Quand on souhaite parcourir une liste, on utilise (presque) tout le temps les méthodes range(len(liste)) pour parcourir l'entièreté de la liste. Ce qui donnerait :
Exécution :
On appelle par défaut le variant de la boucle i.
Élément :
On utilise une variable qui, à chaque tour de boucle, devient un élément de la liste.
On utilise une boucle for, ainsi que le mot-clé in :
Exécution :
Les dictionnaires
Un dictionnaire est une structure de données dans laquelle on associe une clé à une valeur.
Une clé est un élément unique qui peut être de tout type de base (entier, chaine de caractères, caractère) et permet de retrouver la valeur qui lui est associée, un peu comme un dictionnaire papier qui nous permet de retrouver la définition d'un mot à partir de ce mot !
Les valeurs d'un dictionnaire peuvent être de tout type. On pourra y mettre des entiers, des booléens, des objets, des listes, des dictionnaires ...
Cependant, il ne peut y avoir qu'une seule valeur associée à une clé. Si l'on souhaite mettre plusieurs valeurs pour une clé, il faudra mettre toutes ces valeurs dans une liste par exemple.
Les différents usages des dictionnaires :
- Création
- Ajouter un élément
- Accès aux valeurs
- Modifier une valeur
- Parcours
On définit un dictionnaire grâce aux opérateurs { }, que l'on stocke dans une variable. Ce dictionnaire peut être vide, ou rempli en écrivant dans les accolades cle1 : valeur1, cle2 : valeur2 ... :
dico1 = {}
dico2 = {cle1 : valeur1, cle2 : valeur2}
On peut ajouter des clés et valeurs dans un dictionnaire sans utiliser de méthodes comme les listes. Il suffit d'écrire :
mon_dico[nouvelle_cle] = nouvelle_valeur
mon_dico est le dictionnaire dans lequel on souhaite ajouter de nouveaux éléments ;
nouvelle_cle est la nouvelle clé que je souhaite ajouter ;
nouvelle_valeur est la nouvelle valeur que je souhaite ajouter.
On accède aux valeurs d'un dictionnaire grâce à ses clés que l'on précise entre crochets.
dico = {"a" : 1, "b" : 5}
print(dico["a"])
dico2 = {5 : ["a",3]}
print(dico[5][1])
On accède dans le premier print à la valeur de la clé a, ce qui donne 1.
Dans le second, on accède à la valeur de la clé 5 qui est une liste, et on accède au 2ème élément de cette liste, ce qui donne 3.
Les clés d'un dictionnaire ne sont pas modifiables. Par contre, les valeurs associées aux clés peuvent être modifiées, en remplaçant par exemple la valeur d'une clé par une autre :
dico = {'cle1' : 3, 'cle2' : ['test']}
dico['cle2'] = 1
Ici, la nouvelle valeur associée à cle2 sera 1 ; ['test'] a été remplacé.
Il existe 3 façons distinctes de parcourir un dictionnaire : par clés, par valeurs, ou bien en parcourant les 2.
Par clés :
Un dictionnaire possède une méthode appelée keys() qui permet de donner une liste contenant les clés du dictionnaire. Ainsi une boucle for donnerait :
dico = {'cle1' : 3, 'cle2' : ['test']}
for cles in dico.keys() :
print(cles)
La variable cles devient à chaque itération le contenu des clés du dictionnaire.
A la première itération, cles vaut cle1, puis à la seconde, cle2.
Par valeurs :
De la même manière que pour les clés, il existe une méthode values() permettant d'obtenir une liste des valeurs du dictionnaires, que l'on peut parcourir de la même façon :
dico = {'cle1' : 3, 'cle2' : ['test']}
for valeurs in dico.values() :
print(valeurs)
La variable valeurs devient à chaque itération le contenu des valeurs du dictionnaire.
A la première itération, valeurs vaut 3, puis à la seconde, ['test'].
En parcourant les 2 :
Pour finir, il existe une troisième méthode permettant de parcourir clés et valeurs en même temps : items(). Il faudra, lors de la boucle, préciser 2 variables :
dico = {'cle1' : 3, 'cle2' : ['test']}
for cles, valeurs in dico.items() :
print(cles, valeurs)
Comme pour les exemples précédents, cles et valeurs auront à chaque itération la clé et sa valeur associée.