Les listes

Contenu

Les listes#

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

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/

Python autorise la construction de liste 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#

Les éléments d’une liste peuvent être appelés par leur position. Ce numéro est appelé indice (ou index) de la liste :

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

⚠️ les indices d’une liste de n éléments commencent à 0 et se terminent à n-1. ⚠️

La liste peut également être indexée avec 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 de changer la valeur à un indice donné :

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]

Exercice

Déclarez une liste couleurs contenant cinq éléments : rouge, jaune, orange, vert et bleu. Dans la cellule suivante, Remplacez la couleur vert par émeraude.

### BEGIN SOLUTION
couleurs = ['rouge', 'jaune', 'orange', 'vert', 'bleu']
### END SOLUTION

### BEGIN SOLUTION
couleurs[3] = 'émeraude'
### END SOLUTION

Exercice

Créez une liste semaine contenant les sept jours de la semaine. À partir de cette liste, utilisez l’indiçage pour récupérer comment récupérez-vous seulement les cinq premiers jours de la semaine d’une part, et ceux du week-end d’autre part, de deux manières (avec deux indiçages différents).

### BEGIN SOLUTION
semaine = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
premiers_jours = semaine[:5]
weekend = semaine[5:]
premiers_jours2 = semaine[:-2]
weekend2 = semaine[-2:]
### END SOLUTION

Tranches#

Il est possible de sélectionner une partie d’une liste en utilisant un indiçage construit sur le modèle [m:n+1] pour récupérer tous les éléments, du m-ième au n-ième (de l’élément m inclus à l’élément n+1 exclu). On dit alors qu’on récupère une tranche de la liste, par exemple :

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

animaux[0:2]

['girafe', 'tigre']

animaux[0:3]

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

animaux[0:]

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

animaux[:]

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

animaux[1:]

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

animaux[1:-1]

['tigre', 'singe']

Lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole deux-points, Python prend 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 deux points supplémentaire et en indiquant le pas par un entier :

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x[::1]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x[::2]

[0, 2, 4, 6, 8]

x[::3]

[0, 3, 6, 9]

x[1:6:3]

[1, 4]

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

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].

Remarque

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

Création d’une liste : fonctions 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))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Exercice

Créez une liste contenant les entiers de 0 à 10.

### BEGIN SOLUTION
list(range(11))
### END SOLUTION

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Exercice

Créez une liste contenant les entiers pairs de 20 à 0.

### BEGIN SOLUTION
list(range(20, -1, -2))
### END SOLUTION

[20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0]

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

[['girafe', 4], ['tigre', 2], ['singe', 5]]

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]

['tigre', 2]

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

zoo[1][0]

'tigre'

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

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

ani1.extend(ani2)
ani1

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

ani1 * 3

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

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

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

[15]

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

[15, -5]

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

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

sum(liste)

min(liste)

max(liste)

Bilan#

Opération	Définition
Opération sur plusieurs listes
`liste1 + liste2`	Renvoie la concaténation de `liste1` et `liste2`.
`liste * n`	Renvoie la liste `liste` répétée `n` fois.
`liste1.extend(liste2)`	`liste2` est concaténée à `liste1`.
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`.

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

import glob
from jupylates import Exerciser
exercises = glob.glob('../Exercices/listes/*.md')
Exerciser(exercises, lrs_url="../.lrs.json", mode="train")

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[42], line 2
      1 import glob
----> 2 from jupylates import Exerciser
      3 exercises = glob.glob('../Exercices/listes/*.md')
      4 Exerciser(exercises, lrs_url="../.lrs.json", mode="train")

ModuleNotFoundError: No module named 'jupylates'