Les listes

Une liste est une structure de données qui contient une série de valeurs.

Source : https://moncoachdata.com/blog/devenir-python-ninja-structures-de-donnees/

Une liste est une valeur qui rassemble dans une seule structure plusieurs valeurs plus simples : on appelle cela une valeur composite.

Python autorise la construction de listes contenant des valeurs de types différents (par exemple entier et chaîne de caractères). Exécutez les cellules suivantes qui contiennent des exemples de listes :

animaux = ["girafe", "tigre", "singe", "souris"]
tailles = [5, 2.5, 1.75, 0.15]
mixte = ["girafe", 5, "souris", 0.15]

animaux

tailles

mixte

Manipuler les éléments d’une liste¶

Indices¶

L’ordre des éléments dans une liste étant fixé, on peut accéder à un élément donné à partir de son indice, c’est-à-dire sa position dans la liste. L’exemple suivant décrit les indices des quatre éléments de notre liste `d’animaux :

liste  : ["girafe", "tigre", "singe", "souris"]
indice :     0         1        2        3

On peut alors accéder à l’élément d’indice i d’une liste l avec la notation l[i]. Voici par exemple le premier et le troisième élément de notre liste d’animaux :

animaux[0]

animaux[2]

Les éléments d’une listes sont également indexés par des nombres négatifs selon le modèle suivant :

liste          : ["A", "B", "C", "D", "E", "F"]
indice positif :   0    1    2    3    4    5
indice négatif :  -6   -5   -4   -3   -2   -1

Les indices négatifs reviennent à compter à partir de la fin. Ils permettent ainsi d’accéder au dernier élément d’une liste à l’aide de l’indice -1 sans pour autant connaître la longueur de cette liste.

Il est également possible d’affecter une valeur à l[i]; cela aura pour effet de changer la valeur de l à l’indice i :

tailles = [5, 2.5, 1.75, 0.15]
tailles

tailles[2] = 1.5
tailles

from jupylates import Exercise

Exercise("listes/couleurs1.md", dir="../exercices")

Exercise("listes/couleurs2.md", dir="../exercices")

Tranches¶

Il est possible d’extraire des éléments consécutifs d’une liste en utilisant un indice de la forme m:n+1 pour récupérer tous les éléments du m-ième inclus au n-ième exclu. On dit alors que l’on extrait une tranche de la liste. Voici quelques exemples :

animaux = ["girafe", "tigre", "singe", "souris"]

animaux[0:2]

animaux[0:3]

animaux[0:]

animaux[:]

animaux[1:]

animaux[1:-1]

Lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole :, Python extrait par défaut tous les éléments depuis le début, ou tous les éléments jusqu’à la fin respectivement.

On peut aussi préciser le pas en ajoutant un symbole : supplémentaire et en spécifiant ce pas par un entier :

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

x[::1]

x[::2]

x[::3]

x[1:10:3]

Source : https://docs.python.org/fr/3/glossary.html

from jupylates import Exercise

Exercise("listes/tranches1.md", dir="../exercices")

Exercise("listes/tranches2.md", dir="../exercices")

Construction de listes avec range et list¶

Nous avons vu la fonction range() dans la feuille sur les boucles.

Lorsqu’elle est utilisée en combinaison avec la fonction list(), on obtient une liste d’entiers :

list(range(10))

from jupylates import Exercise

Exercise("listes/range1.md", dir="../exercices")

Exercise("listes/range2.md", dir="../exercices")

Opérations sur plusieurs listes¶

Listes de listes¶

Les listes sont des objets comme des autres donc j’ai le droit de les manipuler, je peux faire une liste de ce que je veux donc je peux faire une liste de listes. Il est possible de construire des listes de listes. Par exemple :

enclos1 = ["girafe", 4]
enclos2 = ["tigre", 2]
enclos3 = ["singe", 5]
zoo = [enclos1, enclos2, enclos3]
zoo

Dans cet exemple, chaque sous-liste contient une catégorie d’animal et le nombre d’animaux pour chaque catégorie.

Pour accéder à un élément de la liste, on utilise l’indiçage habituel :

zoo[1]

Pour accéder à un élément de la sous-liste, on utilise un double indiçage :

zoo[1][0]

zoo[1][1]

Concaténation et multiplication¶

Les listes supportent l’opérateur + de concaténation, ainsi que l’opérateur * pour la duplication. Il existe la fonction liste1.extend(liste2) qui permet de faire la même opération de concaténation que + (liste2 est concaténée à liste1). Remarque : l’opération liste1 + liste2 renvoie la concaténation des deux listes, alors que liste1.extend(liste2) met la concatélation des deux listes dans liste1.

Exécutez les cellules suivantes :

ani1 = ["girafe", "tigre"]
ani2 = ["singe", "souris"]
ani = ani1 + ani2
ani

ani1.extend(ani2)
ani1

ani1 * 3

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

a = a + [15]  # Ajout de l'élément 15
a

a = a + [-5]  # Ajout de l'élément -5
a

Opérations sur une seule liste¶

Fonctions sur les éléments d’une liste¶

Voici quelques autres fonctions sur les listes qu’il est nécessaire de connaître :

• liste.append(a) : ajouter un seul élément a à la fin d’une liste. Rappel : liste1.extend(liste2) permet d’ajouter une liste entière liste2 après liste1.

• liste.remove(a) : cherche l’élément a dans la liste et supprime la première occurrence rencontrée.

• liste.insert(i, a) : pour insérer un nouvel élément a à une position spécifique i. Par exemple, liste.insert(1, 12) insérera l’entier 12 à l’indice 1, déplaçant l’ancien élément 1 à l’indice 2 et ainsi de suite ;

• liste.index(a) : permet de trouver l’indice de la première occurrence de l’élément a à chercher dans notre liste.

• del liste[i] : permet de supprimer l’élément à l’indice i.

Voici quelques exemples :

liste = []  # Déclaration d'une liste vide
liste.append(7)  # -> [7]
liste.append(5)  # -> [7, 5]
liste.insert(1, 12)  # [7, 12, 5]
liste[0] = 4  # -> [4, 12, 5]
liste.remove(12)  # [4, 5]
liste.index(5)  # affiche 1
liste.extend([1, 2, 3])  # [4, 5, 1, 2, 3]
del liste[3]  # [4, 5, 1, 3]

La taille d’une liste¶

La fonction len() permet de connaître la longueur d’une liste, c’est-à-dire le nombre d’éléments que contient la liste.

animaux = ["girafe", "tigre", "singe", "souris"]
len(animaux)

len([1, 2, 3, 4, 5, 6, 7, 8])

Minimum, maximum et somme d’une liste¶

Les fonctions min(), max() et sum() renvoient respectivement le minimum, le maximum et la somme d’une liste passée en argument.

liste = list(range(10))
liste

sum(liste)

min(liste)

max(liste)

Bilan¶

Avant de passer à la suite, nous vous proposons quelques exercices d’entraînement et de révisions autocorrigés.

Vous pouvez ignorer les exercices listes_comprehension et operations_plusieurs_listes pour le moment.

import glob, os
from jupylates import Exerciser

os.chdir("../exercices")
exercises = glob.glob("listes/*.md")
Exerciser(exercises)