Accueil

Tutoriel Python - sommaire

Les listes

Premiers pas

C’est une structure qui peut être très utile. Une liste peut contenir des données de types différents.
En Python, une liste se note entre crochets avec la virgule comme séparateur entre chaque élément.

Liste de nombres

Une batterie de commandes pour s'échauffer ... (lol).

>>> 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] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range

a est un variable correspondant à une liste.
La commande type(a) retourne 'list'.
Les commandes "list(a)" ou "print(a)" ou "a" affichent le contenu 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.
len(a) : retourne le nombre d’éléments de la liste (sa longueur)
a.sort() : tri les éléments de façon croissante
a.append(11) : ajout du nombre 11 à la liste
a.index(5) : indique la position de l'élément 5 dans la liste
a.index(11) : indique la position du nombre 11 dans la liste
a[2] : retourne l'élément de rang 2 (donc le troisième)
a[5] : retourne un message d'erreur, l'élément de rang 5 n'existe pas

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

Essayons !

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

Donc la réponse est OUI.

Liste de nombres 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.

Tests

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é.

Vous êtes, à juste titre fier da la commmande que vous avez produite. Et pourtant en fermant l'interpréteur, celle-ci est perdue !
L'on voit les limites du "mode commandes".

Liste de "mots"

On peut construire des listes de chaines ou des listes mixtes (des chaines et des nombres).

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 !

Encore plus loin avec les listes de chaines

Commandes à taper :

>>> 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 la console ne peut savoir où s’arrête la chaine.

De telles commandes peuvent-elles s'appliquer à une liste de nombres ?

Vérifions !

>>> 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

Dans le cadre de la programmation objet, la syntaxe est la suivante : nomListe.méthode(paramètres éventuels).

Les 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"
>>> chaine.split()
['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']

Dans la chaine "chaine" il y a des espaces alors que dans "chaine2" il y a à la place des doubles points.
Donc pour créer une liste à partir de "chaine2" il faut préciser en paramètre le symbole de séparation.

Les listes de listes

Et oui, c'est possible. Et vous verrez plus tard que ça peut être très utile dans le cadre de certains programmes de cryptage ...

>>> 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 for.

Ce chapitre est terminé !

J'aurai l'occasion de revenir sur les listes car c'est une structure de données fondamentale en Python.
Vous verrez aussi par la suite qu'il existe d'autres types de listes : tuples, dictionnaires, ensembles.

Vous savez déjà utiliser beaucoup de fonctions génériques : print(), list(), type(), range()...
Dans le chapitre suivant vous allez apprendre à créer vos propres fonctions.