La liste (list)¶
Une liste (souvent appelée tableau dans d’autres langages de programmation) est une séquence modifiable de données ordonnées. Cela signifie que chaque élément de la liste est associé à une position (un index). Le premier élément d’une liste possède l’index 0 et le dernier élément possède l’index n - 1 pour une liste contenant n éléments.
Créer une liste¶
Pour créer une liste, on écrit la liste des éléments entre crochets []
et
séparés par des virgules :
liste_vide = []
ma_liste = [10, 20, 30, 40]
liste_depareillee = [None, 1, "shrubbery", True]
Comme le montre la liste_depareillee
ci-dessus, une liste peut contenir
des éléments de types différents. Elle peut même contenir un élément ou des
éléments None
ce qui signifie qu’elle contient un élément qui n’est rien.
Accéder aux éléments¶
Pour accéder à un élément d’une liste, il faut utiliser les crochets et préciser l’index de l’élément.
ma_liste = [10, 20, 30, 40]
premier_element = ma_liste[0]
second_element = ma_liste[1]
On peut utiliser un index négatif. Cela signifie que l’on souhaite partir de la fin de la liste. Ainsi le dernier élément d’une liste est aussi accessible avec l’index -1.
ma_liste = [10, 20, 30, 40]
dernier_element = ma_liste[-1]
Attention, si un programme veut accéder à un indice qui n’existe pas, cela
produit une erreur de type IndexError
.
>>> ma_liste = [10, 20, 30, 40]
>>> ma_liste[10000]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
L’accès à un élément permet également de modifier la valeur d’un élément de la liste s’il est placé à gauche de l’opérateur d’affectation :
ma_liste = [10, 20, 30, 40]
ma_liste[0] = 0
print(ma_liste)
# affiche [0, 20, 30, 40]
Les opérations sur les listes¶
Connaître la taille d’une liste¶
Pour connaître le nombre d’éléments d’une liste, il faut utiliser la fonction
len()
(qui est la contraction de length) :
ma_liste = [10, 20, 30, 40]
taille_liste = len(ma_liste)
print(taille_liste)
# affiche 4
Supprimer un élément d’une liste¶
Pour supprimer un élément d’une liste, on utilise le mot-clé del
:
ma_liste = [10, 20, 30, 40]
del ma_liste[1]
print(ma_liste)
# affiche [10, 30, 40]
Ajouter deux listes ensemble¶
L’opérateur +
permet d’ajouter deux listes ensemble pour former une troisième
liste :
ma_liste = [0, 1, 2] + [10, 20, 30]
print(ma_liste)
# affiche [0, 1, 2, 10, 20, 30]
Astuce
Pour augmenter la taille d’une liste, vous pouvez utiliser l’opérateur +=
.
Cet opérateur ne crée pas de nouvelle liste, la liste existante est
simplement étendue avec les nouveaux éléments.
ma_liste = [0, 1, 2]
ma_liste += [10, 20, 30]
print(ma_liste)
# affiche [0, 1, 2, 10, 20, 30]
Créer une liste étendue¶
L’opérateur *
permet de créer une liste en répétant le contenu d’une liste
autant de fois que spécifié :
ma_liste = ['ni'] * 5
print(ma_liste)
# affiche ['ni', 'ni', 'ni', 'ni', 'ni']
Savoir si un élément est présent dans une liste¶
Pour savoir si un élément est présent dans une liste, on peut utiliser le mot-clé
in
:
>>> ma_liste = [1, 2, 3]
>>> 2 in ma_liste
True
>>> 12 in ma_liste
False
>>> 12 not in ma_liste
True
Comparer deux listes¶
On peut utiliser tous les opérateurs de comparaison entre deux listes.
>>> ma_liste = [1, 2, 3]
>>> ma_liste == [1, 2, 3]
True
>>> ma_liste != []
True
>>> ma_liste < [1, 2, 3, 4]
True
>>> ma_liste > [1, 2]
True
Pour que deux listes soient égales, elles doivent avoir la même taille et contenir des éléments deux à deux identiques.
Connaître le plus grand élément d’une liste¶
Pour connaître le plus grand élément d’une liste, il faut utiliser la fonction
max()
:
ma_liste = [10, 20, 30, 40]
element = max(ma_liste)
print(element)
# affiche 40
Cela suppose néanmoins que tous les éléments d’une liste sont comparables et
donc de type similaire sinon on obtient une erreur de type TypeError
.
>>> ma_liste = [10, "coconut"]
>>> element = max(ma_liste)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'
Connaître le plus petit élément d’une liste¶
Pour connaître le plus petit élément d’une liste, il faut utiliser la fonction
min()
:
ma_liste = ["a", "b", "c"]
element = min(ma_liste)
print(element)
# affiche a
Comme pour la méthode max()
, cela suppose que tous les éléments d’une
liste sont comparables et donc de type similaire.
Découper une liste¶
Il est possible de découper (slice) une liste. Attention, cette opération
crée une nouvelle liste et copie les éléments de la liste originelle vers la
nouvelle liste. Pour découper, on utilise les crochets []
avec l’une
des notations suivantes :
[index départ : indice supérieur]
[index départ : indice supérieur : pas d’incrément]
ma_liste = [10, 20, 30, 40]
autre_liste = ma_liste[1:3]
print(autre_liste)
# affiche [20, 30]
ma_liste = [10, 20, 30, 40]
derniers_elements = ma_liste[-2:4]
print(derniers_elements)
# affiche [30, 40]
ma_liste = [1, 2, 3, 4, 5, 6, 7, 8, 9]
nombres_pairs = ma_liste[1:9:2]
print(nombres_pairs)
# affiche [2, 4, 6, 8]
Par défaut, l’indice de départ est 0, l’indice de fin est le nombre d’éléments + 1 et le pas est 1. Il est donc possible d’omettre une ou plusieurs de ces valeurs.
ma_liste = [10, 20, 30, 40]
liste_sauf_dernier_element = ma_liste[:-1]
print(liste_sauf_dernier_element)
# affiche [10, 20, 30]
liste_sauf_premier_element = ma_liste[1:]
print(liste_sauf_premier_element)
# affiche [20, 30, 40]
un_sur_deux = ma_liste[::2]
print(un_sur_deux)
# affiche [10, 30]
Astuce
Pour le slicing de liste, vous pouvez indiquer comme indice de départ ou comme indice supérieur un indice en dehors de la liste. Cela ne génère pas d’erreur. Python s’arrêtera au dernier élément de la liste :
ma_liste = [10, 20, 30, 40]
nouvelle_liste = ma_liste[2:1000]
print(nouvelle_liste)
# affiche [30, 40]
nouvelle_liste = ma_liste[1000:]
print(nouvelle_liste)
# affiche []
Le slicing peut être également utilisé pour modifier une liste. Par exemple pour supprimer des éléments à la fin ou au début d’une liste :
ma_liste = ['a', 'b', 'c', 'd']
del ma_liste[-2:]
print(ma_liste)
# affiche ['a', 'b']
Copier une liste¶
Prenons l’exemple suivant :
ma_liste = [10, 20, 30, 40]
une_autre_liste = ma_liste
On pourrait croire que le code ci-dessus copie la liste contenue depuis la variable
ma_liste
dans la variable une_autre_liste
. Il n’en est rien ! Avec ce code,
les deux variables référencent simplement la même liste.
Pour s’en convaincre, il suffit de modifier la liste à travers une variable et constater que les modifications sont visibles à partir de l’autre variable :
ma_liste = [10, 20, 30, 40]
une_autre_liste = ma_liste
ma_liste[0] = 0
print(une_autre_liste[0])
# affiche 0
Donc les variables sont comme des poignées qui permettent d’accéder à des données et plusieurs poignées peuvent accéder aux mêmes données. Les listes en Python sont des séquences mutables (mutable sequences), cela signifie que l’on peut modifier leur contenu. Ainsi toutes les variables qui référencent la même liste partagent les modifications effectuées sur cette liste.
Pour copier une liste, on peut utiliser la fonction list
:
ma_liste = [10, 20, 30, 40]
une_autre_liste = list(ma_liste)
ma_liste[0] = 0
print(une_autre_liste[0])
# affiche 10
Astuce
Pour copier une liste, on peut aussi utiliser le slicing :
ma_liste = [10, 20, 30, 40]
nouvelle_liste = ma_liste[:]
ma_liste[:]
crée une copie de la liste à partir de l’indice 0 et jusqu’à
l’indice correspondant au nombre d’éléments plus 1 (non inclus). Donc, il
s’agit d’un copie intégrale de la liste.
Quelques méthodes pour les listes¶
Les listes possèdent beaucoup de méthodes.
append(e)
Pour ajouter un élément à la liste.
ma_liste = [1] ma_liste.append(2) ma_liste.append(3) print(ma_liste) # affiche [1, 2, 3]
extend(l)
Pour ajouter une séquence à une liste.
ma_liste = [1] ma_liste.extend([2, 3, 4]) print(ma_liste) # affiche [1, 2, 3, 4]
insert(i, e)
Pour insérer un nouvel élément à un index.
ma_liste = ['a', 'c', 'd'] ma_liste.insert(1, 'b') print(ma_liste) # affiche ['a', 'b', 'c', 'd']
remove(e)
Pour supprimer un élément de la liste.
ma_liste = ['a', 'b', 'c', 'd'] ma_liste.remove('b') print(ma_liste) # affiche ['a', 'c', 'd']
clear()
Pour supprimer tous les éléments d’une liste.
ma_liste = [10, 20, 30] ma_liste.clear() print(ma_liste) # affiche []
count(e)
Pour compter le nombre d’occurrences d’un élément.
ma_liste = ["John", "Eric", "Michael", "John", "Eric", "John"] occurrence = ma_liste.count("John") print(occurrence) # affiche 3
sort()
Pour trier une liste par ordre croissant.
ma_liste = [3, 2, 6, 4] ma_liste.sort() print(ma_liste) # affiche [2, 3, 4, 6]
Pour trier par ordre décroissant, on utilise le paramètre nommé
reverse
:ma_liste = [3, 2, 6, 4] ma_liste.sort(reverse=True) print(ma_liste) # affiche [6, 4, 3, 2]
reverse()
Pour inverser l’ordre des éléments dans la liste.
ma_liste = [4, 2, 3] ma_liste.reverse() print(ma_liste) # affiche [3, 2, 4]
Exercices¶
Exercice : manipuler une phrase
Demandez à l’utilisateur de saisir une phrase sans ponctuation. Découper la phrase afin d’obtenir la liste des mots.
Astuce
Pour découper la phrase, utilisez la méthode split()
d’une
chaîne de caractères qui attend en paramètre le séparateur et qui retourne
la liste des mots :
>>> "Longtemps je me suis couché de bonne heure".split(" ")
['Longtemps', 'je', 'me', 'suis', 'couché', 'de', 'bonne', 'heure']
Affichez le nombre de mots.
Affichez le nombre d’occurrences du mot « python ».
Supprimez le dernier mot de la liste.
Ajoutez à la fin de la liste
["n'est-ce", "pas"]
Insérez
"euh"
en deuxième position de la liste
Puis, recréez une phrase à partir de ces mots et affichez là.
Astuce
On peut créer une chaîne de caractères à partir d’une liste de chaînes de
caractères grâce à la méthode join()
d’une chaîne de caractères.
Cette méthode utilise la chaîne comme séparateur pour concaténer la liste
passée en paramètre.
>>> l = ['Longtemps', 'je', 'me', 'suis', 'couché', 'de', 'bonne', 'heure']
>>> " voyez-vous ".join(l)
'Longtemps voyez-vous je voyez-vous me voyez-vous suis voyez-vous couché voyez-vous de voyez-vous bonne voyez-vous heure'
Exercice : slicing
Réalisez les opérations demandées en utilisant le slicing (découpage de liste).
Soit la liste :
jours = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']
Créez une nouvelle liste que ne contient pas les jours du week-end.
Créez une nouvelle liste que ne contient que les jours du week-end.
Créez une nouvelle liste qui commence par les jours du week-end.
Créez une nouvelle liste qui commence par dimanche.
Exercice : slicing (suite)
Réalisez les opérations demandées en utilisant le slicing (découpage de liste).
Soit la liste :
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Créez une nouvelle liste qui ne contient que les nombres impairs.
Créez une nouvelle liste qui ne contient que les nombres pairs.
Créez une nouvelle liste qui contient d’abord les nombres pairs puis les nombres impairs.