Créons et éditons nos premières listes

Difficulté Facile
Note
Thématiques
Mis à jour le mardi 8 janvier 2013

D'abord c'est quoi, une liste ?

En Python, les listes sont des objets qui peuvent en contenir d'autres. Ce sont donc des séquences, comme les chaînes de caractères, mais au lieu de contenir des caractères, elles peuvent contenir n'importe quel objet. Comme d'habitude, on va s'occuper du concept des listes avant de voir tout son intérêt.

Création de listes

On a deux moyens de créer des listes. Si je vous dis que la classe d'une liste s'appelle, assez logiquement, list, vous devriez déjà voir une manière de créer une liste.

Non ? …

Vous allez vous habituer à cette syntaxe :

>>> ma_liste = list() # On crée une liste vide
>>> type(ma_liste)
<class 'list'>
>>> ma_liste
[]
>>>

Là encore, on utilise le nom de la classe comme une fonction pour instancier un objet de cette classe.

Quand vous affichez la liste, vous pouvez constater qu'elle est vide. Entre les crochets (qui sont les délimiteurs des listes en Python), il n'y a rien. On peut également utiliser ces crochets pour créer une liste.

>>> ma_liste = [] # On crée une liste vide
>>>

Cela revient au même, vous pouvez vérifier. Toutefois, on peut également créer une liste non vide, en lui indiquant directement à la création les objets qu'elle doit contenir.

>>> ma_liste = [1, 2, 3, 4, 5] # Une liste avec cinq objets
>>> print(ma_liste)
[1, 2, 3, 4, 5]
>>>

La liste que nous venons de créer compte cinq objets de type int. Ils sont classés par ordre croissant. Mais rien de tout cela n'est obligatoire.

  • Vous pouvez faire des listes de toute longueur.

  • Les listes peuvent contenir n'importe quel type d'objet.

  • Les objets dans une liste peuvent être mis dans un ordre quelconque. Toutefois, la structure d'une liste fait que chaque objet a sa place et que l'ordre compte.

>>> ma_liste = [1, 3.5, "une chaine", []]
>>>

Nous avons créé ici une liste contenant quatre objets de types différents : un entier, un flottant, une chaîne de caractères et… une autre liste.

Voyons à présent comment accéder aux éléments d'une liste :

>>> ma_liste = ['c', 'f', 'm']
>>> ma_liste[0] # On accède au premier élément de la liste
'c'
>>> ma_liste[2] # Troisième élément
'm'
>>> ma_liste[1] = 'Z' # On remplace 'f' par 'Z'
>>> ma_liste
['c', 'Z', 'm']
>>>

Comme vous pouvez le voir, on accède aux éléments d'une liste de la même façon qu'on accède aux caractères d'une chaîne de caractères : on indique entre crochets l'indice de l'élément qui nous intéresse.

Contrairement à la classe str, la classe list vous permet de remplacer un élément par un autre. Les listes sont en effet des types dits mutables.

Insérer des objets dans une liste

On dispose de plusieurs méthodes, définies dans la classe list, pour ajouter des éléments dans une liste.

Ajouter un élément à la fin de la liste

On utilise la méthode append pour ajouter un élément à la fin d'une liste.

>>> ma_liste = [1, 2, 3]
>>> ma_liste.append(56) # On ajoute 56 à la fin de la liste
>>> ma_liste
[1, 2, 3, 56]
>>>

C'est assez simple non ? On passe en paramètre de la méthode append l'objet que l'on souhaite ajouter à la fin de la liste.

Ceci est extrêmement important. Dans le chapitre précédent, nous avons vu qu'aucune des méthodes de chaînes ne modifie l'objet d'origine mais qu'elles renvoient toutes un nouvel objet, qui est la chaîne modifiée. Ici c'est le contraire : les méthodes de listes ne renvoient rien mais modifient l'objet d'origine. Regardez ce code si ce n'est pas bien clair :

>>> chaine1 = "une petite phrase"
>>> chaine2 = chaine1.upper() # On met en majuscules chaine1
>>> chaine1                   # On affiche la chaîne d'origine
'une petite phrase'
>>> # Elle n'a pas été modifiée par la méthode upper
... chaine2                   # On affiche chaine2
'UNE PETITE PHRASE'
>>> # C'est chaine2 qui contient la chaîne en majuscules
... # Voyons pour les listes à présent
... liste1 = [1, 5.5, 18]
>>> liste2 = liste1.append(-15) # On ajoute -15 à liste1
>>> liste1                      # On affiche liste1
[1, 5.5, 18, -15]
>>> # Cette fois, l'appel de la méthode a modifié l'objet d'origine (liste1)
... # Voyons ce que contient liste2
... liste2
>>> # Rien ? Vérifions avec print
... print(liste2)
None
>>>

Je vais expliquer les dernières lignes. Mais d'abord, il faut que vous fassiez bien la différence entre les méthodes de chaînes, où l'objet d'origine n'est jamais modifié et qui renvoient un nouvel objet, et les méthodes de listes, qui ne renvoient rien mais modifient l'objet d'origine.

J'ai dit que les méthodes de listes ne renvoient rien. On va pourtant essayer de « capturer » la valeur de retour dans liste2. Quand on essaye d'afficher la valeur de liste2 par saisie directe, on n'obtient rien. Il faut l'afficher avec print pour savoir ce qu'elle contient : None. C'est l'objet vide de Python. En réalité, quand une fonction ne renvoie rien, elle renvoie None. Vous retrouverez peut-être cette valeur de temps à autre, ne soyez donc pas surpris.

Insérer un élément dans la liste

Nous allons passer assez rapidement sur cette seconde méthode. On peut, très simplement, insérer un objet dans une liste, à l'endroit voulu. On utilise pour cela la méthode insert.

>>> ma_liste = ['a', 'b', 'd', 'e']
>>> ma_liste.insert(2, 'c') # On insère 'c' à l'indice 2
>>> print(ma_liste)
['a', 'b', 'c', 'd', 'e']

Quand on demande d'insérer c à l'indice 2, la méthode va décaler les objets d'indice supérieur ou égal à 2. c va donc s'intercaler entre b et d.

Concaténation de listes

On peut également agrandir des listes en les concaténant avec d'autres.

>>> ma_liste1 = [3, 4, 5]
>>> ma_liste2 = [8, 9, 10]
>>> ma_liste1.extend(ma_liste2) # On insère ma_liste2 à la fin de ma_liste1
>>> print(ma_liste1)
[3, 4, 5, 8, 9, 10]
>>> ma_liste1 = [3, 4, 5]
>>> ma_liste1 + ma_liste2
[3, 4, 5, 8, 9, 10]
>>> ma_liste1 += ma_liste2 # Identique à extend
>>> print(ma_liste1)
[3, 4, 5, 8, 9, 10]
>>>

Voici les différentes façons de concaténer des listes. Vous pouvez remarquer l'opérateur + qui concatène deux listes entre elles et renvoie le résultat. On peut utiliser += assez logiquement pour étendre une liste. Cette façon de faire revient au même qu'utiliser la méthode extend.

Suppression d'éléments d'une liste

Nous allons voir rapidement comment supprimer des éléments d'une liste, avant d'apprendre à les parcourir. Vous allez vite pouvoir constater que cela se fait assez simplement. Nous allons voir deux méthodes pour supprimer des éléments d'une liste :

  • le mot-clé del ;

  • la méthode remove.

Le mot-clé del

C'est un des mots-clés de Python, que j'aurais pu vous montrer plus tôt. Mais les applications de del me semblaient assez peu pratiques avant d'aborder les listes.

del (abréviation de delete) signifie « supprimer » en anglais. Son utilisation est des plus simple : del variable_a_supprimer. Voyons un exemple.

>>> variable = 34
>>> variable
34
>>> del variable
>>> variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'variable' is not defined
>>>

Comme vous le voyez, après l'utilisation de del, la variable n'existe plus. Python l'efface tout simplement. Mais on peut également utiliser del pour supprimer des éléments d'une séquence, comme une liste, et c'est ce qui nous intéresse ici.

>>> ma_liste = [-5, -2, 1, 4, 7, 10]
>>> del ma_liste[0] # On supprime le premier élément de la liste
>>> ma_liste
[-2, 1, 4, 7, 10]
>>> del ma_liste[2] # On supprime le troisième élément de la liste
>>> ma_liste
[-2, 1, 7, 10]
>>>

La méthode remove

On peut aussi supprimer des éléments de la liste grâce à la méthode remove qui prend en paramètre non pas l'indice de l'élément à supprimer, mais l'élément lui-même.

>>> ma_liste = [31, 32, 33, 34, 35]
>>> ma_liste.remove(32)
>>> ma_liste
[31, 33, 34, 35]
>>>

La méthode remove parcourt la liste et en retire l'élément que vous lui passez en paramètre. C'est une façon de faire un peu différente et vous appliquerez del ou remove en fonction de la situation.

Notez au passage que le mot-clé del n'est pas une méthode de liste. Il s'agit d'une fonctionnalité de Python qu'on retrouve dans la plupart des objets conteneurs, tels que les listes que nous venons de voir, ou les dictionnaires que nous verrons plus tard. D'ailleurs, del sert plus généralement à supprimer non seulement des éléments d'une séquence mais aussi, comme nous l'avons vu, des variables.

Nous allons à présent voir comment parcourir une liste, même si vous devez déjà avoir votre petite idée sur la question.

L'auteur