Manipulation de listes en Python

Spécifier le type des variables Manipulation de tuples

Accès rapide :
La vidéo
Présentation du type list
Définition de listes de données
Accéder aux valeurs d'une listes de données
Vérifier la présence ou non d'une données dans la liste
Ajouter des valeurs dans une liste
Supprimer des valeurs d'une liste
Parcourir une liste de données
La notion de « slicing »
Extraction de sous-listes avec des slices
Utilisation d'une slice pour supprimer des données d'une liste
Les « List Comprehensions » (ou listes en compréhension, en français)
Compléments sur la manipulation de vos listes
Quelques fonctions applicables aux listes
Quelques méthodes de la classe list
Quelques opérateurs de la classe list
Typage de vos listes
Travaux pratiques
Les énoncés
Les corrections

La vidéo

Cette vidéo vous montre comment définir et utiliser des listes de données en Python. Divers opérateurs, fonctions et méthodes vous sont présentés.

Présentation du type list

Définition de listes de données

En Python, le type list permet de représenter un tableau (un ensemble de valeurs). Le langage ne fait pas la distinction entre la notion de tableau ou de liste : on priviligiera à partir de maintenant la terminologie de liste. Pour définir une liste, on utilise la syntaxe [], comme le montre l'exemple suivant.

>>> data = [10, 20, 30, 40, 50]
>>> data
[10, 20, 30, 40, 50]
>>> type(data)
<class 'list'>
>>> 

Une liste Python n'est pas limitée à un type de données unique : vous pouvez donc avoir des données quelconque dans une liste. Voici un exemple de définition d'une liste contenant des données diverses et variées.

>>> data = [10, 2.3, True, "Une chaîne", False, ["une", "sous", "liste"]]
>>> data
[10, 2.3, True, 'Une chaîne', False, ['une', 'sous', 'liste']]
>>> 

Accéder aux valeurs d'une listes de données

Une première chose à savoir, c'est quelle est la taille (le nombre d'éléments qui la constitue) de votre liste. Pour ce faire, il faut utiliser la fonction len.

>>> data = [10, 20, 30, 40, 50]
>>> nb = len(data)
>>> print("Nombre d'éléments :", nb)
Nombre d'éléments : 5
>>> 

Une fois la taille de la liste connue, vous pouvez commencer à manipuler les valeurs de la liste via l'opérateur []. Cet opérateur permet d'accéder à un élément de la liste par sa position. Il est important de mémoriser que les indices (les positions) dans une liste commencent à 0. Ainsi, si une liste contient cinq éléments alors les indices seront compris entre 0 et 4. Voici un exemple de récupération des valeurs d'une liste.

>>> data = [10, 20, 30, 40, 50]
>>> data[0]     # On récupère le premier élément
10
>>> data[1]     # Le second
20
>>> data[2]
30
>>> data[3]
40
>>> data[4]     # Le dernier élément de la liste
50
>>> data[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> 

Il est aussi possible d'utiliser l'opérateur [] pour modifier le contenu d'une liste. Voici un petit exemple.

>>> data = [10, 20, 30, 40, 50]
>>> data[2] = 3000
>>> data
[10, 20, 3000, 40, 50]
>>> 

Contrairement à certains autres langages de programmation, Python autorise l'utilisation d'index négatifs : Dans ce cas, on accède aux valeurs de la collection par la fin : -1 correspond à l'indice du dernier éléments de la liste, -2 correspond à l'indice de l'avant-dernier élément... Voici un exemple d'utilisation d'index négatif.

>>> data = [10, 20, 30, 40, 50]
>>> data[-1]    # Dernier élément
50
>>> data[-2]
40
>>> data[-3]
30
>>> data[-4]
20
>>> data[-5]
10
>>> data[-6]    # Premier élément
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> 

Vérifier la présence ou non d'une données dans la liste

Il est aussi possible de savoir si une valeur est présente dans la liste en utilisant l'opérateur in. Voici un exemple d'utilisation.

>>> l = [10, 20, 30, 40, 50]
>>> 10 in l
True
>>> 100 in l
False
>>> is_present = 30 in l
>>> if is_present: print("30 est présent dans la liste")
... 
30 est présent dans la liste
>>> 

A contrario, vous pouvez vérifier si une information n'est pas présente dans la liste avec l'opérateur not in. Voici des exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> 20 not in data
False
>>> 25 not in data
True
>>> 

Ajouter des valeurs dans une liste

Pour ajouter une nouvelle valeur en fin de liste, on utilise la méthode append. Vous pouvez aussi utiliser la méthode insert pour insérer une valeur à une position donnée (basée à partir de 0, bien entendu). Voici deux exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> data.append(60)
>>> data
[10, 20, 30, 40, 50, 60]
>>> data.insert(2, 25)
>>> data
[10, 20, 25, 30, 40, 50, 60]
>>>

Supprimer des valeurs d'une liste

Pour supprimer une valeur à une position donnée de votre liste, vous pouvez utiliser l'opérateur del. Il est aussi possible d'utiliser la méthode pop pour arriver au même résultat. La différence entre les deux possibilités est que la méthode pop vous renvoie la valeur supprimée, comme le montre l'exemple suivant.

>>> data = [10, 20, 30, 40, 50]
>>> del data[2]         # Utilisation de l'opérateur del
>>> data
[10, 20, 40, 50]
>>> data.pop(2)         # Utilisation de la méthode pop
40
>>> data
[10, 20, 50]
>>> data.pop()          # Utilisation de la méthode pop
50
>>> data
[10, 20]
>>> 

Si vous ne connaissez pas la position de l'élément à supprimer, vous pouvez aussi utiliser la méthode remove qui supprime la première occurrence d'une valeur dans la liste.

>>> l = [10, 20, 30, 20, 40]
>>> l.remove(20)
>>> l
[10, 30, 20, 40]
>>> l.remove(50)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> 

Si vous souhaitez supprimer toutes les valeurs présentes dans une liste, vous pouvez aussi invoquer la méthode clear.

>>> data = [10, 20, 30, 40, 50]
>>> data.clear()
>>> data
[]
>>>

Parcourir une liste de données

Il est bien entendu possible de parcourir tous les éléments d'une liste. Pour ce faire, vous pouvez utiliser une boucle while. Il faudra juste gérer un index qui va s'incrémenter au fur et à mesure de la progression dans la liste. Comme cela fait maintenant plusieurs fois qu'on utilise une boucle while (tant que), je pense que l'exemple ci-dessous ne vous posera aucune difficulté : cette fois-ci, tapez les lignes de code suivantes dans un éditeur Python (PyCharm par exemple) et non pas dans l'interpréteur interactif.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 

data = [10, 20, 30, 40, 50]

# On démarre le parcours à partir de la première position
index = 0

# On calcule, une fois pour toute, la taille de la liste
length = len(data)

# On traite chaque élément de la liste, un par un
while index < length:
    value = data[index]
    index += 1
    
    print(value)
    
print("Parcours terminé")

Et voici les résultats produits par cet exemple.

$> python sample.py
10
20
30
40
50
Boucle while terminée
$> 

Bien que la boucle while fonctionne parfaitement, ce n'est pas la meilleure manière de parcourir tous les éléments d'une liste. Une autre construction est bien plus pratique : la boucle for. Effectivement, celle-ci vous évite de gérer l'index de parcours vous-même et elle va vous permettre de récupérer chaque valeur de la liste à tour de rôle dans une variable.

La syntaxe est simple : on commence par le mot clé for suivit du nom de la variable qui va recevoir une à une les valeurs de la collection, puis on trouve le mot clé in lui-même suivit de la collection à traiter et enfin un caractère : introduit le bloc d'instructions à exécuter à chaque tour de boucle. En voici un exemple d'utilisation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 

data = [10, 20, 30, 40, 50]

# On traite chaque élément de la liste, un par un
for value in data:
    print(value)
    
print("Parcours terminé")

Les résultats sont exactement les mêmes que ceux produits par la boucle while. Et vous aurez certainement validé la simplicité de la syntaxe, comparé à la boucle while.

La notion de « slicing »

Extraction de sous-listes avec des slices

Nous avons parlé de l'opérateur [] qui permet d'accéder aux éléments de la liste. Pour le moment, nous avons accédé aux valeurs une à une, mais il est aussi possible d'accéder à plusieurs valeurs de la liste via un seul appel à l'opérateur []. Dans ce cas, on parle de « slice » (de tranches, si l'on parle en français).

Pour extraire une sous-liste, à l'instar des chaînes de caractères, il faut passer l'indice de début (basé à partir de 0) et l'indice de fin (position exclusive) de cette dernière. Les deux indices doivent être séparés par un caractère :. Voici quelques exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> data[1:3]
[20, 30]
>>> data[1:4]
[20, 30, 40]
>>> data[1:5]
[20, 30, 40, 50]
>>> data[:4]
[10, 20, 30, 40]
>>> data[2:]
[30, 40, 50]
>>> data[:]
[10, 20, 30, 40, 50]
>>> 

Il est aussi possible d'extraire les éléments d'une sous-liste tout les « n » éléments. Imaginons que vous ayez une liste qui contiennent des coordonnées x, y qui suivent les une après les autres. Si vous souhaitez extraire que les abscisses (les x), vous pouvez le faire en spécifiant la slice suivante : coords[::2] (avec le pas en troisième paramètre de la slice). Pour obtenir toutes les ordonnées (les y), veuillez utiliser la slice suivante : coords[1::2], pour débuter l'extraction à partir de la seconde valeur par pas de 2. Voici un exemple d'utilisation.

>>> #         x, y, x,  y, x,  y,  x, y
>>> coords = [0, 0, 10, 5, 13, 12, 5, 7]
>>> 
>>> all_x = coords[::2]
>>> all_x
[0, 10, 13, 5]
>>> 
>>> all_y = coords[1::2]
>>> all_y
[0, 5, 12, 7]
>>> 

Utilisation d'une slice pour supprimer des données d'une liste

Vous pouvez utiliser une slice pour supprimer des données d'une liste. Voici quelques exemples d'utilisation.

>>> data = [10, 20, 30, 40, 50]
>>> del data[1:4]       # On supprime tous les éléments d'index compris en 1 et 4 (exclusif).
>>> data
[10, 50]
>>> data = [10, 20, 30, 40, 50]
>>> del data[1:4:2]     # Cette fois ci, on a un pas de 2
>>> data
[10, 30, 50]
>>> 

Les « List Comprehensions » (ou listes en compréhension, en français)

Le langage Python permet de définir une liste par filtrage et adaptation du contenu d'une autre liste : on parle de liste en compréhension. Bien que l'on puisse faire cela avec des simples boucles (while ou for), les listes en compréhension propose une syntaxe plus simple et compacte : je vous recommande donc leurs utilisations.

Commençons par un exemple simple : on veut filtrer toutes les valeurs positives dans un liste de valeurs numériques. Voici comment faire :

>>> original = [10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> positive_values = [x for x in original if x >= 0]    # Notre liste en compréhension
>>> positive_values
[10, 3, 7, 0, 5, 9, 16]
>>> 

Si l'on décompose la liste en compréhension, la séquence for x in original indique que nous allons parcourir toutes les valeurs de la liste originale et tour à tour chaque valeur sera nommée x. La partie de droite, if x >= 0, correspond au filtrage à proprement parler : on ne veut considérer que les valeurs supérieures ou égales à 0. La partie de gauche, x, indique que pour chaque valeur sélectionnée, on la pousse telle quelle dans la liste de destination. Comme au final on veut produire une nouvelle liste, le tout est placé entre crochets : c'est logique, car ces caractères introduisent une liste.

Nous aurions pu aussi sélectionner et doubler (x * 2) chaque valeur positive de la liste : voici comment s'y prendre :

>>> original = [10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> positive_values = [x * 2 for x in original if x >= 0] 
>>> positive_values
[20, 6, 14, 0, 10, 18, 32]
>>> 

Il faut aussi savoir, que la partie relative au filtrage (la partie de droite de la liste en compréhension) n'est pas obligatoire. Dans ce cas, toutes les valeurs seront sélectionnées.

>>> original = [10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> positive_values = [x * 2 for x in original] 
>>> positive_values
[20, -4, 6, -2, 14, 0, 10, 18, -6, 32]
>>> 

>>> original = [10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> copy = [x for x in original]
>>> copy
[10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> 
>>> # Voici une autre technique, plus standard, pour cloner une liste
>>> copy2 = list(original)
>>> copy2
[10, -2, 3, -1, 7, 0, 5, 9, -3, 16]
>>> 

Notez aussi que, contrairement à ce que pourrait laisser présager les exemples précédents, une liste en compréhension peut être utilisée avec des types de données quelconque, tant que les traitements demandés restent bien cohérents avec ce type. Voici un exemple de liste en compréhension s'appliquant sur des données de type str (chaînes de caractères) : on y sélectionne que les langages de programmation commençant par la lettre P et on les considère en majuscules.

>>> langages = ["c", "Java", "Python", "c++", "Perl", "Visual Basic"]
>>> selection = [lang.upper() for lang in langages if lang[0] == 'P']
>>> selection
['PYTHON', 'PERL']
>>> 

Compléments sur la manipulation de vos listes

Quelques fonctions applicables aux listes

Il existe de nombreuses fonctions applicables aux listes Python. Nous pouvons notamment citer :

• len : cette fonction permet de calculer la taille d'une liste (mais nous l'avions déjà présentée).

  >>> data = [50, 10, 30, 20, 40, 60]
  >>> len(data)
  6
  >>> 

• max : cette fonction permet de calculer la valeur maximale contenu dans une liste de données. Il est à noter que cette fonction peut aussi être invoquée avec un nombre quelconques de paramètres : dans ce cas, c'est le paramètre contenant la plus grande valeur qui sera retourné.

  >>> data = [50, 10, 30, 20, 40, 60]
  >>> max(data)                     # Invoquée avec une liste de valeur
  60
  >>> max(50, 10, 30, 20, 40, 60)   # Invoquée avec un nombre variable de paramètres
  60
  >>> 

• min : cette fonction permet de calculer la valeur minimale contenu dans une liste de données. Il est à noter que cette fonction peut aussi être invoquée avec un nombre quelconques de paramètres : dans ce cas, c'est le paramètre contenant la plus grande petite qui sera retourné.

  >>> data = [50, 10, 30, 20, 40, 60]
  >>> min(data)                     # Invoquée avec une liste de valeur
  10
  >>> min(50, 10, 30, 20, 40, 60)   # Invoquée avec un nombre variable de paramètres
  10
  >>> 

• sum : cette fonction permet de sommer toutes les valeurs de la liste passée en paramètre. Attention, les données de la liste doivent obligatoirement être numériques.

  >>> data = [50, 10, 30, 60, 40, 20]
  >>> total = sum(data)
  >>> total
  210
  >>> 

Quelques méthodes de la classe list

Vous vous en doutez, la classe list expose aussi de nombreuses méthodes bien utiles. En voici quelques-unes : vous pouvez cliquer sur le nom de la méthode pour en obtenir un descriptif plus détaillé.

Quelques opérateurs de la classe list

De nombreux autres opérateurs sont aussi proposés par la classe list. Voici quelques exemples d'utilisation.

>>> l1 = [10, 20, 30, 40, 50]
>>> l2 = [60, 70, 80, 90, 100]
>>> 
>>> # Concaténation de listes
>>> full = l1 + l2
>>> full
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> 
>>> # Répétition d'une liste
>>> l1 * 3
[10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50]
>>> 
>>> # Comparaison de listes
>>> l1 == l2
False
>>> 
>>> # Recherche d'une valeur dans une liste
>>> 30 in l1
True
>>> 70 in l1
False
>>>
>>> # Insertion de valeurs dans une liste
>>> l1 += l2
>>> l1
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> 

Typage de vos listes

Nous avons vu, dans les chapitres précédents, qu'il était possible de spécifier le type de vos variables lors de leurs déclarations. Il en va de même pour vos listes et vous pouvez même indiquer le type des éléments qu'une liste doit contenir. Voici un exemple de code indiquant que la variable data sera typée en tant que liste de valeurs flottantes (list[float]).

 1 
 2 
 3 

# Attention : Python 3.9 ou supérieur requis !!!
data: list[float] = [10, 20.2, 13.4]
print(data)

 1 
 2 
 3 
 4 
 5 

from typing import List

# Syntaxe recommandée pour des versions antérieures à Python 3.9            
data: List[float] = [10, 20.2, 13.4]
print(data)

N'oubliez pas que certains IDEs peuvent vérifier les informations de typage : c'est le cas de PyCharm. Si vous tentez d'insérer autre chose qu'une valeur flottante dans la liste ci-dessus, l'IDE pourra signaler cette incohérence. Voici une capture d'écran de PyCharm montrant cette capacité.

Vous pouvez aussi utiliser l'outil « mypy » pour vérifier la cohérence des types de votre programme. Voici un exemple de vérification.

[$> mypy test_typing.py 
test_typing.py:2: error: List item 3 has incompatible type "str"; expected "float"
test_typing.py:4: error: Argument 1 to "append" of "list" has incompatible type "str"; expected "float"
Found 2 errors in 1 file (checked 1 source file)
$> 

Travaux pratiques

Les énoncés

Exercice 1 : écrire un programme qui calcule la somme et la valeur moyenne d'une liste de données numériques. Il vous est demandé de procéder un utilisant une instruction de boucle.

Exercice 2 : écrire un programme qui calcule la somme et la valeur moyenne d'une liste de données numériques. Cette fois-ci, il vous est demandé de pas utiliser d'instruction de boucle.

Exercice 3 : en vous basant sur la méthode os.listdir du module os, veuillez uniquement sélectionner les fichiers d'un dossier donné qui auront l'extension .py. Le problème étant que la fonction os.listdir vous retourne tous les fichiers contenus dans le dossier considéré : il faudra donc filtrer les bons fichiers.

>>> import os
>>> files = os.listdir("./demo")
>>> files
['file1.txt', 'file1.py', 'file2.txt', 'file2.py', 'file3.txt', 'file3.py']
>>> 

Bien entendu, essayez de faire ces exercices sans regarder directement la correction ci-dessous. ;-)

Les corrections

Exercice 1 : voici donc comment calculer la somme et la moyenne d'une liste de valeurs numériques en utilisant une boucle for.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 

from random import random

# Partie 1 - on génère une liste de valeurs numériques
data = []
for i in range(10):
    value = round((random() - 0.5) * 100, 2)
    data.append(value)
print(data)

# Partie 2 - on calcule la somme des valeurs et la moyenne
total = 0
for value in data:
    total += value
    
mean = total / len(data)

# On affiche les résultats
print(f"Total = {total:.2f}")
print(f"Mean = {mean:.2f}")

Et voici le résultat produit par cet exemple.

$> python sample.py
[-11.55, 41.19, -39.87, 28.44, -36.8, 29.29, -42.56, -4.37, -21.95, 14.88]
Total = -43.30
Mean = -4.33
$> 

Exercice 2 : pour calculer la somme des valeurs sans utiliser une boucle, vous pouvez utiliser la fonction sum.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 

from random import random

# Partie 1 - on génère une liste de valeurs numériques
data = []
for i in range(10):
    value = round((random() - 0.5) * 100, 2)
    data.append(value)
print(data)

# Partie 2 - on calcule la somme des valeurs et la moyenne
total = sum(data)
mean = total / len(data)

# On affiche les résultats
print(f"Total = {total:.2f}")
print(f"Mean = {mean:.2f}")

Sachez aussi qu'il existe un module proposant des fonctions de calculs statistiques : le module statistics. Il propose notamment la fonction mean qui calcule la moyenne d'une liste de valeurs. Vous pourriez donc aussi écrire le programme ainsi.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 

from random import random
from statistics import mean

# Partie 1 - on génère une liste de valeurs numériques
data = []
for i in range(10):
    value = round((random() - 0.5) * 100, 2)
    data.append(value)
print(data)

# Partie 2 - on calcule la somme des valeurs et la moyenne
total = sum(data)
m = mean(data)

# On affiche les résultats
print(f"Total = {total:.2f}")
print(f"Mean = {m:.2f}")

Exercice 3 : le plus simple pour filtrer la liste des fichiers contenus dans un dossier est d'utiliser une liste en compréhension. Voici comment faire.

 1 
 2 
 3 
 4 
 5 
 6 
 7 

import os

files = os.listdir(".");
python_files = [file for file in files if file.endswith(".py")]

for file in python_files:
    print(file)

Spécifier le type des variables Manipulation de tuples