Les listes en python


Vieux tutoriel que j'avais réussi à faire publier sur le site du zér0. Je l'ai finalement supprimé pour le mettre ici.


Ce petit tutoriel vous montrera comment manipuler simplement les listes. Vous ne savez pas ce que c'est ? Ne vous inquiétez pas, je suis là pour ça.
Nous commencerons tout d'abord par étudier les listes, puis ensuite les méthodes.
Mais avant, je partirai du principe que vous ayez des pré-requis en langage python.


Dans cette partie, nous allons étudier les listes. N'ayez pas peur, c'est trop trop simple !
C'est quoi une liste alors ? Ca ressemble à quoi en python ?
Une liste, ça ressemble à ça :
Code : python
 
[0, 1, 2, 3, 4, 5]
 

Vous l'avez compris, une liste commence par un crochet [ et se termine par un crochet ]. Dans cette liste, nous avons des valeurs indexées. :)
Un exemple d'utilisation dans le shell de python :

>>> MaListe = [0,1,2,3,4,5] # On affecte notre liste a la variable 'MaListe'
>>> print MaListe # on affiche la liste
[0, 1, 2, 3, 4, 5]
>>>


On peut manipuler les listes très facilement. Mais patience, il ne faut pas mettre la charue avant les boeufs. Tout d'abord il faut apprendre à afficher un élément unique d'une liste.

On retourne sur le shell.

>>> MaListe = [0,1,2,3,4,5] # On affecte notre liste a la variable 'MaListe'
>>> print MaListe # on affiche la liste
[0, 1, 2, 3, 4, 5]
>>> print MaListe[0] # on affiche le premier element de la liste
0
>>>


Vous l'avez compris ? Maliste[n - 1] permet d'afficher le nième élément de cette liste. Par exemple, si vous voulez afficher le 5ème élément (qui, dans notre liste, est 4), vous devrez faire :

>>> print MaListe[4]
4
>>>


Sympathique, non ? On peut aussi mettre des nombres négatifs entre les crochets. Quoi, vous ne me croyez pas ? Et bien regardez. :-°

>>> print MaListe[-1] # on affiche le dernier element de la liste
5
>>>


Explications : le premier terme est MaListe[0]. Si on veut remonter la chaîne, on fait MaListe[-1]. Ok , mais il n'y a aucune valeur avant MaListe[0], alors on va en fin de chaîne. MaListe[-1] renvoie donc le dernier élément de la liste, qui est 5. MaListe[-2], lui, est équivalent à MaListe[4], il renvoie 4.

Je suppose que c'est un peu le bazard dans votre petite tête, alors éclaircissons tout cela. ^^

>>> UneNouvelleListe = ['a','b','c','d','e']
>>> UneNouvelleListe[3]
'd'
>>> UneNouvelleListe[1]
'b'
>>> UneNouvelleListe[-1]
'e'
>>> UneNouvelleListe[0]
'a'


Ca va mieux ? Continuons.

Modifier un élément dans une liste


C'est tout simple, ça se modifie comme les variables. Allons dans le shell.

>>> MaListe = ['f','g','h','i','j']
>>> MaListe
['f', 'g', 'h', 'i', 'j']
>>> MaListe[1] = 'z' # on modifie le deuxieme element dans la liste
>>> MaListe
['f','z','h','i','j']


Ajouter un élément dans une liste


Je sais comment faire, imaginons qu'on a 5 éléments, le 6ème que l'on veut rajouter sera MaListe[5]. Je dois faire MaListe[5] = 'valeur', facile ! :p


Eh bien... Faux.
Regardez la belle erreur que vous êtes susceptible de produire :

>>> MaListe[5] = 'valeur'
Traceback (most recent call last):
File "", line 1, in ?
IndexError: list assignment index out of range


Arf... En gros, ça dit quoi ?

Cela signifie que MaListe[5] n'existe pas dans la liste. Oui, il faut allouer de la place supplémentaire dans cette liste.

Mais moi je veux une liste dynamique :'( Comment je fais ?

Je m'appelle Geo, et j'ai la solution (ok je me la pète, mais les tutoriaux doivent égayer les lecteurs, non ?).
Il faut utiliser ce qu'on appelle une méthode, associée aux listes. Cette méthode s'appelle append().
Comment on se sert des méthodes ?

Quoi, vous ne savez pas ? o_O Oups, pardon, je suis là pour TOUT vous apprendre. :)
En python, on utilise une méthode comme ceci (ici, elle est associée à une liste) :
NomDeLaListe.NomDeLaMethode().

append(N)


La méthode append() permet d'ajouter l'élément 'N' en fin de liste
Petit exemple dans le shell :

>>> MaListe = [1,2,3,4,5]
>>> MaListe
[1, 2, 3, 4, 5]
>>> MaListe.append(6) # utilisation de la methode
>>> MaListe
[1, 2, 3, 4, 5, 6]


Magique !
Maintenant, voyons d'autres méthodes associées aux listes.

extend(L)


La méthode extend() permet d'ajouter les éléments d'une liste 'L' à la liste à laquelle la méthode est appliquée.
Exemple :

>>> PremiereListe = [1,2,3]
>>> SecondeListe = [4,5,6]
>>> PremiereListe.extend(SecondeListe)
>>> PremiereListe
[1, 2, 3, 4, 5, 6]


insert(pos, e)


Cette méthode permet d'insérer un élément 'e' à une position 'pos' donnée.
Exemple :

>>> MaListe = [1,2,4,5,6]
>>> MaListe.insert(0,0) # on ajoute 0 au debut de la liste
>>> MaListe
[0, 1, 2, 4, 5, 6]
>>> MaListe.insert(3,3) # pareil pour le numero 3
>>> MaListe
[0, 1, 2, 3, 4, 5, 6]


remove(e)


Cette méthode permet de supprimer le premier élément de la liste (donc en partant de 0) dont la valeur est 'e'.
Exemple :

>>> MaListe = [1,2,4,5,6]
>>> MaListe.remove(1)
>>> MaListe
[2, 3, 4, 5, 6]
>>> MaListe.remove(4)
>>> MaListe
[2, 3, 5, 6]

Attention, si vous essayez de supprimer un élément qui n'existe pas, une erreur de type 'x not in list' vous sera renvoyée.

pop(i)


Cette méthode vous permet de retirer l'élément figurant à l'index 'i' d'une liste et de le retourner.
Exemple :

>>> MaListe = ['a','b','c']
>>> MaListe.pop(1) # on retire le second element
'b'
>>> MaListe
['a', 'c']


index(e)


Renvoie l'index du premier élément dont la valeur est 'e'. Si la valeur ne figure pas dans la liste, une erreur est renvoyée.
Exemple :

>>> MaListe = ['a','b','c']
>>> MaListe.index('c') # on demande l'index de la valeur 'c'
2


count(e)


Cette méthode vous renvoie le nombre d'occurences de la valeur 'e'.
Exemple :

>>> MaListe = ['a','b','c','d','a']
>>> MaListe.count('b')
1
>>> MaListe.count('a')
2
>>> MaListe.count('e')
0


reverse()


Cette méthode vous permet d'inverser une liste.

>>> MaListe = [0,1,2,3,4,5]
>>> MaListe.reverse()
>>> MaListe
[5, 4, 4, 2, 1, 0]


Voila, nous connaissons les méthodes principales pour manipuler les listes en python.


La puissance des listes


Dans cette sous-partie, je vais vous montrer que les listes permettent de faire beaucoup de choses. Dans la première partie, nous avons appris les bases de manipulation de listes. Maintenant, il est temps d'énumérer les autres possibilités.

Une liste, ça contient des éléments. Nous avons inséré des nombres, mais nous pouvons insérer n'importe quoi, par exemple des lettres, des chaînes, etc...

>>> liste = ['a','b','c','d','e']

>>> liste[0]

'a'

>>> liste = ['je','suis','un','zéro']

>>> liste[-1]

'z\x82ro'

Si le shell affiche 'z\x82ro' en réponse, c'est parce que le 'é' à été converti en hexadécimal. Rassurez-vous, il suffit de faire une simple source pour afficher un 'é' comme ceci :

print "Je suis un z\x82ro"
[/console]
Ce qui affichera en console :

Je suis un zéro

Bref, passons.


Nous pouvons aussi retourner plusieurs éléments d'une liste simultanément !

>>> liste = ['a','b','c','d','e',1,2,3,4,5]
>>> liste[0:2] # on part de l'index '0' jusqu'au deuxième élément (qui a l'index '1')
['a', 'b']
>>> liste[1:3] # on part de l'index '1' jusqu'au troisième élément (qui a l'index '2')
['b', 'c']
>>> liste[2:3] # on part de l'index '2' jusqu'au troisième élément (qui a l'index 2)
['c']
>>> liste[1:] # on part de l'index 1, jusqu'à la fin
['b', 'c', 'd', 'e', 1, 2, 3, 4, 5]
>>> liste[-2:] # on part de l'index -2 jusqu'à la fin
[4, 5]
>>> liste[:-2] # on part du début jusqu'au -2 index de la liste
['a', 'b', 'c', 'd', 'e', 1, 2, 3]


En résumé


Pour afficher plusieurs éléments simultanés dans une liste, on aura :
liste[debut:fin]
Où début/fin sont optionnels, mais il faut au moins un argument (le début ou la fin) entre crochets.

Voici un petit code d'exemple qui va lister chaque élément d'une liste.
Code : python
 
# on cree notre liste
liste = ["a","b","c","d","e","f","g"]
# on affiche tous les elements
for i in liste:
       print i
 


Ce qui donne :


a
b
c
d
e
f
g


C'est un exemple comme un autre. Après, il faut bien évidemment de la pratique pour se familiariser avec tout cela.


Voilà, maintenant vous savez manipuler les listes très facilement.
J'espère de tout cœur (comme toujours) que ce tutoriel vous a été utile.
Après, vous pouvez apprendre à faire la même chose avec les dictionnaires, qui sait.

Geo