Ateliers Python : Introduction aux listes

Ateliers Python : Introduction aux listes
par X. HINAULT
www.mon-club-elec.fr
Tous droits réservés – 2013 - 2016.
Document gratuit.
Ce support PDF d'atelier Python + Qt vous est offert.
Pour acheter d'autres supports d'ateliers Python rendez-vous ici :
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.PythonShell
Vous avez constaté une erreur ? une coquille ? N'hésitez pas à nous le signaler à cette adresse : [email protected]
Truc d'utilisation : visualiser ce document en mode diaporama dans le visionneur PDF. Navigation avec les flèches HAUT / BAS ou la souris.
En mode fenêtre, activer le panneau latéral vous facilitera la navigation dans le document. Bonne lecture !
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 1 / 19
Python + interpréteur : introduction aux listes
Par X. HINAULT – Avril 2013 – www.mon-club-elec.fr – Tous droits réservés
Ce que l'on va faire ici
•
Dans ce tutoriel, apprenez à utiliser l'équivalent des tableaux, les listes avec le langage Python. Comme un tableau, une liste permet de stocker
plusieurs éléments dans un même objet, permet d'y accéder grâce à un indice, etc...
•
Mais un objet list Python, c'est beaucoup plus puissant et souple qu'un tableau : vous pouvez ajouter/enlever des éléments facilement, y mettre
des éléments de type différents, etc...
•
Toute la puissance de l'objet list apparaîtra clairement pour vous lorsque nous l'utiliserons avec la boucle For : vous découvrirez alors une
souplesse de programmation qui fait toute la force du langage Python.
Pré-requis : un système Gnu/Linux opérationnel
•
Je suppose ici que vous disposez
◦ d'un système graphique opérationnel (Gnu/Linux, Windows, Mac OsX) :
◦ avec Python installé ainsi que l'interpréteur Python de votre choix
Lancer l'interpréteur Python
•
Commencer par la lancer l'interpréteur Python que vous souhaitez utiliser, soit en ligne de commande depuis une console, soit à partir du menu
graphique du système.
•
Par exemple, pour lancer ipython, on fera :
$ ipython qtconsole
•
ce qui donne :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 2 / 19
•
De façon comparable, on lancera dreampie en faisant :
$ dreampie
•
On obtient :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 3 / 19
•
A noter avec Dreampie la particularité qui consiste à saisir les instructions Python dans la fenêtre du bas.
Conseil d'ami : paramétrer la fenêtre de votre interpréteur en mode « toujours au dessus » (clic droit sur la barre de titre sous Gnu/Linux) pour pouvoir
facilement travailler avec ce tuto.
Une simple variable
Comme on l'a vu dans le tuto précédent, et çà sera le point de départ de ce tuto consacré aux listes, l'élément de base de la mémorisation de données est
la variable : une « boite » en mémoire dans laquelle on met quelquechose et sur laquelle on colle une étiquette en y écrivant son nom :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 4 / 19
Un tableau, çà vous dit quelque chose ?
Un tableau, typiquement, est un « groupe » de variables qui sont rassemblées ensemble dans un même objet : l'intérêt essentiel réside dans le fait de
pouvoir accéder à chaque élément du tableau à l'aide d'un indice, ce qui permet de simplifier la gestion de plusieurs variables.
Typiquement, un tableau va avoir la structure interne suivante :
Le tableau a un nom, comme une variable : ici x. Chaque élément du tableau est accessible à partir de son indice sous la forme x[i]. Ici les ..
symbolisent des valeurs quelconques contenues dans les « cases » du tableau.
Déclaration d'un tableau
Ce que vous savez...
Vous avez probablement appris à déclarer un tableau dans un autre langage, tel que le C ou Arduino. Dans ces langages, typiquement, il faut préciser au
moment de la déclaration du tableau 2 choses :
•
le type des éléments du tableau
•
le nombre des éléments du tableau, ou le contenu du tableau, dont la taille est ensuite fixe.
Par exemple, en langage C, on ferait :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 5 / 19
En langage Python
Pas de tableau... des listes
En langage Python, les choses sont différentes et beaucoup plus souples : l'objet natif dédié pour créer un tableau est l'objet list. La list est un objet
conteneur qui va pouvoir stocker un ensemble d'objets d'un même type, voire même de types différents. En clair, une liste va pouvoir contenir plusieurs
variables, à la façon d'un tableau.
La grande force de l'objet list est sa souplesse : il n'est pas nécessaire de fixer la taille de la List à l'initialisation. Cette taille sera variable et il va être
possible d'ajouter, insérer, enlever des objets de la liste à volonté !
Initialisation d'une liste
En Python, list est une classe du langage, et pour créer un objet list, il va tout simplement falloir commencer par la déclarer, ce qui se fait sous la
forme :
>>> maListe=list()
Il est également possible de déclarer une liste en utilisant simplement 2 crochets :
>>> maListe=[]
ou encore en initialisant le contenu de la liste selon :
>>> maListe=[0,1,2,3]
Vérifions le contenu de notre liste en l'affichant :
>>> print maListe
[0, 1, 2, 3]
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 6 / 19
Nous pouvons aussi vérifier le type de notre objet list avec :
>>> type(maListe)
list
Ces présentations étant faites, nous allons pouvoir apprendre à utiliser notre liste.
L'objet list va vous faire entrer de plein pied dans les atouts du langage Python : les choses vont être simples, intuitives et spontanées pour manipuler les tableaux.
Simplification et puissance de codage au rendez-vous !
Initialiser une liste en fixant le nombre d'éléments
A noter que définir une liste en fixant le nombre d'éléments est possible : cela est possible en utilisant l'opération de « multiplication » appliquée à la
liste selon :
>>> maListe =[0]*10 # initialise une liste de 10 éléments
>>> print maListe
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Noter que l'on peut aussi initialiser la liste en utilisant le mot-clé None pour la valeur de l'élément selon :
>>> maListe = [None]*10
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 7 / 19
>>> print maListe
[None, None, None, None, None, None, None, None, None, None]
Utilisation de la liste
Connaître la taille d'une liste
Lorsque l'on utilise une liste, il est souvent nécessaire d'en connaître la taille, ce qui se fait avec la fonction native du langage Python len(objet), ce qui
donne :
>>> maListe=[0,1,2,3]
>>> print len(maListe)
4
Bien noter la différence avec d'autres langages où typiquement on accède à la taille d'un objet sous la forme objet.len() ou objet.length.
Accéder à un élément
Pour accéder à un élément de la liste, on le ferait comme pour un tableau, à l'aide de l'indice placé entre [ ]. Attention, le premier élément a l'indice 0.
Par exemple, pour accéder au premier élément de la liste on fera :
>>> print maListe[0]
0
Modifier un élément
Supposons que l'on veuille modifier la valeur du 2ème élément : on fera alors :
>>> maListe[1]=38
>>> print maListe[1]
38
>>> print maListe
[0, 38, 2, 3]
Le 2ème élément (indice = 1) a bien été modifié.
Ajouter un élément
C'est là le grand intérêt d'une liste, comparativement à un tableau : sa taille n'est pas figée et il est possible d'ajouter un élément très simplement à l'aide
de la fonction append() de la classe list, ce qui donne :
>>> maListe.append(255)
>>> print maListe
[0, 38, 2, 3, 255]
La valeur a bien été ajoutée à la fin de la liste.
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 8 / 19
Connaître la taille d'une liste
Pour connaître la taille d'une liste, on utilise l'instruction Python len() selon :
>>> len(maListe)
5
Effacer un élément
Pour effacer un élément d'une liste, on a 2 possibilités : soit utiliser l'instruction Python del :
>>> del maListe[4]
>>> print maListe
[0, 38, 2, 3]
soit utiliser la fonction pop() de la classe list selon :
>>> maListe.pop(1)
38
>>> print maListe
[0, 2, 3]
Noter que la fonction pop() renvoie la valeur de l'élément retiré.
Truc : pour enlever ler dernier élément d'une liste, on fera :
>>> maListe.pop(len(maListe)-1)
Insérer un élément
Pour insérer un élément, on fera insert(i,x) où x est la valeur et i l'emplacement (index= n-1 ème position ). Par exemple pour enregistrer la valeur 42
en 3ème position, on fera :
>>> maListe.insert(2,42)
>>> print maListe
[0, 2, 42, 3]
Noter que si i dépasse la taille de la liste, la valeur sera mise en dernière position.
Remarque : les opérations effectuées sur une liste modifient la liste elle-même, à la différence des str qui ne sont pas modifiés par les opérations
effectués dessus (le résultat est renvoyé sans modifier le str).
Toutes les fonctions de l'objet list : http://docs.python.org/2/tutorial/datastructures.html
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 9 / 19
L'objet tuple : une liste « figée »
Le langage Python dispose d'un autre objet qui s'apparente à une liste : l'objet tuple. La différence : un tuple est une liste mais à contenu fixe aussi bien
en taille qu'en contenu. La déclaration se fait à l'aide de parenthèse au lieu des []. Par exemple :
>>> t=(1,2,3)
>>> print t
(1, 2, 3)
On accède aux éléments de la même façon que pour une liste :
>>> print t[0]
1
Je vous présente ici l'objet tuple à titre purement informatif, car en pratique, çà sert peu je trouve. C'est potentiellement utile pour une liste de
constantes ou ce genre de choses. Pour plus de détail, voir au besoin :
http://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences
L'objet range : une liste pré-remplie
Une fonction Python de construction de liste plus intéressante et utile en pratique : la fonction range. Cette fonction renvoie un objet list pré-rempli
avec une valeur progressive. La déclaration se fait sous la forme :
range(stop)
range(start, stop[, step])
Par exemple, si on souhaite une série de valeur de 0 à 9 espacée de 1, on fera :
>>> x=range(10)
>>> print x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ou bien :
>>> x=range(0,10,1)
>>> print x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Retenez cette fonction : elle nous resservira lorsque nous aborderons la boucle for.
Vous pouvez vérifier que la fonction range() renvoie bien un objet list :
>>> type (x)
<type 'list'>
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 10 / 19
Défiler les éléments d'une list
Cela se fait à l'aide de la boucle for :
for item in myList :
print item
Un truc à connaître : comment connaître l'index de l'élément courant d'une list que l'on défile avec for... ??? La solution passe par la fonction
native enumerate (crée tuple (index,elem) pour chaque elem?) :
>>> ints=[12,13,14,15,16,17,18,19]
>>> for index, val in enumerate(ints):
...
print index, val
0 12
1 13
2 14
3 15
4 16
5 17
6 18
7 19
Voir : http://stackoverflow.com/questions/522563/accessing-the-index-in-python-for-loops
Extraire des éléments d'une liste à l'aide de la notation slice
Voici une des fonctionnalités les plus puissantes du langage Python : ce que l'on appelle le slicing, la possibilité de facilement extraire des éléments
d'une liste, d'une chaîne de caractères, etc...
Le principe est le suivant :
•
on utilise le : pour signifier les éléments quelconques
•
on utilise l'indice pour signifier un élément précis,
•
on place le tout entre [ ] après le nom de la chaîne.
Par exemple, soit la chaine :
>>> maListe=range(10)
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 11 / 19
>>> print maListe
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Pour extraire les caractères du début à l'indice 5, on fera :
>>> maListe[:5]
6: [0, 1, 2, 3, 4]
Pour extraire les caractères de l'indice 5 à la fin, on fera :
>>> maListe[5:]
7: [5, 6, 7, 8, 9]
Pour extraire les caractères de l'indice 3 à l'indice 7, on fera :
>>> maListe[3:7]
8: [3, 4, 5, 6]
Cool non ? Encore mieux : la même chose à l'envers... Par exemple, pour extraire les 2 derniers caractères d'une chaîne, on fera :
>>> maListe[-2:]
9: [8, 9]
Encore plus fort : extraire 1 élément sur 2 d'une chaine :
>>> maListe[::2]
10: [0, 2, 4, 6, 8]
Une petite dernière chose : pour effacer par exemple 1 élément sur 2 d'une liste, on fera :
>>> del maListe[::2]
>>> print maListe
[1, 3, 5, 7, 9]
Retenez bien ce système de notation car il vous servira souvent, aussi bien avec des listes, des chaînes de caractères que des tableau Numpy,
etc... Très pratique et puissant !
Pour plus de détails, voir :
http://docs.python.org/2/tutorial/introduction.html
http://docs.python.org/release/2.3.5/whatsnew/section-slices.html
Conversion d'objets en list et inversement
Pour convertir un str en list :
Si on fait :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 12 / 19
>>> chaine="1,2,3,4,5,6"
>>> list(chaine)
on a :
['1', ',', '2', ',', '3', ',', '4', ',', '5', ',', '6']
autrement dit, par défaut, on récupère une liste de tous les caractères unitaires, y compris ici le séparateur.
Si on souhaite récupérer une liste des éléments séparés par des ',' on utilisera plutôt la fonction split() de la classe str selon :
>>> chaine="1,2,3,4,5,6"
>>> chaine.split(",")
['1', '2', '3', '4', '5', '6']
C'est tout...
Mais on récupère une list de str, que l'on pourra caster en int avec :
>>> chaine="1,2,3,4,5,6"
>>> myList=chaine.split(",")
>>> myList
['1', '2', '3', '4', '5', '6']
>>> map(str,myList)
['1', '2', '3', '4', '5', '6']
>>> map(int,myList)
[1, 2, 3, 4, 5, 6]
ce qui donne en une seule ligne :
>>> chaine="1,2,3,4,5,6"
>>> map(int,chaine.split(","))
[1, 2, 3, 4, 5, 6]
Convertir un fichier en list de lignes
Dans le cas de la lecture d'un fichier texte, on récupérera un str multiligne et il sera intéressant dans ce cas de récupérer une list des lignes. On fera :
myFile=open(« chemin », 'r ')
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 13 / 19
myList=myFile.readlines()
myFile.close()
Convertir une list en str
Si on prend une list de valeurs, la caster en str donnera :
>>> myList=range(10)
>>> str(myList)
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
On obtient chaine str de la liste des valeurs séparées par , et encadrée par [ .. ]
Si on a une list de str, on utilisera la fonction join() en précisant le séparateur à utiliser
>>> myList=list("coucou")
>>> myList
['c', 'o', 'u', 'c', 'o', 'u']
>>> ":".join(myList)
'c:o:u:c:o:u'
Mais ceci ne fonctionne pas si on a une liste de valeurs numériques :
>>> myList=range(10)
>>> myList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ":".join(myList)
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
":".join(myList)
TypeError: sequence item 0: expected string, int found
Dans ce cas, on peut caster la list en str() et enlever les [ ] selon :
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 14 / 19
>>> myList=range(10)
>>> str(myList)
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
>>> str(myList)[1:-1]
'0, 1, 2, 3, 4, 5, 6, 7, 8, 9'
Par contre, si on a une list mixte avec des chaines et des valeurs, on pourra utiliser map() pour transformer en str tous les éléments de la list avant de les
joindre ensemble avec join() :
>>> myList=["13:23:43", 10.2, 16, 12.678]
>>> myList=map(str,myList)
>>> myList
['13:23:43', '10.2', '16', '12.678']
>>> ",".join(myList)
'13:23:43,10.2,16,12.678'
En une seule ligne, çà donnera :
>>> myList=["13:23:43", 10.2, 16, 12.678]
>>> ",".join(map(str,myList))
'13:23:43,10.2,16,12.678'
Ceci pourra être utile pour convertir une série de list en un fichier de ligne et inversement...
Voir www.decalage.info
Opérations sur list de list..
Soit une list de list
>>> lol=list()
>>> lol.append(range(0,10,1))
>>> lol.append(range(10,20,1))
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 15 / 19
>>> lol.append(range(20,30,1))
>>> lol.append(range(30,40,1))
>>> lol
13: [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]]
Si on souhaite accéder à un élément précis, on fera pour la 3ème ligne, 4ème colonne :
>>> lol[2][3]
23
Si maintenant, on veut accéder à une « ligne » entière, on fera :
lol[1]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
Maintenant, pour obtenir une colonne entière, je pensais pouvoir faire :
>>> lol[:][2]
16: [20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
donc cela ne marche pas... En fait, que se passe-t-il ? Ici lol[:] correspond en fait à lol (= toutes les listes de lol) et donc lol[:][2] renvoie comme
lol[2]...
La solution passe par la fonction zip().
>>> lol
13: [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]]
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 16 / 19
>>> zip(*lol)
19: [(0, 10, 20, 30),
(1, 11, 21, 31),
(2, 12, 22, 32),
(3, 13, 23, 33),
(4, 14, 24, 34),
(5, 15, 25, 35),
(6, 16, 26, 36),
(7, 17, 27, 37),
(8, 18, 28, 38),
(9, 19, 29, 39)]
Cette fonction renvoie donc une liste de tuples correspondant aux colonnes... On a donc la list de la colonne voulue avec :
list(zip(*lol)[2])
[2, 12, 22, 32]
*lol expands lol into a list of arguments. C'est équivalent à :
zip ((0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (10, 11, 12, 13, 14, 15, 16, 17, 18, 19), etc..)
c'est comme pour *arg => nombre indéfini d'éléments
A noter la forme permettant de coupler des éléments à partir des listes elles-mêmes :
>>> x
20: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> y
21: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> zip(x,y)
22: [(0, 10),
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 17 / 19
(1, 11),
(2, 12),
(3, 13),
(4, 14),
(5, 15),
(6, 16),
(7, 17),
(8, 18),
(9, 19)]
Autre alternative pour la même chose :
points=[(32, 166), (32, 168), (137, 238), (140, 238), (140, 236), (139, 227), (136, 209), (133, 198), (129, 184), (125, 174), (120, 164), (117, 159), (111,
150), (105, 143), (104, 142), (99, 138), (96, 136), (88, 132), (81, 130), (72, 130), (66, 131), (59, 133), (56, 134), (46, 139), (41, 143), (39, 145), (38,
147), (34, 159)]
x=list(xy[0] for xy in points)
print x
y=list(xy[1] for xy in points)
print y
Fusionner les éléments d'une liste de list en une seule liste :
>>> import itertools
>>> a=[[1,2,3],[4,5,6]]
>>> list(itertools.chain(*a))
0: [1, 2, 3, 4, 5, 6]
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 18 / 19
En fait, c'est possible de façon encore plus simple (« Python makes this ridiculously easy »)
listone = [1,2,3]
listtwo = [4,5,6]
maList=listone+listtwo
Création fonctionnelle de list (ou « list compréhension »)
[elem*2 for elem in range(10)]
Conclusion
Voilà, c'est tout ce qu'il y a à savoir sur les listes pour être opérationnel.
Ateliers Python + Interpréteur : Introduction aux listes – Par X. HINAULT – p. 19 / 19