Les listes Python pour plus de flexibilité

Les listes Python sont des séquence qui peuvent être de n’importe quel type. Les valeurs de la liste sont appelées éléments, ils sont placés entre deux crochets []et séparées par des virgules.

En fait, une liste Python est un conteneur mutable. Donc, nous pouvons ajouter, supprimer et modifier des valeurs existantes. De plus, vous pouvez avoir une liste vide, répéter un élément plusieurs fois, et même avoir des données de types différents.

Comment créer une liste Python ?

Il existe plusieurs méthodes pour créer une liste Python. Nous allons créer une liste vide.

>>> ma_liste = []
>>> ma_liste
[]

Pour créer une liste Python, on met les éléments entre crochets et on les sépare par des virgules. Puis on affecte les valeurs entre crochets à une variable.

ma_liste = [2, 3, "voiture", ["a","b"]]

On a créé une liste contenant des entiers, une chaîne de caractère et une autre liste.

>>> type(ma_liste)
<class 'list'>

Utiliser la fonction range().
La fonction intégrée range() génère des nombres entiers entre l’entier de début(inclus) et l’entier d’arrêt(exclu) et renvoie un objet d’intervalle.

>>> range(5)
range(0, 5)
>>> list(range(0, 5))
[0, 1, 2, 3, 4]
>>> nombres = list(range(1,6))
>>> nombres
[1, 2, 3, 4, 5]    # le dernier élément est exclu

list() : une fonction qui renvoie un objet liste à partir de données itérables, comme les chaînes de caractères ainsi que d’autres types de données que nous verrons prochainement.

>>> list('aeiou')
['a', 'e', 'i', 'o', 'u']
>>> nombres = (1,2,3)   # tuple
>>> list(nombres)
[1, 2, 3]
>>> nombres = {1,2,3}    # set
>>> list(nombres)
[1, 2, 3]
>>> nombres = {'a':1, 'b':2,'c':3}        # dictionnaire
>>> list(nombres)
['a', 'b', 'c']

Les listes sont mutables

La syntaxe qui vous permet d’accéder aux éléments d’une liste est la même que celle qu’on a vu dans les chaines de caractères. On utilise le nom de la liste suivi de deux crochets. L’expression se trouvant à l’intérieur des crochets détermine les indices. Le premier index est le zéro, le deuxième index est le un, et ainsi de suite, jusqu’à n-1 pour une liste de n éléments.

>>> fruits = ["pomme", "banane", "fraise"]
>>> fruits[1]
'banane'

En outre, l’indice peut être négatif. Cela signifie que l’interpréteur commence à partir de la droite de la liste. Si vous voulez accéder au dernier élément de la liste :

>>> fruits[-1]
'fraise'

Contrairement aux chaînes de caractères, les listes sont modifiables, ce qui veut dire que les valeurs des indices peuvent être modifiées.

>>> fruits = ["pomme", "banane", "fraise"]
# modifier le deuxième élément, il porte l'index 1
>>> fruits[1] = "abricot"
>>> fruits
['pomme', 'abricot', 'fraise']

On a modifié l’élément qui est associé a l’indice 1.

Pour afficher une partie spécifique de la liste, on précise l’indice du début et l’indice de la fin, séparés par deux points.

>>> fruits[0:2]
['pomme', 'abricot']

De plus, on peut utiliser les indices pour modifier plusieurs éléments.

>>> fruits = ["pomme", "banane", "fraise"]
# modifier le 1er et le 2ème élément
>>> fruits[0:2] = ["abricot", "melon"]
>>> fruits
['abricot', 'melon', 'fraise']

Comme vous pouvez le constater, vous pouvez appliquer tous ce qu’on a vue avec les chaines de caractères en ce qui concerne les indices.

Est-il possible d’accéder aux lettres de chaque chaîne de caractères dans une liste.

>>> fruits = ["pomme", "banane", "fraise"]
>>> fruits[2][3]
'i'

En fait, les listes Python, remplacent les tableaux dans d’autres langages de programmation.

On utilise aussi cette méthode pour accéder aux éléments d’une liste imbriquée.

>>> ma_liste = ["python", 3, [2,4,7]]
# le troisième élément de la liste externe, i = 3-1
# et le deuxième élément de la liste interne, i = 2-1
>>> ma_liste[2][1]
4

Parcourir une liste python

Disons que nous voulons afficher chaque élément de la liste fruits. Le moyen le plus courant de parcourir les éléments d’une liste est d’utiliser une boucle for.

>>> for element in fruits:
	print(element)

À chaque itération de la boucle, la variable element stockera la valeur de l’un des éléments de la liste, un par un, triés par leurs indices.

pomme
abricot
fraise

De plus, il est possible d’utiliser les fonctions range() et len() pour parcourir une liste selon des indices spécifiques.
La fonction intégrée len(objet) est utilisée pour trouver les longueurs des objets.

>>> nombres = [2, 4, 5]
>>> len(nombres)
3
>>> range(len(nombres))
range(0, 3)                    # le 3 est exclu
>>> for i in range(len(nombres)):
	print(nombres[i] * 2)

len() renvoie le nombre d’éléments de la liste et range() renvoie une liste d’indices de 0 à n - 1.

4
8
10

Nous pouvons modifier notre liste nombres pour avoir une nouvelle liste, en multipliant tous les éléments par 2.

>>> for i in range(len(nombres)):
	nombres[i] = nombres[i] * 2

Cette boucle parcourt la liste et multiplie chaque élément par 2.

>>> nombres
[4, 8, 10]

Les opérations sur les listes Python

Concaténer des listes Python

Pour concaténer deux listes, on utilise l’opérateur +.

>>> liste_1 = [1, 2, 3]
>>> liste_2 = [4, 5, 6]
>>> liste_1 + liste_2
[1, 2, 3, 4, 5, 6]

Répéter les éléments d’une liste

L’opérateur * permet de répéter une liste.

>>> liste_3 =["a"]
>>> liste_3 * 5
['a', 'a', 'a', 'a', 'a']

Vérifier si un élément existe dans une liste

L’opérateur in vous permet de tester rapidement si un objet est dans la liste ou non. Aussi, vous pouvez utiliser l’opérateur not in pour vérifier si un objet spécifique ne fait pas partie des éléments de la liste. L’interpréteur renvoie True ou False.

>>> fruits = ["pomme", "banane", "fraise"]
>>> "pomme" in fruits
True
>>> "citron" not in fruits
True

Les méthodes de listes

Python fournit des méthodes qui opèrent sur des listes.
append() : ajoute un nouvel élément à la fin d’une liste.

>>> liste = [1, 2, 3]
>>> liste.append(4)
>>> liste
[1, 2, 3, 4]

extend() : elle prend une liste comme argument et ajoute tous ces éléments à une autre liste.

>>> liste_1 = [1, 2, 3]
>>> liste_2 = [4, 5, 6]
>>> liste_1.extend(liste_2)
>>> liste_1
[1, 2, 3, 4, 5, 6]
>>> liste_2
[4, 5, 6]

Uniquement liste_1 qui a été modifiée.

sort () : trie les éléments d’une liste dans un ordre croissant ou décroissant.

>>> voyelles = ['e', 'a', 'u', 'o', 'i']
>>> voyelles.sort()
>>> voyelles
['a', 'e', 'i', 'o', 'u']

Pour trier la liste dans un ordre décroissant, utilisez le paramètre reverse = True .

>>> liste = [1, 2, 3]
>>> liste.sort(reverse=True)
>>> liste
[3, 2, 1]

La méthode sort() modifie la liste d’origine.

En fait, la plupart des méthodes des listes modifient l’objet et renvoient None.
Si vous écrivez liste = liste.sort (), vous serez surpris par le résultat.

>>> voyelles = voyelles.sort()
>>> print(voyelles)
None

Donc, la méthode sort() ne renvoie aucune valeur.

reverse() : inverser une liste Python.

>>> liste = [1, 2, 3, 4, 5]
>>> liste.reverse()
>>> liste
[5, 4, 3, 2, 1]

count() : renvoie le nombre occurrence d’un élément dans une liste.

>>> liste = [1, 2, 3, 4, 5, 2, 3, 1, 2]
>>> liste.count(2)
3

Supprimer un élément d’une liste Python

Il existe plusieurs façons pour supprimer des éléments d’une liste.

clear() : supprimer tous les éléments de la liste.

>>> liste.clear()
>>> liste
[]

pop() : supprimer un élément par son indice et obtenir sa valeur.

>>> liste = [4, 5, 6]
>>> liste.pop(1)
5
>>> liste
[4, 6]

En fait, si l’argument n’est pas spécifié, le dernier élément sera supprimé.

>>> liste = [4, 5, 6]
>>> liste.pop()
6
>>> liste
[4, 5]

remove() : si vous connaissez l’élément que vous souhaitez supprimer et que vous n’avez pas son index.

>>> liste = [4, 5, 6]
>>> liste.remove(4)
>>> liste
[5, 6]

Si la liste contient plusieurs éléments avec la même valeur, le premier sera supprimé.

Par ailleurs, del n’est pas une méthode et elle est utilisée pour supprimer un ou plusieurs éléments en utilisant les indices.

>>> liste = [1, 2, 3, 4, 5, 6]
>>> del liste[1:4]  # index=1,2,3 (supprime 2,3 et 4)
>>> liste
[1, 5, 6]

Vous pouvez appliquer tous les principes d’indexation qu’on a vu dans les chaînes de caractères.

Il existe une autre technique de suppression, l’utilisation des indices et d’une liste vide.

>>> fruits = ["pomme", "banane", "fraise"]
>>> fruits[0:2] = []
>>> fruits
['fraise']

Vous pouvez obtenir une liste de toutes les méthodes associées à une liste en utilisant la fonction dir ().

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', 
'__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', 
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append',
'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove',
'reverse', 'sort']

Découper une liste Python

Comme avec les chaînes de caractères, vous pouvez accéder aux éléments d’une liste et créer des sous-listes en utilisant les crochets, les indices et les deux points.
Le n ème élément possède un index de n-1. Puisque le premier indice commence à 0, le deuxième élément aura un indice de 2-1, donc 1, et l’indice du troisième élément est 2.

>>> liste = [1, 2, 4, 8, 16, 32]
# du 2ème au 4ème élément, 
# inclure l'index du début et exclure l'index de la fin
# notez que l'élément avec l'indice 4 est 16
>>> liste[1:4]
[2, 4, 8]
# le troisième élément à partir de la fin
# le dernier indice est le -1
>>> liste[-3]
8
# du premier élément au quatrième
# on commence de l'index 0
>>> liste[:4]
[1, 2, 4, 8]
# du 5ème élément au dernier
>>> liste[4:]
[16, 32]
# du début à la fin
>>> liste[:]
[1, 2, 4, 8, 16, 32]

Les listes Python et les fonctions

Bien que toutes les méthodes soient des fonctions en Python, toutes les fonctions ne sont pas des méthodes. Les fonctions prennent des objets comme entrées. En revanche, les méthodes agissent sur les objets.

En utilisant certaines fonctions intégrées, on peut parcourir rapidement une liste sans écrire des boucles.

max (liste) : l’élément de la liste avec une valeur maximale.

>>> liste = [5,6,8,4,1,9]
>>> max(liste)
9

min (liste) : la valeur minimale d’une liste.
sum(liste) : renvoie la somme des éléments d’une liste.
len (liste) : donne la longueur totale de la liste.
cmp (liste1, liste2) : compare les éléments des deux listes liste1 et liste2.

Les listes Python et les alias

En Python, lorsque deux variables font référence au même objet, elles deviennent des alias elles elles auront la même adresse mémoire.

>>> a = [20, 25, 30]
>>> b = [20, 25, 30]
>>> a is b
False
>>> id(a)
139750467746432
>>> id(b)
139750467345536

Malgré que les valeurs des deux listes sont identiques, elles ne font pas référence au même objet.

Pour que ça soit possible, il faut utiliser la notion d’affectation.

>>> a = b
>>> a is b
True
>>> id(a)
139750467345536
>>> id(b)
139750467345536

À présent, notre objet liste possède deux noms, donc on dit que c’est un alias.

Essayons de modifier l’une des deux variables.

>>> a[0] = 19
>>> b
[19, 25, 30]

En fait, les listes sont mutables, ce qui fait que lorsque vous avez plusieurs variables qui font référence au même objet, la modification de l’une d’elles entraînera la modification de l’objet et de toutes les autres variables.

Par conséquent, vous devez éviter les alias avec des objets mutables comme les listes, sinon vous aurez de mauvaises surprises.

Toutefois, cela ne peut pas se produire avec des valeurs immuables, telle qu’une chaîne de caractères. Puisqu’elle ne peut pas être modifiée après sa création.

Les listes et les chaînes de caractères

Une chaîne de caractères est une séquence de caractères et une liste est une séquence de valeurs. Cependant, une liste de caractères n’est pas la même chose qu’une chaîne. Pour convertir une chaîne en une liste de caractères, vous pouvez utiliser la fonction list(), qu’on a déjà utilisé pour créer une liste.

>>> ctr = "wow"
>>> lst = list(ctr)
>>> lst
['w', 'o', 'w']

La fonction list() transforme les lettres d’une chaîne de caractères en éléments de liste.

En outre, on peut appliquer la méthode split() sur une chaîne de caractères pour obtenir une liste.

>>> phrase = "créer une liste à partir d'une chaine"
>>> phrase_liste = phrase.split()
phrase_liste = ['créer', 'une', 'liste', 'à', 'partir', "d'une", 'chaine']
>>> phrase_liste[4]
'partir'

En fait, la création d’une liste à partir d’une chaîne de caractère avec la méthode split(), vous permet d’accéder à n’importe quel élément en utilisant son indice.

De plus, split() prend en argument le délimiteur de votre liste.

>>> ctr = "bonjour, bonjour, bonjour"
>>> lst = ctr.split(',')
>>> lst
['bonjour', ' bonjour', ' bonjour']

Si on veut faire l’inverse et récupérer une chaîne à partir d’une liste, nous utiliserons la méthode join() qui prendra en paramètre la chaîne de caractères.

>>> lst = ['bonjour', ' bonjour', ' bonjour']
>>> sep = ' '
>>> ctr = sep.join(lst)
>>> ctr
'bonjour  bonjour  bonjour'

sep est le séparateur que vous voulez inclure dans la chaîne de caractère.

Remplir les listes avec des éléments

Une des méthodes courantes qui permet de remplir une liste Python, est de créer une liste vide [], puis d’utiliser les fonctions append () ou extend () pour ajouter des éléments à la liste.

>>> fruits = []
>>> fruits.append("pomme")
>>> fruits
['pomme']