Maîtriser les listes en Python

Les listes, qu’est-ce que ça peut bien être en programmation. Les listes sont un type de données structuré dont fait partie également les tuples et les dictionnaires. Nous resterons ici sur les listes.

Qu’est-ce qu’une liste ?

Une liste n’est ni plus ni moins qu’une liste de données organisées. C’est en quelque sorte un tableau à une dimension. Voici un exemple de création d’une liste en Python :

ma_liste_de_caracteres = ['L','I','S','T','E']
ma_liste_de_chiffres = [1, 5, 9, 7, 6]
ma_liste_mixte = ['L', 1,'S','T', 3]

Vous pouvez donc voir qu’une liste peut être définies avec plusieurs éléments. Ces éléments peuvent être de type différent. Pour connaitre les différents types de variables, je vous ai écrit un article dédié qui vous pouvez lire ici. Les listes en python sont de type « list ».

ma_liste = ['L', 1, 'S', 'T', 3]
type(ma_liste)
>>> list

Accéder aux éléments de la liste et les modifier

Contrairement aux tuples, les listes sont modifiables. L’objet de cet article n’est pas les tuples mais vous en entendrez certainement parlé. Pour faire court, un tuple est une liste qu’on ne peut pas modifier. Tout comme une chaîne de caractère, on ne peut pas modifier un caractère à l’intérieur, il faut d’abord la diviser. Les tuples suivent la même règle.

Accéder aux éléments de la liste

On peut accéder aux éléments d’une liste via leur index. Il faut savoir qu’en Python, les index commencent à 0. On peut récupérer un élément la liste en utilisant le nom de la variable suivant de l’index entre crochets.

ma_liste[2]
>>> 'S'

Dans l’exemple ci-dessus, l’index 2 renvoie le troisième élément de la liste, donc la lettre « S ». Voici une autre image qui explique l’indexation des listes.

Egalement, il est possible d’utiliser les index négatifs ! Cette pratique peut vous être très pratique si vous souhaitez récupérer les derniers éléments d’une liste. En effet, il est intéressant de savoir que l’indice « -1 » vous donnera le dernier élément de la liste, l’indice « -2 » l’avant dernier, etc …

ma_liste[-1]
>>> 3
ma_liste[-2]
>>> 'T'

Pour connaitre la taille d’une liste, il existe une fonction très pratique qui s’appelle « len() ». Voici un exemple :

len(ma_liste)
>>> 5

L’utilisation de cette fonction vous sera très utile lorsque vous voudrez définir les bornes d’une boucle. Une boucle « for » par exemple. Vous pourrez ainsi être sûr que vous parcourrez la liste entière.

Vous noterez que la fonction « len() » renvoie la valeur 5. Si vous utilisez la ligne de commande ma_liste[5] vous obtiendrez une erreur. Mais nous avons bien 5 éléments dans la liste. En fait, lorsque vous utilisez un boucle « for », vous pourrez également également utiliser la fonction « range() » qui permet de générer une liste de nombre entier allant de 0 à N-1. Si N=5 dans notre cas, le boucle ira de 0 à 4 ce qui est compatible de notre liste. Mais ceci fera l’objet d’un autre article sur les boucles et les structures de contrôle.

Modifier / extraire une partie d’une liste

Un élément de la liste peut être modifié directement en le désignant par son indice :

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste[2] = 5
ma_liste
>>> ['L', 1, 5, 'T', 3]

Vous pouvez également sélectionner une partie d’une liste en donnant un intervalle. C’est ce qu’on appelle un « slice » ou un tranche si je peux me permettre. L’intervalle est défini par l’indice de départ inclus et l’indice de fin exclu séparé par le signe « : ». Un petit exemple valant mieux qu’un long discours, voyez plutôt dans le code ci-dessous :

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste[2:4]
>>> ['S', 'T']

L’indice de départ est le 2, ce qui nous donne bien la lettre « S ». L’indice de fin est le 4 correspond au chiffre ‘3’ dans la liste. Mais j’ai bien écrit exclu ce qui veut dire que cet indice ne sera pas compris dans l’extraction de liste d’où le résultat avec les lettres ‘S’ et ‘T’. Cela peut paraître étrange mais Python fonctionne de cette manière.

Si vous souhaitez partir du début jusqu’à un certain index ou depuis un index jusqu’à la fin, vous pouvez omettre l’indice de début ou de fin respectivement. Voici un exemple illustré :

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste[:3]
>>> ['L', 1, 'S']
ma_liste[3:]
>>> ['T', 3]
ma_liste == ma_liste[:3] + ma_liste[3:]
>>> True

La première découpe donne les trois premiers éléments. La seconde donne la liste à partir du 4e élément jusqu’à la fin de la liste. On rappelle que l’indice 3 correspond au 4e élément dans une liste. Enfin, il est intéressant de voir que la somme des deux découpes correspond à la liste entière.

Viens ensuite les indices négatifs. Le signe négatif dans l’indice permet de partir de la fin. Idem, vous pourrez utiliser les « slices » avec des indices négatifs. Voici des exemples :

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste[-1] # le dernier élément de la liste
>>> 3
ma_liste[-2] # l'avant dernier élément de la liste
>>> 'T'
ma_liste[:-2] # la liste depuis le début jusqu'à l'avant dernier élément exclu
>>> ['L', 1, 'S']
ma_liste[-2:] # la liste depuis l'avant dernier élément jusqu'à la fin
>>> ['T', 3]

Opérations simples sur les listes

Vous pouvez réaliser des opérations sur les listes. Par exemple il est possible de fusionner deux listes avec le signe « + » ou en multiplier une avec le symbole « * »

lis = ['L', 1, 'S']
te = ['T', 3]
liste = lis + te
liste
>>> ['L', 1, 'S', 'T', 3]

lis * 2
>>> ['L', 1, 'S', 'L', 1, 'S']

liste_de_L = ['L'] * 7
liste_de_L
>>> ['L', 'L', 'L', 'L', 'L', 'L', 'L']

Vous pouvez supprimer un élément de la liste via son index avec l’expression « del ». Supprimer un élément de cette façon ne renvoie aucune valeur. Si vous avez besoin de récupérer la valeur lors de sa suppression, vous utiliserez alors la méthode « pop » que nous verrons plus loin dans l’article.

ma_liste = ['L', 1, 'S', 'T', 3]
del ma_liste[1]
ma_liste
>>> ['L', 'S', 'T', 3]

Pour savoir si un élément est présent dans une liste, vous pouvez utiliser l’instruction « in ». Voici un exemple :

ma_liste = ['L', 1, 'S', 'T', 3]
'T' in ma_liste
>>> True
'Z' in ma_liste
>>> False

Voilà, vous avez maintenant un aperçu sur comment manipuler les listes en python. Voyons maintenant dans la section suivante les méthodes associées aux listes.

Les méthodes associées aux listes en Python

Les méthodes permettent d’interagir avec votre variable liste et renvoie une valeur que vous pourrez utiliser ensuite. Une méthode, c’est comme une fonction mais associée à un type de variable. Pour appeler cette méthode, il faut la rajouter en suffixe à la variable.

Pour trouver une valeur et sa position : index

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste.index('S')
>>> 2
ma_liste.index(3)
>>> 4
ma_liste.index('Z')
Traceback (most recent call last):

  File "C:\Users\olivier\AppData\Local\Temp\ipykernel_8488\4273698224.py", line 1, in <cell line: 1>
    ma_liste.index('z')

ValueError: 'z' is not in list

Il est donc possible de retrouver l’indice d’une valeur dans la liste avec la méthode « index ». Cependant, si la valeur ne se trouve pas la liste, le code part en erreur.

Pour ajouter une valeur à la fin de la liste : append

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste.append('Z')
ma_liste
>>> ['L', 1, 'S', 'T', 3, 'Z']

La méthode « append » permet d’ajouter un élément dans la liste à la fin.

Ajouter un élément sur un indice défini : insert

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste.insert(1, 'Z')
ma_liste
>>> ['L', 'Z', 1, 'S', 'T', 3]

Supprimer un élément : remove

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste.remove('S')
ma_liste
>>> ['L', 1, 'T', 3]

Si vous essayez de supprimer un élément qui n’existe pas dans la liste, vous aurez une erreur.

Si la valeur que vous essayez de supprimer apparait plusieurs dans la liste, c’est la première instance qui sera supprimée.

ma_liste = ['L', 1, 'S', 'T', 3, 'S']
ma_liste.remove('S')
ma_liste
>>> ['L', 1, 'T', 3, 'S']

Si vous connaissez à l’avance l’index de la valeur à supprimer, vous pourrez plutôt utiliser l’instruction « del » vue précédemment.

Récupérer la valeur supprimée de la liste : pop

Enfin, si vous souhaitez récupérer la valeur qui est supprimée de la liste, vous pourrez utiliser la méthode « pop ». Pour utiliser la méthode « pop » vous devrez connaitre l’index de l’élément que vous souhaitez supprimer.

ma_liste = ['L', 1, 'S', 'T', 3]
element = ma_liste.pop(2)
element
>>> 'S'
ma_liste
>>> ['L', 1, 'T', 3]

Autres remarques concernant les listes

Si vous souhaitez inverser rapidement la liste, vous avez la méthode « reverse ». Attention toutefois car cette méthode modifie la liste.

ma_liste = ['L', 1, 'S', 'T', 3]
ma_liste.reverse()
ma_liste
>>> [3, 'T', 'S', 1, 'L']

Enfin, ce qui différence une liste d’un tableau est qu’on peut mettre une liste dans une éléments d’une liste. Ceci engendre donc des listes imbriquées. J’attire toutefois votre attention sur ce point. Si vous utilisez des listes imbriquées, la lisibilité du code sera fortement dégradée. Je vous le déconseille donc. Pour un tableau, sa dimension étant fixe, vous ne pourrez donc pas l’augmenter en imbriquant un autre tableau dans un élément de celui-ci.

Lorsque que vous avez à créer manuellement des listes assez longues, vous pouvez revenir à la ligne. En effet, tant que Python ne trouve pas le crochet de fermeture de la liste, celui-ci considère qu’il est toujours dans la définition de la liste.

ma_liste = ['L', 
1,
    'S', 
         'T', 
              3]
ma_liste
>>> ['L', 1, 'S', 'T', 3]

C’est moche, mais ça fonctionne 🙂

Voilà, j’espère que vous en savez un peu plus les listes. Merci de m’avoir lu et n’hésitez pas à laisser un commentaire.
A bientôt,
Benjamin