Les listes

À faire

• Introduire la notion de valeur composite

• Expliciter que l’ordre et les répétitions sont importantes

• Améliorer la définition de structure de données

• Remplacer chaque exercice d’application immédiate par un exercice Jupylates randomisé

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

Definition 1 (Définition : Structure de données)

Les structures de données sont des moyens spécifiques d’organiser et de stocker des données afin qu’elles puissent être consultées et travaillées de manière efficace. Les structures de données définissent la relation entre les données et les opérations pouvant être effectuées dessus.

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 apppelle 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

['girafe', 'tigre', 'singe', 'souris']

tailles

[5, 2.5, 1.75, 0.15]

mixte

['girafe', 5, 'souris', 0.15]

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 (array index), 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

Attention

Les indices d’une liste de \(n\) éléments commencent à \(0\) et se terminent donc à \(n-1\).

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]

'girafe'

animaux[2]

'singe'

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

[5, 2.5, 1.75, 0.15]

tailles[2] = 1.5
tailles

[5, 2.5, 1.5, 0.15]

Exercices

Indication : exécutez le code suivant pour faire apparaître les exercices.

import os
os.chdir("../Exercices")
from entraîneur import Exercise
display(Exercise("listes/couleurs1.md"))
display(Exercise("listes/couleurs2.md"))

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

À faire

Un poil redondant avec ci-dessus

Definition 2 (Définition : Les tranches)

Une tranche en Python est un objet contenant une portion de séquence. Une tranche est créée en utilisant la notation [] avec des : entre les nombres lorsque plusieurs sont fournis; cela fonctionne sur le modèle liste[début:fin:pas]. On retrouve le même principe que pour la fonction range qui pouvait prendre jusqu’à trois paramètres: range(début, fin, pas).

Remarque

Tout ce qu’on a vu sur les listes se généralise aux chaînes de caractères.

À faire

Donner un exemple.

Exercices

import os
os.chdir("../Exercices")
from entraîneur import Exercise
display(Exercise("listes/tranches1.md"))
display(Exercise("listes/tranches2.md"))

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))

Exercices

import os
os.chdir("../Exercices")
from entraîneur import Exercise
display(Exercise("listes/range1.md"))
display(Exercise("listes/range2.md"))

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

Opération	Définition
Opération sur une seule liste
liste.append(a)	Ajoute l’élément a à la fin de liste
liste.remove(a)	Supprime la première occurrence de a dans liste.
liste.insert(i, a)	Insère un nouvel élément a à la position i.
liste.index(a)	Renvoie l’indice de la première occurrence de a dans liste.
del liste[i]	Supprime l’élément à l’indice i.
len(liste)	Renvoie la longueur de liste.
min(liste)	Renvoie le plus petit élément de liste.
max(liste)	Renvoie le plus grand élément de liste.
Opération sur plusieurs listes
liste1 + liste2	Renvoie la concaténation de liste1 et liste2.
liste * n	Renvoie la concaténation de n copies de liste.
liste1.extend(liste2)	Ajoute les éléments de liste2 à la fin de liste1.

À faire

• Filtrer les exercices faisables à ce stade: compréhension; 2D?

• Exo operations_plsrs_listes.md: affichage incorrect du code

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)