Tutoriel Python - sommaire

Les listes - la fonction range()

Une liste est une suite de données simples.
Une liste est délimitée par des crochets et les différents éléments sont séparés par des virgules. La liste est l'équivalent d'un tableau indicé dans d'autres langages.

Les listes : premiers pas

Les différentes éléments d'une liste peuvent être des entiers, des flottants, des chaines, des booléens OU un mélange de tout cela.

Exercice : tapez dans la console interactive les commandes qui suivent : >>> 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'> >>> liste2 =[] >>> type(liste2) <class 'list'> >>> len(liste2) 0 >>>

"maliste" est un objet de type "list" (ou instance de la classe "list").
La liste "maliste" comprend 4 éléments de type différent : un booléen, un entier, une chaine et un flottant.
Je vous montre ci-dessus comment accéder à un élément d'une liste : nomListe[indice].
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.

Je crée ensuite une liste vide nommée "liste2 : rien entre les deux crochets.
Pour la remplir je pourrai utiliser certaines méthodes de liste telles insert(), append(), extend() ; méthodes qui seront abordées plus loin.

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() ; voir paragraphe suivant.

Commandes à saisir dans la console interactive. >>> a=[7,5,9,3] >>> type(a) <class 'list'> >>> 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 print(a) et 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. Attention l'indice doit être écrit entre crochets.

Commentaire des autres commandes :
• len(a) : retourne le nombre d’éléments de la liste : sa longueur
• a.sort() : tri des é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[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 ; le dernier élément a le rang 4
• a.index(13) : retourne un message d'erreur, le nombre 13 ne fait pas partie de la liste

Attention len est une fonction générique tandis que append(),index(), sort() sont des méthodes (fonctions spécifiques à une classe d'objets) d'où des syntaxes différentes.

Syntaxes :
• emploi d'une fonction générique : fonction(argument)
• emploi d'une méthode : objet.méthode(argument)

La fonction range()

On peut construire facilement un série composée d'entiers grâce à la fonction native range().

Tests

Commandes à saisir dans la console. >>> b =range(10) >>> b range(0, 10) >>> type(b) <class 'range'> >>> maliste = list(range(10)) >>> maliste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> type(maliste) <class 'list'> >>> pairs =range(2,20,2) >>> liste_pairs = list(pairs) >>> liste_pairs [2, 4, 6, 8, 10, 12, 14, 16, 18] >>> type(liste_pairs) <class 'list'>

Attention la fonction range() toute seule crée un objet de type "range" (et non pas un objet de type "list").
Pour créer une liste composée d'entiers, il faut donc imbriquer les fonctions range() & list() dans la même commande OU enchainer deux commandes : la première basée sur range() puis une seconde basée sur list().

La fonction range() peut avoir jusqu'a trois arguments : start, stop, step.
Ainsi pairs = range(2,20,2) donne la série des entiers positifs de 2 à 20 (exclu) avec un pas de 2.
Seul l'argument stop est obligatoire; par défaut start vaut alors 0 et step vaut +1

Avec la fonction range() on peut créer une série avec des entiers négatifs, le pas aussi peut être négatif.
Exemples : >>> maliste =list(range(-10,11,2)) >>> maliste [-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10] >>>uneliste =list(range(10,-11,-2)) >>>uneliste [10, 8, 6, 4, 2, 0, -2, -4, -6, -8, -10]

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

La commande ci-dessus produit la liste des carrés des entiers de 0 à 9.
La série produite est une liste en raison des crochets qui délimitent la formule. J'aurais pu utiliser une autre syntaxe. Voir ci-dessous. >>> carres =list(x**2 for x in range(1,10)) >>> carres [1, 4, 9, 16, 25, 36, 49, 64, 81] >>> type(carres) <class 'list'>

A la place des crochets j'ai utilisé la fonction list().

Construire la liste des premiers entiers pairs

La commande produit la liste des entiers entre 0 et 9 dont la division entière par 2 donne un reste nul.

Construire une nouvelle liste à partir d'une autre liste

Ne pensez pas qu'il faille toujours employer la fonction range() pour bâtir une liste en compréhension. >>> entiers = [1,2,3,4,5,6,7,8,9] >>> pairs = [x for x in entiers if x%2==0] >>> pairs [2, 4, 6, 8]

La liste "pairs" a été construite en compréhension à partir de la liste "entiers".
Seriez vous capable de produire la liste "impairs" à partir de "entiers" ?

Liste de "mots"

On peut construire des listes de chaines.

Une série de commandes sur une liste de chaines

La liste contient des nombres écrits en lettres !

Commentons certaines de ces commmandes :
• impairs[4] retourne un message d’erreur puisque le dernier élément a l'indice 3 !
• 'trois' in impairs : l'opérateur 'in" fonctionne dans une liste de chaines
• impairs.index(‘trois') : la chaine "trois" est le deuxième élément donc la commmande retourne 1
• impairs.append('onze') : comme pour une liste de nombres, il est possible d’ajouter un élément en fin de liste.

Plus loin dans le "slicing"

À saisir dans la console. >>> 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.

Commentaires des commandes :
• liste[-1] : retourne le dernier élément ; c'est pratique quand on ignore le nombre d’éléments de celle-ci
• liste[-2] : retourne l’avant dernier élément
• liste[1:3] : extrait de liste : de l'élément d'indice 1 à 3 exclu
• liste[2:] : fin de liste : à partir de l'élément d'indice 2
• liste[:2] : début de liste jusqu'à celui d'indice 2 exclu

Le slicing peut s'appliquer à n'importe quelle liste en particulier 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]

Opérations complexes sur les listes

L’addition de deux 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]

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

La syntaxe est la suivante : nomListe.méthode(arguments é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]

Attention à la syntaxe :
• nomListe.insert(position,valeur)
• nomListe.remove(valeur)
• nomListe.pop(position)
• nomListe.reverse()

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

Pour que chaque caractère d'une chaine devienne un élément d'un liste il faut utiliser la fonction générique list
Par contre pour que chaque mot d'une liste devienne un élément d'une liste il faut utiliser la méthode de chaine : split() déjà abordée dans le chapitre précédent.

Commandes à saisir : >>> chaine ="un deux trois cinq sept onze" >>> liste1 = list(chaine) >>> liste1 ['u', 'n', ' ', 'd', 'e', 'u', 'x', ' ', 't', 'r', 'o', 'i', 's', ' ', 'c', 'i', 'n', 'q', ' ', 's', 'e', 'p', 't', ' ', 'o', 'n', 'z', 'e'] >>> liste_mots = chaine.split() >>> liste_mots ['un', 'deux', 'trois', 'cinq', 'sept', 'onze'] >>> chaine2 ="un:deux:trois:cinq:sept:onze" >>> liste_mots2 = chaine2.split(':') >>> liste_mots2 ['un', 'deux', 'trois', 'cinq', 'sept', 'onze']

La fonction list() appliquée à "chaine" crée une liste qui présente peu d'intérêt ; chaque caractère de la chaine devient un item de la liste.
Par contre la méthode de chaine split() appliquée une chaine avec des séparateurs crée une liste de mots utile.

Il faut argumenter la méthode split() avec le caractère qui sert de séparateur de mots dans la chaine d'origine. Par défaut le séparateur est le caractère 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 sous_liste in liste_de_listes: ... print(sous_liste) ... ['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.

C'est l'équivalent des tableaux indicés à deux dimensions en JavaScript.

Annexe : compléments sur le type range

La fonction range() seule ne construit pas une liste mais un objet de type range.
Il est possible ensuite de convertir un objet range en liste ou tuple voire en set. >>> r =range(1,10) >>> type(r) <class 'range'> >>> maliste =list(r) >>> type(maliste) <class 'list'> >>> maliste [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> montuple =tuple(r) >>> type(montuple) <class 'tuple'> >>> montuple (1, 2, 3, 4, 5, 6, 7, 8, 9) >>> monset =set(r) >>> monset {1, 2, 3, 4, 5, 6, 7, 8, 9} >>>type(monset) <class 'set'>

Ci-dessous je convertis successivement un objet de type range en :
• une liste
• un tuple
• un "set" (ou "ensemble")

Les tuples et les ensembles sont des séquences qui ont des caractéristiques très utiles en programmation.
Ces deux types de séquences seront étudiés plus tard.
Retenez pour l'instant qu'un tuple ne peut être modifié après avoir été créé et qu'un ensemble ne peut contenir de doublons.