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.

Dans ce chapitre y a un nombre très important de commandes à saisir afin de vous familiariser avec la syntaxe.
Plutôt qu'utiliser la console Python vous pouvez utiliser le service en ligne Google Colab : voir fin de ce chapitre pour plus d'explications.

Les listes - découverte

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 >>> 3 in maliste True >>> 4 not in maliste True >>>

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

On peut appliquer à une liste les opérateurs "in" et "not in".

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 (ou dans un "notebook" : voir fin du chapitre). >>> 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 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'> >>> liste2 = list(b) >>> type(liste2) <class 'list'> >>> liste2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> 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().

Les arguments de la fonction 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.
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 la construction de listes en compréhension.

Objectif : 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 : carres =list(x**2 for x in range(1,10))

Construire la liste des premiers entiers pairs

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

Construire une nouvelle liste à partir d'une autre liste

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"

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

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 !

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.

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 créer à partir d'un objet "range" des liste, tuple,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 j'ai créé successivement à partir d'un objet "range" :
• 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.

Tester la syntaxe Python : un autre outil

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.

Se connecter à la plateforme

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