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.