Accueil
Mes tutoriels sur la programmation

Tutoriel Python - sommaire


Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site

Les listes

Premiers pas

Définition d'une liste

La liste est le conteneur (série de données) le plus utilisé.
Lorsqu'on interroge une liste avec la fonction type(), le message retourné est "class 'list'" (instance de la classe 'list').
Il s'agit d'une suite d'élements séparés par des virgules et encadrés par des crochets.
Les différentes éléments peuvent être des entiers, des flottants, des chaines, des booléens ou un mélange de tout cela.
Tapez dans la console interactive (l'interpréteur) :

>>> maliste = [True,3,"bonjour", 3.14] >>> type(maliste) <class 'list'> >>> type(maliste[0]) <class 'bool'> >>> type(maliste[1]) <class 'int'> >>> type(maliste[2]) <class 'str'> >>> type(maliste[3]) <class 'float'> >>>

La liste ci-dessus comprend 4 éléments de type différent : un booléen, un entier, une chaine et un flottant.
Le premier élément d'une liste a l'indice 0 ! Donc si le nombre de termes d'une liste est n alors le dernier terme a l'indice n-1.

Liste d'entiers

On utilise très souvent les listes d'entiers d'autant qu'elles peuvent être créées rapidement via la fonction range().

Une batterie de commandes à saisir dans la console interactive.

>>> a=[7,5,9,3] >>> type(a) <class 'list'> >>> list(a) [7, 5, 9, 3] >>> print(a) [7, 5, 9, 3] >>> a [7, 5, 9, 3] >>> a[0] 7 >>> a[2] 9 >>> len(a) 4 >>> a.sort() >>> a [3, 5, 7, 9] >>> a.append(11) >>> a [3, 5, 7, 9, 11] >>> a.index(5) 1 >>> a.index(11) 4 >>> a[5] IndexError: list index out of range >>> a.index(13) ValueError: 13 is not in list

a est un variable contenant une liste. En effet on lui a affecté une énumération délimitée par des crochets.
La commande type(a) retourne 'list'.
Les commandes list(a) ou print(a) ou a ont le même effet : afficher le détail de la liste.
Pour afficher le premier élément de la liste il faut écrire a[0]. On dit que le premier nombre a la position (ou indice) zéro, le deuxième l’indice 1, etc. L'indice doit être écrit entre crochets.

Peux t-on utiliser l'opérateur de comparaison "in" dans une liste d'entiers ?

Essayons !

>>> a = [5,6,7,8]
>>> 5 in a
True
>>> 10 in a
False
>>> 7 in a
True

Donc la réponse est OUI ! Une commande basé sur l'opérateur "in" retourne un booléen.

Liste d'entiers avec la fonction range()

On peut construire rapidement une liste d'entiers grâce à une commande basée sur la fonction range().
Cette fonction est particulièrement puissante.

Tapez les commandes suivantes

>>> b = range(10)
>>> b
range(0, 10)
>>> list(b)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a =range(1,10)
>>> list(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> impairs =range(1,20,2)
>>> list(impairs)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> pairs =range(2,20,2)
>>> list(pairs)
[2, 4, 6, 8, 10, 12, 14, 16, 18]

Listes en compréhension

Abordons maintenant des formules un peu plus complexes : listes en compréhension.

Construire la liste des carrés des entiers naturels

>>> carres = [x**2 for x in range(10)]
>>> carres
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

La commande produit d'abord une liste de 0 à 9 puis chaque terme est mis au carré.

Construire la liste des premiers entiers pairs

>>> pairs = [x for x in range(10) if x % 2 == 0]
>>> pairs
[0, 2, 4, 6, 8]

La commande produit d'abord une liste de 0 à 9 puis ne retient que les entiers dont la division entière par 2 donne zéro !

Construire la liste des carrés des premiers entiers impairs

>>> carres_impairs= [x**2 for x in range(12) if x % 2 != 0]
>>> carres_impairs
[1, 9, 25, 49, 81, 121]

La commande produit d'abord une liste de 0 à 11 puis ne retient que les nombres impairs (reste de la division entière non nulle).
Puis chaque terme retenu est mis au carré.

Liste de "mots"

On peut construire des listes de chaines.

Une série de commandes sur une liste de chaines

Pour se mettre en jambes (LOL) :

>>> impairs = ['un','trois','cinq','sept']
>>> impairs[0]
'un'
>>> impairs[4]
IndexError: list index out of range
>>> 'trois' in impairs
True
>>> 'quatre' in impairs
False
>>> impairs.index('trois')
1
>>> impairs.append('onze')
>>> impairs
['un', 'trois', 'cinq', 'sept', 'onze']
>>> impairs.append('onze')
5

La liste contient des nombres écrits en lettres !

Plus loin dans le "slicing"

À saisir dans l'interpréteur :

>>> liste =["l'homme","l'oie","l'âne","l'orvet"]
>>> liste[-1]
"l'orvet"
>>> liste[-2]
"l'âne"
>>> liste[1:3]
["l'oie", "l’âne"]
>>> liste[2:]
["l'âne", "l'orvet"]
>>> liste[:2]
["l'homme", "l'oie"]
>>>

Quand une chaine comprend une apostrophe, elle doit impérativement être délimitée par une paire de guillemets doubles (jamais des guillemets simples). Et c’est logique sinon l'interpréteur ne peut savoir où s’arrête la chaine.

De telles commandes peuvent-elles s'appliquer à une liste de nombres ?
Vérifions ci-dessous !

>>> premiers = [2,3,5,7,11]
>>> premiers[-1]
11
>>> premiers[-2]
7
>>> premiers[2:]
[5, 7, 11]
>>> premiers[:2]
[2, 3]

Donc la réponse est OUI !

* un nombre premier et un entier qui admet seulement 2 diviseurs : 1 et lui-même.

Retour sur les listes : approfondissements

L’addition entre des listes et la multiplication d’une liste par un entier

Exemple :

>>> ma_liste = [1,2,3,4]
>>> ma_liste2 = ma_liste + [5,6]
>>> ma_liste2
[1, 2, 3, 4, 5, 6]
>>> ma_liste3 = ma_liste2*2
>>> ma_liste3
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
>>> ma_liste
[1, 2, 3, 4]

Première commande : ajout d'éléments à une nouvelle liste à partir de la liste initiale
Deuxième commande : affichage d'une liste avec le double d'éléments.
Attention, si vous écrivez seulement ma_liste2 *2 vous affichez (mais ne créez pas) une nouvelle liste à partir de liste2.
Pour créer une nouvelle liste, il faut écrire : ma_liste3 = ma_liste2*2

Des méthodes que l'on peut appliquer à une liste

La syntaxe est la suivante : nomListe.méthode(paramètres éventuels).

Quelques méthodes applicables à une liste :

>>> ma_liste = [1,2,3,4,5]
>>> ma_liste.extend([6,7])
>>> ma_liste
[1, 2, 3, 4, 5, 6, 7]
>>> ma_liste.insert(0,0) #insertion de la valeur 0 à la position 0
>>> ma_liste
[0, 1, 2, 3, 4, 5, 6, 7]
>>> ma_liste.insert(8,8)
>>> ma_liste
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> ma_liste.remove(8)
>>> ma_liste
[0, 1, 2, 3, 4, 5, 6, 7]
>>> ma_liste.pop(0)
0
>>> ma_liste
[1, 2, 3, 4, 5, 6, 7]
>>> ma_liste.reverse()
>>> ma_liste
[7, 6, 5, 4, 3, 2, 1]

Donc les deux méthodes remove() & pop() suppriment un élément de la liste ; mais avec remove() il faut passer en argument la valeur de l'élément alors qu'avec pop() il faut argumenter avec son rang (ou indice ou position). Sachant que le premier élément a le rang zéro !

Convertir une chaine en liste

Il faut employer la méthode split().
A défaut de paramètre les espaces sont utilisés comme séparateurs.
Exemple :

>>> chaine ="un deux trois cinq sept onze"
>>> liste_chaine = chaine.split()
>>> liste_chaine
['un', 'deux', 'trois', 'cinq', 'sept', 'onze']
>>> chaine2 ="un:deux:trois:cinq:sept:onze"
>>> liste_chaine2=chaine2.split(':')
>>> liste_chaine2
['un', 'deux', 'trois', 'cinq', 'sept', 'onze']

Il faut argumenter la méthode split() avec le caractère qui sert de séparateur pour l'élaboration de la liste de destination.
Par défaut le séparateur est l'espace.

Les listes de listes

Et oui, c'est possible. Et vous verrez plus tard que ça peut être très parfois utile ...

>>> liste_de_listes = [['a','1'], ['e','2'],['i','3']]
>>> liste_de_listes
[['a', '1'], ['e', '2'], ['i', '3']]
>>> for s in liste_de_listes:
...     print(s)
...
['a', '1']
['e', '2']
['i', '3']

J'ai crée une liste nommée "liste_de_listes" qui comprend 3 sous-listes.
Pour afficher successivement chaque sous-liste je suis obligé de créer une boucle.