Bases de Python - Listes et Dictionnaires

Dans cet article, nous allons découvrir les deux principaux types de données en Python, ainsi que comment les manipuler et les utiliser. Pensez à ouvrir votre interpréteur Python afin de pratiquer également en même temps que moi !

Les listes

Définition

En Python, une liste est une structure de données utilisée pour stocker des valeurs. Elle peut contenir tous types de valeurs, et même différents types de valeurs pour une même liste.

Pour instancier une lise, on précise entre crochets les différentes valeurs qu'on souhaite stocker, séparées par des virgules. Exemple :

>>> couleurs = ["rouge", "bleu", "vert"]
>>> mixte = ["rouge", 6, 8.3, "bleu"]
>>> couleurs
["rouge", "bleu", "vert"]
>>> mixte
["rouge", 6, 8.3, "bleu"]

Manipulation

Pour accéder aux éléments d'une liste, on les appelle en utilisant leur index comme ceci :

>>> couleurs = ["rouge", "bleu", "vert"] 
>>> element = couleurs[1]
>>> element
"bleu"

Attention, les index commencent à partir de zéro. C'est à dire que pour accéder au premier élément d'une liste, on utilise l'index 0. Pour accéder au dernier index d'une liste de n éléments, on utilise donc l'index n-1.

On peut également utiliser l'index pour modifier la liste, simplement en assignant une nouvelle valeur à tel index.

>>> couleurs = ["rouge", "bleu", "vert"] 
>>> couleurs[2] = "jaune"  // Si vous avez bien suivi, le dernier élément de la liste devient "jaune"
>> couleurs
["rouge", "bleu", "jaune"] 

Pour cela, on utilise la méthode append d'une instance de liste. Une méthode est une fonction présente dans une classe. Pour ne rien compliquer, considérez qu'une méthode ne peut être appelée que par un objet d'une classe, alors qu'une fonction peut être appelée sans instancier d'objet (nous verrons plus tard que ceci est en fait faux, notamment à cause des méthodes dites "statiques"). Si vous ne savez pas ce qu'est un objet, considérez que c'est une sorte de type de données contenant des méthodes et des attributs (des attributs sont des variables propres à un objet). Ainsi, une liste est un objet contenant des méthodes (append par exemple, et des attributs, par exemple les éléments qu'elle stocke, sa longueur, etc...)

>>> couleurs = ["rouge", "bleu", "vert"] 
>>> couleurs.append("jaune")  # On ajoute "jaune" à la liste
>>> print(couleurs)
["rouge", "bleu", "vert", "jaune"] 

Pour appeler append, on instancie une liste, alors que la fonction print ne nécessite aucun objet particulier pour être appelée. Notez bien la syntaxe pour utiliser une méthode : objet.méthode(arguments). Remarquez que la méthode append ajoute l'élément à la fin de la liste, et non au début ou au milieu.

Parcourir une liste

Très souvent, nous aurons besoin de parcourir une liste, élément par élément. Vous vous rappelez de la boucle for vue dans le dernier article ? (https://www.propython.fr/post/bases-de-python-2 si vous ne l'avez pas lu)

Nous parlions d'itération et d'itérateurs, eh bien une liste est itérable, donc on peut la parcourir avec une boucle for. Reprenons l'exemple du dernier article :

for i in range(5):
	print(i)

Cela affiche successivement les valeurs de 0 à 4. C'est comme si i prenait successivement chaque valeur de la liste suivante : [0, 1, 2, 3, 4]. Appliquons maintenant une boucle for à une liste :

>>> couleurs = ["rouge", "bleu", "vert"] 
>>> for couleur in couleurs:
...     print(couleur)
...
rouge
bleu
vert

C'est exactement pareil qu'avec la fonction range. Ici, notre variable d'itération est couleur au lieu de i, et notre liste est ["rouge", "bleu", "vert"] au lieu de [0, 1, 2, 3, 4]. On affiche donc successivement chaque valeur de notre liste avec une boucle for.

Mais peut-être qu'on aimerait afficher en plus l'index de chaque élément ? Pour cela, on va utiliser la fonction range et la notation par index. Tout d'abord, il faut connaître la longueur de notre liste. Pour cela, on utilise la fonction len qui renvoie la longueur d'un objet.

>>> len(["a", "b", "c", "d"]
4

Et on utilise la longueur de notre liste dans la fonction range afin d'itérer sur chaque index.

>>> couleurs = ["rouge", "bleu", "vert"] 
>>> for index in range(len(couleurs)):  # On itère sur chaque index
...     print(index, couleurs[index])  # On utilise la notation par index pour récupérer l'élément de notre liste
...
0 rouge
1 bleu
2 vert

On peut donc parcourir notre liste soit de cette façon, soit de la première façon. Lorsque vous n'avez pas besoin de l'index, privilégiez la première façon, bien plus lisible et pratique. Lorsque vous avez besoin de l'index, ce qui arrive assez souvent, utilisez la deuxième.

Slicing

Une façon de manipuler les listes en utilisant les index est ce qu'on appelle les slices. C'est à dire qu'on va pouvoir découper nos listes en fonction des éléments auxquels on souhaite accéder. Par exemple, si on souhaite extraire les 10 premiers éléments d'une liste, ou les 10 derniers, cela est possible simplement en utilisant les slices. Si on considère L une liste, on peut découper notre liste en utilisant cette notation : L[2:5]. Cela signifie qu'on extrait une slice de notre liste de l'index 2 à l'index 5 (non inclus).

>>> couleurs = ["rouge", "bleu", "vert", "jaune", "marron", "gris"]
>>> couleurs [1:3]
["bleu", "vert"] 

Cela nous renvoie une sous liste de notre liste de base avec les éléments de l'index 1 à 3 (non inclus).

On peut aussi préciser un pas, c'est à dire extraire des éléments tous les k éléments, de cette façon : L[0:10:2]. Ici, on extrait les éléments de l'index 0 à l'index 10 avec un pas de 2. Exemple :

>>> couleurs = ["rouge", "bleu", "vert", "jaune", "marron", "gris"]
>>> couleurs [0:5:2]  # On récupère un élément tous les 2 index
["rouge", "vert", "marron"]

L'intérêt du slicing est de récupérer des slices, qui sont donc des sous listes, c'est à dire qu'on peut itérer dessus comme sur toute liste.

>>> couleurs = ["rouge", "bleu", "vert", "jaune", "marron", "gris"]
>>> for couleur in couleurs[0:3]:
...    print(couleur)
...
rouge
bleu
vert

Ici par exemple, on récupère les 3 premiers éléments d'une liste avec les slices et on les affiche successivement grâce à une boucle for.

Index négatifs

En Python, on a aussi la possibilité d'utiliser des index négatifs afin d'accéder aux éléments d'une liste à partir de la fin. Par exemple, L[-1] permet d'accéder au dernier élément d'une liste, L[-3] au 3ème élément, etc...

On peut donc aussi utiliser les index négatifs avec le slicing. Par exemple, pour parcourir une liste de la fin au début, on doit partir du dernier index (qu'on récupère avec L[-1], aller jusqu'à l'index 0, et avec un pas de -1 puisqu'on parcourt dans le sens inverse :

>>> couleurs = ["rouge", "bleu", "vert"]
>>> for couleur in couleurs[-1:0:-1]:
...    print(couleur)
...
vert
bleu
rouge

Voilà, c'est tout pour les listes. L'essentiel à retenir c'est qu'on peut stocker tout type d'objet dans des listes, ainsi on peut par exemple stocker une liste dans une liste, dans ce cas on y accède comme si on accédait à tout objet stocké dans une liste, après c'est à vous d'expérimenter aussi :)

On passe maintenant aux dictionnaires !

Les dictionnaires

Définition

Un dictionnaire est également une structure de donnée utilisée pour stocker des valeurs. A la différence d'un liste, les valeurs dans un dictionnaire ne sont pas stockées bout à bout et accessibles via un index, mais sont stockées sous la forme clé-valeur. C'est à dire qu'on associe chaque valeur d'un dictionnaire à une clé. Voyons cela avec un exemple :

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> personne["prenom"]
Jean

Voici donc la syntaxe d'un dictionnaire : dico = {clé1: valeur1, clé2: valeur2, ...}. Et on accède à une valeur de cette façon : dico[clé]. Une clé peut être une chaine de caractères, un entier, un nombre à virgule, un booléen, ou tout autre type hashable (nous reviendrons sur cela dans d'autres articles).

Attention, si vous essayer d'accéder à une valeur en utilisant une clé qui n'existe pas dans le dictionnaire, cela vous générera une erreur :

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> personne["age"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

Manipulation

Modifier une valeur existante

Vous savez déjà comment déclarer un dictionnaire et accéder à ses valeurs. Mais comment modifier une valeur déjà existante ? C'est simple, on accède à la valeur qu'on souhaite modifier via la syntaxe vue précédemment, et on y affecte une nouvelle valeur.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> personne["prenom"] = "Maurice"
>>> personne["prenom"]
Maurice

Supprimer une clé d'un dictionnaire

On utilise le mot-clé del permettant de supprimer un élément. Appliqué à une clé d'un dictionnaire, il permet de supprimer le couple clé-valeur.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> del personne["prenom"]
>>> personne
{"nom": "Dupont"}
# Le couple "prenom"-"Jean" a bien disparu

Vérifier si une clé est présente dans un dictionnaire

On utilise le mot-clé in permettant de savoir si un élément est présent dans un itérateur. Appliqué à un dictionnaire, il renvoie True si la clé recherchée est présente dans le dictionnaire, sinon False.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> "prenom" in personne
True
>>> "age" in personne
False

Récupérer une valeur autrement

Une autre façon de récupérer une valeur d'un dictionnaire est d'utiliser la méthode get(key, default]. Cette méthode vous permet de récupérer la valuer associée à une clé d'un dictionnaire si cette clé existe, et si elle n'existe pas vous récupérez une valeur par défaut passée en paramètre, ou None si jamais vous n'avez pas précisé de valeur par défaut. L'avantage de cette méthode est qu'elle ne vous génère pas d'erreur si la clé n'existe pas.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> personne.get("prenom")
Jean
>>> personne.get("age")
None
>>> personne.get("age", 43)
43

Parcourir un dictionnaire

Avant de parcourir un dictionnaire, il faut choisir ce que vous souhaitez parcourir, soit les clés, soit les valeurs, soit les deux.

Pour parcourir les clés, on peut utiliser le mot-clé in. En effet, lorsque l'on itère sur un dictionnaire, on récupère les clés.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> for key in personne:
...    print(key)
...
prenom
nom

On peut aussi parcourir les clés en utilisant la méthode keys() d'un dictionnaire. Cette méthode renvoie un objet sur lequel on peut itérer pour récupérer les clés.

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> for key in personne.keys():
...    print(key)
...
prenom
nom

Cela revient exactement au même qu'avec la première méthode.

Pour parcourir les valeurs, on le fait de la même façon que précédemment, sauf que la méthode utilisée est la méthode values().

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> for value in personne.values():
...    print(value)
...
Jean
Dupont

En effet, des fois on souhaite parcourir ces deux éléments en même temps. On utilise donc une fois de plus une boucle for, sauf qu'on va récupérer deux éléments plutôt que de récupérer soit les clés, soit les valeurs. On utilise pour cela la méthode items() qui va nous permettre d'itérer sur le couple clé-valeur de cette façon :

>>> personne = {"prenom": "Jean", "nom": "Dupont"}
>>> for key, value in personne.items():
...    print(key, ":", value)
...
prenom : Jean
nom : Dupont

On récupère simplement ces deux éléments en les séparant par une virgule dans la boucle for.

Vous avez maintenant les bases des dictionnaires en Python !

Le mot de la fin

Voilà, vous avez découvert les listes et les dictionnaires, et commencez à avoir pas mal de bases en Python. Dans le prochain article, nous traiterons un premier exercice afin de mettre ne pratique ce que vous avez appris jusque là !

Si c'est article vous a plus, si vous avez besoin de précisions, ou si vous avez des suggestions de choses à rajouter dans cet article, n'hésitez pas à laisser un commentaire, ou à me contacter par mail : contact@propython.fr

Merci à tous d'avoir lu, on se retrouve prochainement pour la suite de votre apprentissage de Python !