Les listes

Pourquoi utiliser des listes ?

Mise en situation

Vous devez gérer les données des planètes des différents systèmes solaires. Chaque planète a un nom. Vous ne savez pas combien de planètes sont exactement présentes dans ces systèmes solaires. Vous devez afficher le nom de toutes les planètes.

Solution sans liste

# Saisie de chaque variable
planete_01_nom = "Mercure"
planete_02_nom = "Vénus"
planete_03_nom = "Mars"
planete_04_nom = "Terre"
# jusqu'à
planete_08_nom = "Uranus"


# Affichage des noms et des distances un par un
print(planete_01_nom)
print(planete_02_nom)
print(planete_03_nom)
print(planete_04_nom)
# jusqu'à
print(planete_08_nom)

Solution avec une liste

L’utilisation des listes permettra d’exécuter cette tâche beaucoup plus facilement. Vous pourrez ajouter/modifier/enlever des planètes.

Losque nous ne connaissons pas le nombre de données à saisir dans une liste, il convient de créer une liste vide.

# Remplissage de la liste
planetes = []

Une fois cette liste vide instanciée, nous utilisons la méthode append() pour rentrer nos informations.

planetes.append("Mercure")
planetes.append("Vénus")
planetes.append("Mars")
planetes.append("Terre")
# etc...
planetes.append("Uranus")
print(planetes)

['Mercure', 'Vénus', 'Mars', 'Terre', 'Uranus']

Enfin, pour afficher les données de notre liste, nous devons boucler sur cette liste afin d’afficher les planètes une par une. Pour cela, la boucle for s’y prête bien.

• 1er exemple:

for i in range(len(planetes)):
    print(planetes[i])

Mercure
Vénus
Mars
Terre
Uranus

Dans ce premier exemple, nous bouclons sur la longueur de notre liste et nous affichons le ième élément de notre liste où i correspond à notre indice.
len(planetes) nous retourne la longueur de la liste.
Ce sont les [] avec l’indice i qui donnerons l’accès à la valeur saisie.

• 2ème exemple:

for planete in planetes:
    print(planete)

Mercure
Vénus
Mars
Terre
Uranus

Dans ce deuxième exemple nous parcourons la liste pour afficher directement les données une à une présente dans notre liste.

L’affichage est exactement le même, seule la méthode change.

Qu’est-ce qu’une liste ?

En Python, une liste est une collection ordonnée et modifiable d’éléments. Les listes sont utilisées pour stocker plusieurs éléments dans une seule variable et peuvent contenir des éléments de différents types, y compris des nombres, des chaînes de caractères, d’autres listes, etc. Les listes en Python sont définies en utilisant des crochets [].

Caractéristiques d’une liste

• Ordonnée : Les éléments de la liste conservent un ordre défini, ce qui signifie que l’ordre dans lequel vous ajoutez les éléments est préservé.
• Modifiable : Une liste peut être modifiée après sa création, ce qui signifie que vous pouvez ajouter, supprimer ou changer des éléments.
• Taille Dynamique : Une liste en Python peut changer de taille dynamiquement. Vous pouvez ajouter ou supprimer des éléments sans avoir à spécifier la taille initiale de la liste.
• Hétérogène : En Python, une liste peut contenir des éléments de différents types (entiers, chaînes de caractères, listes, etc.).
  • Bien qu’il est possible de le faire, il faut rester prudent lorsqu’on utilise des listes hétérogènes. Elles pourraient entraîner des erreurs, notamment dans les boucles.

Comment utiliser une liste ?

Opérations simples

Création d’une liste

Comme stipulé précédemment, si nous n’avons pas connaissance de la quantité de données que nous mettrons à l’intérieur de notre liste, il faut créer une liste vide. Dans le cas contraire, il est possible de directement saisir les données à l’intérieur de la liste sans faire la première étape.

# Création d'une liste vide
ma_liste = []

# Liste avec des éléments
ma_liste = [6, 3, 8, 9, 7, 3, 1, 2]

Accès aux Éléments d’une Liste

Les crochets [] sont utilisés pour accéder directement à l’élément correspondant.

# Accès au premier élément
print(ma_liste[0])  # Affiche 6

# Accès au dernier élément
print(ma_liste[-1])  # Affiche 2

# Opérations sur les éléments de la liste
somme = ma_liste[1] + ma_liste[3]  # est l'équivalent de 3 + 9, soit les éléments qui se trouve aux indices 1 et 3
print(somme)    # Affiche 12

Notez que les indices commencent à zéro.

Ajout d’Éléments

# Liste vide
ma_liste = []

# Ajoute la valeur 6 à la fin de la liste
ma_liste.append(6)

# Ajoute la valeur 3 à la fin de la liste
ma_liste.append(3)

ma_liste.append(8)
ma_liste.append(9)
ma_liste.append(7)
ma_liste.append(3)
ma_liste.append(1)
ma_liste.append(2)

Modification des Éléments

# La valeur de la case à l'indice 2 est maintenant 0
ma_liste[2] = 0

# La valeur de la case à l'indice 4 est maintenant la même que celle de la case à l'indice 7
ma_liste[4] = ma_liste[7]

Suppression d’Éléments

# Supprime le dernier élément de la liste
ma_liste.pop()

# Supprime l'élément à l'indice 2
ma_liste.pop(2)

# Supprime la première occurrence de la valeur 3
ma_liste.remove(3)

Insertion

# Insert la valeur 7 à l'indice 3
ma_liste.insert(3, 7)

Triage

La fonction sort() modifie la liste initiale, elle ne se stocke pas dans une nouvelle variable.

# La liste est triée en ordre croissant
ma_liste.sort()
print(ma_liste)

La fonction sorted() retourne une liste triée qui devra être stockée dans une variable. (utile lorsque nous voulons garder notre liste initiale.)

# La liste est triée en ordre croissant
liste_triee = sorted(liste)  # Renvoie une nouvelle liste triée
print(liste_triee)  # Affiche la nouvelle liste triée

# La liste est triée en ordre décroissant
ma_liste.sort(reverse=True)

Fonctions et méthodes

Parcourir les éléments d’une liste (à l’aide d’une boucle)

Un premier exemple serait de parcourir chacun des éléments de la liste avec une boucle for:

ma_liste = [1, 2, 3, 4, 5]

# Affichage de chacun des éléments de la liste
for element in ma_liste:
    print(element)

1
2
3
4
5

Il est aussi possible d’utiliser la fonction range() afin de parcourir la liste à l’aide des indices:

# On additionne 1 à chaque élément de la liste
for i in range(len(ma_liste)):
    ma_liste[i] = ma_liste[i] + 1

print(ma_liste)

2
3
4
5
6

Les listes dans les listes

Une liste peut comporter tout type d’élément.
Nous pouvons donc mettre des listes dans des listes. Nous parlons alors de listes (ou tableaux) à 2 dimensions.

# Liste contenant 3 éléments
# Chaque élément est une liste contenant 2 nombres
matrice = [[1, 2], [3, 4], [5, 6]]

Pour parcourir toutes les listes, il suffit de mettre une boucle dans une boucle :

# On parcourt chaque éléments de la liste principale
for sous_liste in matrice:
    # et ensuite chaque élément de la "sous-liste"
    for element in sous_liste:
        print(element)

1
2
3
4
5
6

Les opérations vues sur les listes en 1 dimension fonctionnent aussi pour les listes en 2D:

print(matrice[0]) # affiche la première liste de la matrice
print(matrice[0][1]) # affiche le 2e élément de la première liste de la matrice

matrice.append([7, 8]) # ajoute une nouvelle liste à la matrice

[1, 2]
2

Comme nous l’avons vu plus haut, la fonction range() peut aussi être utilisé pour parcourir les listes à 2 dimensions :

# On ajoute 1 à chaque élément de la matrice
for i in range(len(matrice)):
    for j in range(len(matrice[i])):
        matrice[i][j] = matrice[i][j] + 1

Ateliers

Atelier 1

Prise en main des listes

Atelier 2

Atelier sur la régression linéaire

Atelier 3

Atelier sur les listes