Les listes Python

Les listes Python#

Vidéo: Éléments de base#

Créer une liste#

Une liste est une séquence de valeurs, comme une chaîne. Dans une chaîne, ces valeurs sont des caractères. Dans une liste, les valeurs peuvent être de n’importe quel type.

Les valeurs dans une liste sont appelées éléments.

Le plus simple pour créer une liste est d’entourer les éléments par des crochets [ et ]. Voici une liste, nommée ma_liste, qui contient des valeurs des trois types que l’on a introduits dans l’activité “Première prise en main de Python”. Saurez-vous les reconnaître ?

# Création de la liste
ma_liste = [1, 2, 3.0, "a"]

# Affichage de la liste
print(ma_liste)

[1, 2, 3.0, 'a']

Exercice#

Créer trois variables nommées plante1, plante2 et plante3, contenant respectivement les valeurs "gentiane", "campanule" et "pensée".
Créer une liste nommée plantes, à partir des noms des 3 variables créées en 1, qui contient les noms des trois plantes.
Vous possédez ces trois plantes chez vous, et vous voulez suivre leur croissance. Créez une nouvelle liste nommée taille_plantes qui contient le nom des trois plantes, et juste après le nom de chaque plante, sa taille (valeur de type float). La gentiane fait 7.5 cm, la campanule 5.8 cm et la pensée 11.4 cm.
Afficher le contenu des 2 listes à l’écran avec la fonction print()

['gentiane', 'campanule', 'pensée']
['gentiane', 7.5, 'campanule', 5.8, 'pensée', 11.4]

Liste de listes#

Une liste peut contenir une autre liste. On dit alors que la liste est imbriquée. Dans l’exemple suivant, on crée une liste de trois listes imbriquées :

taille_plantes = [[plante1, 7.5], 
                  [plante2, 5.8],
                  [plante3, 11.4]]

Exercice#

Afficher le contenu de la liste taille_plantes à l’écran.
Afficher le type de la liste avec la fonction type().

[['gentiane', 7.5], ['campanule', 5.8], ['pensée', 11.4]]
<class 'list'>

Classe et type

On retrouve ici le mot class, que l’on peut traduire par classe. Dans Python 3 les concepts de classe et de type sont équivalents.

Modifier une liste#

On peut accéder à un élément de la liste en utilisant l’opérateur [] d’indexation :

# Accès à un élément de la liste
plante_choisie = plantes[0]

# Affichage de la plante choisie
print(plante_choisie)

gentiane

La première instruction sélectionne l’élément numéroté par 0 de la liste plantes et l’affecte à la variable plante_choisie. L’expression entre crochets s’appelle un indice.

Attention

Le premier élément de la liste est numéroté avec l’entier 0, le deuxième élement avec l’entier 1, et ainsi de suite.

Les listes sont modifiables. Lorsque l’opérateur d’indexation apparaît du côté gauche de l’affectation, il indique l’élément de la liste auquel la valeur sera affectée :

# Création de la liste
plantes = ["gentiane", "campanule", "pensée"]

# Modification d'un élément de la liste
plantes[1] = "digitale"

# Affichage de la liste
print(plantes)

['gentiane', 'digitale', 'pensée']

Le deuxième élément de la liste (indice 1), qui avait la valeur "campanule", a maintenant la valeur "digitale".

Voici quelques règles d’indexation :

toute expression entière peut être utilisée comme indice
si un indice a une valeur négative, il compte en sens inverse, à partir de la fin de la liste
si vous essayez de lire ou d’écrire un élément qui n’existe pas, vous obtenez une erreur

Voici une illustration de ces trois règles :

# Accès à un élement de liste avec une expression
i = 1
print(plantes[i + 1])

pensée

# Accès à un élément de liste depuis la fin
print(plantes[-2])

digitale

# Accès à un élément de liste qui n'existe pas : message d'erreur
print(plantes[3])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[10], line 2
      1 # Accès à un élément de liste qui n'existe pas : message d'erreur
----> 2 print(plantes[3])

IndexError: list index out of range

Opérations sur listes#

L’opérateur + concatène 2 listes, alors que l’opérateur * répète une liste un certain nombre de fois :

# Création de la liste
plantes = ["gentiane", "campanule", "pensée"]

# Concaténation
plantes2 = plantes + ["marguerite", "oseille"]

# Affichage de la liste
print(plantes2)

['gentiane', 'campanule', 'pensée', 'marguerite', 'oseille']

# Répétition de la liste
print(plantes * 2)

['gentiane', 'campanule', 'pensée', 'gentiane', 'campanule', 'pensée']

On peut aussi effectuer des calculs en utilisant directement des éléments de la liste. Par exemple :

# Création de la liste
taille_plantes = ["gentiane", 7.5, "campanule", 5.8, "pensée", 11.4]

# Calcul de la taille totale
taille_totale = taille_plantes[1] + taille_plantes[3] + taille_plantes[5]

# Affichage du résultat
print(taille_totale)

24.700000000000003

Exercice#

Après une semaine, vos plantes ont poussé. Modifier la liste taille_plantes avec les tailles 8.3 cm, 6.4 cm et 13.2 cm pour respectivement les plantes gentiane, campanule et pensée.
Afficher la liste avec print()

['gentiane', 8.3, 'campanule', 6.4, 'pensée', 13.2]

Vidéo: Sous-listes et tranches#

Tranches de liste#

Il est possible de sélectionner plusieurs éléments d’une liste en utilisant l’opérateur tranche [m:n], où m et n sont des expression entières. L’opérateur de tranche inclut l’élément de départ, mais exclut l’élément de fin de la tranche. Ainsi, l’opérateur [0:2] revient à sélectionner les élements d’indice 0 et 1. Par exemple :

# Création de la liste
plantes = ["gentiane", "campanule", "pensée"]

# Affichage d'une tranche de liste : l'élément de fin de tranche EST EXCLUT
print(plantes[0:2])

['gentiane', 'campanule']

Si vous omettez le premier indice, la tranche commence au début de la liste. Si vous omettez le second indice, la tranche s’étend jusqu’à la fin de la liste. Si vous omettez les deux indices, la liste entière est sélectionnée :

# Omission du 1er indice : commence à l'élément 0
print(plantes[:2])

['gentiane', 'campanule']

# Omission du dernier indice : va jusqu'à la fin de la liste
print(plantes[1:])

['campanule', 'pensée']

# Omission de 2 indices : tous les éléments de la liste
print(plantes[:])

['gentiane', 'campanule', 'pensée']

Il est possible de modifier plusieurs éléments en même temps en utilisant l’opérateur tranche à gauche de l’opérateur affection. Il faut alors mettre à droite de l’opérateur affectation une liste de longueur quelconque qui va remplacer la tranche sélectionnée. Par exemple :

# Création de la liste
plantes = ["gentiane", "campanule", "pensée"]

# Modification d'une tranche
plantes[0:2] = ["marguerite", "oseille", "saxifrage"]

# Affichage de la liste
print(plantes)

['marguerite', 'oseille', 'saxifrage', 'pensée']

On a remplacé les deux premiers éléments de la liste par une liste de trois éléments. La taille de la liste a donc changé.

Exercice#

# Création de la liste
plantes = ["gentiane", "campanule", "pensée", "marguerite", "oseille"]

Dans la liste plantes créée ci-dessus, remplacer les chaînes "campanule" et "pensée" par les chaînes "saxifrage", "primevère" et "orchis" à l’aide de l’opérateur tranche.
Afficher la liste avec print() pour vérifier le résultat.

['gentiane', 'saxifrage', 'primevère', 'orchis', 'marguerite', 'oseille']

Indexation et tranche de liste de listes#

On a vu qu’une liste peut contenir d’autres listes (listes imbriquées). Il est possible d’utiliser l’opérateur d’indexation sur les listes de listes. Par exemple :

# Création de la liste
taille_plantes = [["gentiane",   7.5], 
                  ["campanule",  5.8],
                  ["pensée",     11.4]]

# Sélection d'une liste imbriquée
print(taille_plantes[1])

['campanule', 5.8]

# Sélection d'un élement dans la liste imbriquée
print(taille_plantes[1][0])

campanule

Le premier opérateur sélectionne la liste (dans l’exemple la liste d’indice 1), et le deuxième opérateur sélectionne l’élément dans la liste sélectionnée (dans l’exemple celui d’indice 0).

On peut aussi utiliser l’opérateur tranche :

# Sélection d'une tranche de listes imbriquées
print(taille_plantes[1:3])

[['campanule', 5.8], ['pensée', 11.4]]

# Sélection d'une tranche de la liste imbriquée
print(taille_plantes[1][0:1])

['campanule']

La première instruction sélectionne les listes d’indices 1 et 2 et retourne une liste de listes. La deuxième instruction sélectionne l’élément d’indice 0 dans la liste d’indice 1.

Exercice#

Quelle est la difference entre les instructions taille_plantes[1][0] et taille_plantes[1][0:1] ? Vous pouvez utiliser l’opérateur type() pour vérifier cette différence.

<class 'str'>

<class 'list'>

Vidéo: Manipuler les listes#

Supprimer un élément#

Il existe deux possibilités pour supprimer un élément d’une liste : en utilisant l’instruction del() ou bien en insérant une liste vide []. Par exemple :

plantes = ["gentiane", "campanule", "pensée", "marguerite", "oseille"]

del(plantes[2]); print(plantes)

['gentiane', 'campanule', 'marguerite', 'oseille']

plantes[1:3] = []; print(plantes)

['gentiane', 'oseille']

Dans la deuxième ligne, on a supprimé l’élément d’indice 2. On remarque alors que les indices des élements de la liste changent. Dans la troisième ligne, on a supprimé grâce à l’opérateur tranche les élements 1 et 2, en introduisant à la place une liste vide.

Le point-virgule

Ici nous avons utilisé un point-virgule à la fin d’une instruction pour pouvoir écrire deux instructions sur la même ligne.

Il est tout de même conseillé de ne pas le faire, pour que le code soit plus lisible, mais sachez que c’est possible.

Les chaînes#

On a vu que les chaînes sont constituées d’une séquence de caractères. Comme pour les listes, on peut utiliser les opérateurs indexation et tranche pour accéder à certains caractères de la chaîne. Par exemple :

# Création de la chaîne
plante1 = "gentiane"

# Sélection d'un caractère
print(plante1[3])

# Sélection d'une tranche
print(plante1[3:6])

tia

Par contre, contrairement aux listes, les chaînes sont immuables, ce qui signifie que l’on ne peut pas modifier une chaîne existante. Si on essaye, on a alors un message d’erreur :

plante1[3] = "b"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[37], line 1
----> 1 plante1[3] = "b"

TypeError: 'str' object does not support item assignment

Objet

La chaîne de caractères "gentiane" est un objet dont les éléments sont les caractères de la chaîne, qui sont aussi des objets. De manière générale, un objet est quelque chose auquel une variable peut se référer. Ici, la variable plante1 se réfère à l’objet "gentiane".

Muable

Un objet muable est un objet qui peut être modifié, comme les listes. À l’inverse, un objet immuable ne peut pas être modifié, comme les chaînes.

Objets et valeurs#

Effectuons les affectations suivantes :

plante1 = "gentiane"
plante2 = "gentiane"

Dans cet exemple on a créé une variable plante1 qui se réfère à un objet “gentiane”, et une variable plante2 qui se réfère à un objet “gentiane”. Python a-t-il créé deux objets “gentiane” ou un seul ? Autrement dit, les variables plante1 et plante2 se réfèrent-elles à deux objets différents ou bien à un seul objet commun ?

Pour vérifier si deux variables font référence au même objet, nous pouvons utiliser l’opérateur is :

plante1 is plante2

True

Cette instruction nous renvoie la valeur True, c’est-à-dire Vrai. Donc les deux variables se réfèrent bien au même objet chaîne.

Cependant, ce n’est pas le cas lorsque l’on crée deux listes:

plantes1 = ["gentiane", "campanule", "pensée"]
plantes2 = ["gentiane", "campanule", "pensée"]

plantes1 is plantes2

False

Dans ce cas, les deux listes sont équivalentes, parce qu’elles ont les mêmes éléments, mais pas identiques, car il ne s’agit pas d’un même objet.

Valeur d’un objet

Une variable se réfère à un objet, qui a une certaine valeur. En évaluant [1, 2, 3], on obtient un objet liste dont la valeur est une séquence d’entiers. Si une autre liste a les mêmes éléments, on dit qu’elle a la même valeur, mais ce n’est pas le même objet.

Aliasing#

Créons une variable plantes1 qui se réfère à un objet et écrivons plantes2 = plantes1. Alors les 2 variable plantes1 et plantes2 se réfèrent au même objet. Pour le vérifier, utilisons l’opérateur is :

plantes1 = ["gentiane", "campanule", "pensée"]
plantes2 = plantes1

# Les deux variables se réfèrent au même objet
plantes2 is plantes1

True

L’association entre une variable et un objet s’appelle une référence. Dans l’exemple il existe deux références vers le même objet ["gentiane", "campanule", "pensée"]. Comme l’objet est une liste, il est muable, c’est-à-dire qu’on peut le modifier. Alors les modifications faites à un alias (une référence) affectent l’autre :

# On modifie l'objet auquel se réfère plante2
plantes2[1] = "primevère"

# L'objet auquel se réfère plantes1 est aussi modifié, car c'est le même objet
print(plantes1)

['gentiane', 'primevère', 'pensée']

Ce comportement, appelé aliasing, peut être source d’erreur. Pour éviter cela, vous pouvez copier de façon superficielle l’objet à l’aide de list() ou de [:].

plantes1 = ["gentiane", "campanule", "pensée"]

# Copie superficielle de la liste : version 1
plantes2 = plantes1[:]

# Copie superficielle de la liste : version 2
plantes3 = list(plantes1)

# Les variables plantes2 et plantes3 ne se réfèrent pas au même objet que la variable plantes1
print(plantes2 is plantes1)
print(plantes3 is plantes1)

False
False

Les listes Python

Contents

Les listes Python#

Vidéo: Éléments de base#

Créer une liste#

Exercice#

Liste de listes#

Exercice#

Modifier une liste#

Opérations sur listes#

Exercice#

Vidéo: Sous-listes et tranches#

Tranches de liste#

Exercice#

Indexation et tranche de liste de listes#

Exercice#

Vidéo: Manipuler les listes#

Supprimer un élément#

Les chaînes#

Objets et valeurs#

Aliasing#