Traduction
Tutoriel Python - sommaire
Tutoriel Python - recherche
L'auteur : Patrick Darcheville
Vous pouvez me contacter via Facebook pour questions & suggestions :
Page Facebook relative à mon site
Vous pouvez me contacter via Facebook pour questions & suggestions :
Page Facebook relative à mon site
Une liste est une série 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 différence d'un objet str, une liste est un objet mutable comme nous allons le démontrer plus loin.
On peut créer facilement un objet "list" composé d'une série d'entiers avec la fonction range() comme nous le verrons un peu plus loin.
Vous pouvez tester la syntaxe Python de façon plus ergonomique qu'avec la console, en utilisant la plateforme Google colab ; voir la fin de ce chapitre.
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.
>>> maliste = [True,3,"bonjour", 3.14] >>> type(maliste) class 'list' >>> maliste[0] True >>> maliste[3] 3.14 >>> maliste[4] ... IndexError: list index out of range >>> machaine = maliste[2] >>> machaine 'bonjour' >>> maliste[3] = 3.14116 # modifier un élément de la liste >>> maliste [True, 3, 'bonjour', 3.14116]
"maliste" est un objet de type "list" on dit aussi 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 élement de la liste : nomListe[indice].
Il s'agit du "slicing" déjà utilisé dans la chapitre précédent avec les chaines.
En effet une liste est un objet ordonnée et indexable comme une chaine.
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.
Dans l'exemple les quatre éléments ont respectivement l'indice 0 à 3 donc la commande maliste[4] retourne un
message d'erreur.
Je vous montrer comment créer une variable simple à partir d'une liste et pour terminer comment changer la valeur
d'un élément de la liste via l'accès indexé : nomListe[indice] =nouvelle valeur
On peut construire facilement une liste d'entiers à partir de la fonction range() et la fonction list()
>>> pairs =range(2,20,2) >>> type(pairs) class 'range' >>> liste_pairs = list(pairs) >>> liste_pairs [2, 4, 6, 8, 10, 12, 14, 16, 18] >>> impairs = list(range(1,13,2)) >>> impairs [1, 3, 5, 7, 9, 11] >>>
Attention la fonction range() employée seule crée un objet de type "range".
Pour créer un objet "list" il faut combiner les fonctions list() & range()
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.
Dans la fonction range(), seul l'argument stop est obligatoire ;
Par défaut start vaut alors 0 et step vaut +1
Ainsi range(10) retourne la série des entiers de 0 à 9 avec un pas de +1.
>>> 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]
>>> carres = [x**2 for x in range(10)] >>> type(carres) class 'list' >>> carres [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
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 : carres =list(x**2 for x in range(10))
>>> 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" ?
>>> impairs = list(range(1,11,2)) >>> impairs [1, 3, 5, 7, 9] >>> len(impairs) 5 >>> min(impairs) 1 >>> max(impairs) 9 >>> sum(impairs) 25 >>> impairs.index(5) 2 >>> # la valeur 5 a l'indice 2 >>> impairs.append(13) >>> impairs [1, 3, 5, 7, 9, 13]
Len(), min(), max(),sum() sont des fonctions génériques appliquées à un objet "list".
.index(), .append() sont des méthodes de la classe "list".
Les méthodes sont des fonctions spécifiques à une classe d'objets.
Lors de l'emploi de méthodes de classe, on dit que l'on utilise la "notation pointée".
Attention la méthode .index(valeur) peut être mal comprise ; Cette méthode retourne un index (ou indice) mais est argumentée avec une valeur. Alors que l'accès indexé (nomListe[indice]) est argumenté avec un index mais retourne une valeur ou un message d'erreur ...
La valeur entre crochets peut être négative.
>>> liste_mots =["l'homme","l'oie","l'âne","l'orvet"] >>> liste_mots[-1] "l'orvet" >>> liste_mots[-2] "l'âne" >>> liste_mots[-1] ="l'anilocre" >>> liste_mots ["l'homme", "l'oie", "l'âne", "l'anilocre"]
Remarque : "liste_mots" est une séquence de mots. Chaque mot comprend l'apostrophe ; aussi il doit être délimité par des guillemets doubles (ou il faut échapper l'apostrophe).
Un indice négatif permet de compter à partir de la fin de la liste.
C'est très pratique quand on ne connait pas le nombre de d'éléments d'une liste.
Je vous rappelle aussi que "slicing" permet de remplacer un élément de la liste.
Jusqu'à présent avec l'accès indexé on s'est contenté d'accéder à un seul élément. Mais on peut accéder à une tranche (plusieurs éléments) avec la syntaxe nomListe[indice début : indice fin]
>>> liste_mots =["l'homme","l'oie","l'âne","l'anilocre"] >>> liste_mots[1:3] ["l'oie", "l'âne"] >>> liste_mots[2:] ["l'âne", "l'orvet"] >>> liste_mots[:2] ["l'homme", "l'oie"]
Donc si rien devant ":" équivaut à l'indice zéro Et si rien après ":" équivant à fin de liste.
>>> pairs = list(range(2,10,2)) >>> pairs [2, 4, 6, 8] >>> impairs =list(range(1,11,2)) >>> impairs [1, 3, 5, 7, 9] >>> entiers = pairs + impairs >>> entiers [2, 4, 6, 8, 1, 3, 5, 7, 9] >>> entiers.sort() >>> entiers [1, 2, 3, 4, 5, 6, 7, 8, 9]
Dans "entiers" j'ai ajouté les listes "pairs" & "impairs".
Puis j'ai effectué un tri.
J'ai déjà présenté deux méthodes de liste : .index(valeur) & .append(valeur) qui permettent respectivement de rechercher un élément et d'ajouter un élément . Mais il existe bien d'autres méthodes de liste.
>>> maliste =list(range(10)) >>> maliste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> maliste.append(5) >>> maliste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5] >>> maliste.count(5) 2 >>> maliste.reverse() >>> maliste [5, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] >>> maliste.sort() >>> maliste [0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9] >>> maliste.clear() >>> maliste []
La méthode .count(valeur) indique le nombre d'occurences pour une valeur dans la liste.
Attention les méthodes .reverse() & .sort() modifient l'ordre des éléments de la liste.
La méthode .clear() vide une liste.
La méthode .sort() trie les éléments par valeurs croissantes.
Je viens de vous montrer que l'on peut modifier une liste avec les méthodes .append(), .sort(), .reverse(), .clear()
Donc, et à la différence d'un objet str, un objet "list" est mutable !
Pour certaines "mutations" vous n'êtes pas obligé d'utiliser une méthode de classe mais plus simplement l'accès indexé !
>>> uneliste = list(range(10,1,-1)) >>> uneliste [10, 9, 8, 7, 6, 5, 4, 3, 2] >>> uneliste[0] = 11 >>> uneliste [11, 9, 8, 7, 6, 5, 4, 3, 2] >>> del uneliste[0] >>> uneliste [9, 8, 7, 6, 5, 4, 3, 2] >>>
Ci-dessous je vous montre comment remplacer / supprimer un élément via l'accès indexé.
Mais j'aurais pu utiliser aussi des méthodes de classe : .remove(), .pop(), .insert()
Cette situation se présente souvent dans le cadre d'un programme.
>>> liste_vide = [] >>> len(liste_vide) 0 >>> for i in range(5) : ... liste_vide.append(3) ... >>> liste_vide [3, 3, 3, 3, 3] >>> 3 in liste_vide True >>> 4 in liste_vide False >>> liste_vide.count(5) 0 >>> liste_vide.index(5) ... ValueError: 5 is not in list >>>
liste_vide = [] : création d'une liste nommmée "liste_vide" qui ne contient rien.
for i in range(5) : : création d'une boucle exécutée 5 fois (de 0 à 5 exclu)
J'aurai l'occasion de revenir plus loin sur la structure for ... in range ...
Pour effectuer une recherche de valeur dans une liste vous pouvez utiliser l'opérateur "in" qui retourne un booléen OU les méthodes .index() & .count() .
Préférez .count() qui retourne zéro si recherche infrutueuse alors que .index() retourne un mesage d'erreur ...
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.
Une liste de mots peut être convertie en une chaine ; une chaine peut être convertie en une liste de mots.
>>> maliste = ["aaa", "bbb", "ccc", "dddd", "ffff", "eeee"] >>> machaine = " - ".join(maliste) >>> machaine 'aaa - bbb - ccc - dddd - ffff - eeee' >>> machaine = " ".join(maliste) >>> machaine 'aaa bbb ccc dddd ffff eeee' >>> machaine = "".join(maliste) >>> machaine 'aaabbbcccddddffffeeee'
machaine = " - ".join(maliste) : la méthode join() a une syntaxe étrange ...
Elle convertit ici une liste de chaines en une chaine unique. Les crochets et les guillemets internes sont supprimés,
les virgules sont ici remplacées par des "-".
Si je veux des espaces ll suffit d'écrire : : machaine = " ".join(maliste)
Si je veux coller les mots : machaine = "".join(maliste)
Pour que chaque mot d'une chaine devienne un élément d'une liste il faut utiliser la méthode de chaine : split().
>>> chaine ="un deux trois cinq sept onze"
>>> 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 méthode de chaine split() appliquée une chaine avec des séparateurs crée une liste de mots.
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 " ".
La console Python présente de nombreux inconvénients : aucune assistance pour la saisie des commandes donc des risques d'erreurs
de saisie.
De plus aucune possibilité de sauvegarder les commandes.
Si vous souhaitez une interface plus agréable (avec un aide à la saisie, la possibilité de modifier une commande et
de sauvegarder les commandes) utilisez la plateforme Google Colab.
Dès que vous avez un compte Google vous pouvez utiliser ce service en ligne.
Pour tester un série de commandes il suffit de créer ou de modifier un "notebook".
Le service en ligne Google Colab permet d'utiliser le langage Python sans rien avoir installé sur votre ordinateur.
Composez l'URL : https://colab.research.google.com/?hl=fr
La page d'accueil :
Il suffit de cliquer sur "+Nouveau Notebook" ou sur un notebook présent dans la liste.
Ci-dessous une capture d'écran sur le fichier "test_liste.ipynb"
Vous ne voyez pas toutes les commandes stockées dans ce fichier.
Ci-dessous les commandes et l'affichage éventuel (->) qui en découle :
impairs = [x for x in range(13) if x %2 !=0] impairs -> [1, 3, 5, 7, 9, 11] len(impairs) -> 6 8 in impairs -> False impairs[0] -> 1 type(impairs) -> list impairs.append(13) print(impairs) -> [1, 3, 5, 7, 9, 11, 13] impairs.index(5) -> 2 #le chiffre 5 a le rang 2 dans la liste impairs (3ième rang) impairs.extend([15,17]) impairs.reverse() impairs.sort() impairs -> [1,3,5,7,9,11,15,17] impairs.clear() impairs -> []
J'ai créé la liste des premières nombres impairs en compréhension.
Puis j'ai appliqué à cette liste des fonctions génériques (len(), type(), print()) mais aussi des méthodes de liste : append(), index(),
etc.
Le gros avantage est que vous êtes assisté pour la saisie des commandes.
Ainsi si vous tapez : "pairs =[" le crochet fermant est ajouté automatiquement.
Si vous saisissez à l'intérieur des crochets : "x for x in range( ", la parenthèse fermante est ajoutée automatiquement.
Pour revenir à la page d'accueil il suffit de cliquer sur l'icône "CO" en haut à droite (avec lettres de couleur or).
Attention une liste Python n'est pas vraiment comparable à un tableau indicé ("array") dans d'autres langages (C, C++, Java).
En effet dans ces langages les "arrays" ont obligatoirement un contenu homogène, par exemple une suite d'entiers ou de flottants.
Or en Python rien n'interdit de mélanger dans une liste des entiers avec des flottants ou des chaines ou des booléens.
Dans le chapitre 15 vous verrez que le module array de Python permet de créer de véritables tableaux indicés.
Le point sur les conteneurs, d'autres conteneurs moins connus