Maîtriser les listes Python : bases expliquées

Introduction

Cette section présente les listes, le type principal de Python pour stocker une collection ordonnée de valeurs.

Création d'une liste

Utilisez des crochets pour définir un littéral de liste :

names = [ 'Elwood', 'Jake', 'Curtis' ]
nums = [ 39, 38, 42, 65, 111]

Parfois, les listes sont créées par d'autres méthodes. Par exemple, une chaîne de caractères peut être divisée en une liste en utilisant la méthode split() :

>>> line = 'GOOG,100,490.10'
>>> row = line.split(',')
>>> row
['GOOG', '100', '490.10']
>>>

Opérations sur les listes

Les listes peuvent contenir des éléments de tout type. Ajoutez un nouvel élément en utilisant append() :

names.append('Murphy')    ## Ajoute à la fin
names.insert(2, 'Aretha') ## Insère au milieu

Utilisez + pour concaténer des listes :

s = [1, 2, 3]
t = ['a', 'b']
s + t           ## [1, 2, 3, 'a', 'b']

Les listes sont indexées par des entiers. En commençant par 0.

names = [ 'Elwood', 'Jake', 'Curtis' ]

names[0]  ## 'Elwood'
names[1]  ## 'Jake'
names[2]  ## 'Curtis'

Les indices négatifs comptent à partir de la fin.

names[-1] ## 'Curtis'

Vous pouvez modifier n'importe quel élément d'une liste.

names[1] = 'Joliet Jake'
names                     ## [ 'Elwood', 'Joliet Jake', 'Curtis' ]

Longueur de la liste.

names = ['Elwood','Jake','Curtis']
len(names)  ## 3

Test d'appartenance (in, not in).

'Elwood' in names       ## True
'Britney' not in names  ## True

Réplication (s * n).

s = [1, 2, 3]
s * 3   ## [1, 2, 3, 1, 2, 3, 1, 2, 3]

Itération et recherche dans une liste

Utilisez for pour itérer sur le contenu de la liste.

for name in names:
    ## utilisez name
    ## par exemple, print(name)
  ...

Cela est similaire à une instruction foreach d'autres langages de programmation.

Pour trouver rapidement la position d'un élément, utilisez index().

names = ['Elwood','Jake','Curtis']
names.index('Curtis')   ## 2

Si l'élément est présent plus d'une fois, index() renverra l'index de la première occurrence.

Si l'élément n'est pas trouvé, une exception ValueError sera levée.

Suppression d'éléments dans une liste

Vous pouvez supprimer des éléments soit par valeur d'élément, soit par index :

## En utilisant la valeur
names.remove('Curtis')

## En utilisant l'index
del names[1]

Supprimer un élément ne crée pas de trou. Les autres éléments se déplaceront vers le haut pour combler l'espace laissé vacant. Si l'élément apparaît plus d'une fois, remove() ne supprimera que la première occurrence.

Tri d'une liste

Les listes peuvent être triées "en place".

s = [10, 1, 7, 3]
s.sort()                    ## [1, 3, 7, 10]

## Tri dans l'ordre inverse
s = [10, 1, 7, 3]
s.sort(reverse=True)        ## [10, 7, 3, 1]

## Cela fonctionne avec n'importe quel type de données ordonnée
s = ['foo', 'bar','spam']
s.sort()                    ## ['bar', 'foo','spam']

Utilisez sorted() si vous préférez créer une nouvelle liste :

t = sorted(s)               ## s est inchangé, t contient les valeurs triées

Listes et mathématiques

Attention : Les listes ne sont pas conçues pour les opérations mathématiques.

>>> nums = [1, 2, 3, 4, 5]
>>> nums * 2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> nums + [10, 11, 12, 13, 14]
[1, 2, 3, 4, 5, 10, 11, 12, 13, 14]

Plus précisément, les listes ne représentent pas des vecteurs/matrices comme dans MATLAB, Octave, R, etc. Cependant, il existe des packages pour vous aider dans ce domaine (par exemple, numpy).

Dans cet exercice, nous expérimentons le type de données liste de Python. Dans la dernière section, vous avez travaillé avec des chaînes de caractères contenant des symboles d'actions.

>>> symbols = 'HPQ,AAPL,IBM,MSFT,YHOO,DOA,GOOG'

Divisez-la en une liste de noms en utilisant l'opération split() des chaînes de caractères :

>>> symlist = symbols.split(',')

Exercice 1.19 : Extraction et réaffectation d'éléments de liste

Essayez quelques consultations :

>>> symlist[0]
'HPQ'
>>> symlist[1]
'AAPL'
>>> symlist[-1]
'GOOG'
>>> symlist[-2]
'DOA'
>>>

Essayez de réaffecter une valeur :

>>> symlist[2] = 'AIG'
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'DOA', 'GOOG']
>>>

Prenez quelques tranches :

>>> symlist[0:3]
['HPQ', 'AAPL', 'AIG']
>>> symlist[-2:]
['DOA', 'GOOG']
>>>

Créez une liste vide et ajoutez un élément à celle-ci.

>>> mysyms = []
>>> mysyms.append('GOOG')
>>> mysyms
['GOOG']

Vous pouvez réaffecter une partie d'une liste à une autre liste. Par exemple :

>>> symlist[-2:] = mysyms
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG']
>>>

Lorsque vous faites cela, la liste du côté gauche (symlist) sera redimensionnée en conséquence pour adapter la liste du côté droit (mysyms). Par exemple, dans l'exemple ci-dessus, les deux derniers éléments de symlist ont été remplacés par l'unique élément de la liste mysyms.

Exercice 1.20 : Boucler sur les éléments d'une liste

La boucle for fonctionne en parcourant les données d'une séquence telle qu'une liste. Vérifiez cela en tapant la boucle suivante et en observant ce qui se passe :

>>> for s in symlist:
        print('s =', s)
## Regardez la sortie

Exercice 1.21 : Tests d'appartenance

Utilisez l'opérateur in ou not in pour vérifier si 'AIG', 'AA' et 'CAT' sont dans la liste de symboles.

>>> ## Est-ce que 'AIG' EST DANS `symlist`?
True
>>> ## Est-ce que 'AA' EST DANS `symlist`?
False
>>> ## Est-ce que 'CAT' N'EST PAS DANS `symlist`?
True
>>>

✨ Vérifier la solution et pratiquer

Exercice 1.22 : Ajout, insertion et suppression d'éléments

Utilisez la méthode append() pour ajouter le symbole 'RHT' à la fin de symlist.

>>> symlist.append('RHT') ## ajoute 'RHT'
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']
>>>

Utilisez la méthode insert() pour insérer le symbole 'AA' comme deuxième élément de la liste.

>>> symlist.insert(1, 'AA') ## Insère 'AA' comme deuxième élément de la liste
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']
>>>

Utilisez la méthode remove() pour supprimer 'MSFT' de la liste.

>>> symlist.remove('MSFT') ## Supprime 'MSFT'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT']
>>>

Ajoutez une entrée dupliquée pour 'YHOO' à la fin de la liste.

Nota : Il est tout à fait normal qu'une liste contienne des valeurs dupliquées.

>>> symlist.append('YHOO') ## Ajoute 'YHOO'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT', 'YHOO']
>>>

Utilisez la méthode index() pour trouver la première position de 'YHOO' dans la liste.

>>> symlist.index('YHOO') ## Trouve le premier indice de 'YHOO'
4
>>> symlist[4]
'YHOO'
>>>

Comptez combien de fois 'YHOO' est dans la liste :

>>> symlist.count('YHOO')
2
>>>

Supprimez la première occurrence de 'YHOO'.

>>> symlist.remove('YHOO') ## Supprime la première occurrence de 'YHOO'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'GOOG', 'RHT', 'YHOO']
>>>

Pour que vous le sachiez, il n'y a pas de méthode pour trouver ou supprimer toutes les occurrences d'un élément. Cependant, nous verrons une manière élégante de le faire dans la section 2.

Exercice 1.23 : Tri

Voulez trier une liste? Utilisez la méthode sort(). Essayez :

>>> symlist.sort()
>>> symlist
['AA', 'AAPL', 'AIG', 'GOOG', 'HPQ', 'RHT', 'YHOO']
>>>

Voulez trier dans l'ordre inverse? Essayez ceci :

>>> symlist.sort(reverse=True)
>>> symlist
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']
>>>

Note : Trier une liste modifie son contenu "en place". C'est-à-dire que les éléments de la liste sont réorganisés, mais aucun nouvelle liste n'est créée à la suite.

Exercice 1.24 : Remettre tout en place

Voulez prendre une liste de chaînes de caractères et les joindre pour former une seule chaîne? Utilisez la méthode join() des chaînes de caractères comme ceci (note : cela semble étrange au premier abord).

>>> a = ','.join(symlist)
>>> a
'YHOO,RHT,HPQ,GOOG,AIG,AAPL,AA'
>>> b = ':'.join(symlist)
>>> b
'YHOO:RHT:HPQ:GOOG:AIG:AAPL:AA'
>>> c = ''.join(symlist)
>>> c
'YHOORHTHPQGOOGAIGAAPLAA'
>>>

Exercice 1.25 : Listes de tout

Les listes peuvent contenir n'importe quel type d'objet, y compris d'autres listes (par exemple, des listes imbriquées). Essayez :

>>> nums = [101, 102, 103]
>>> items = ['spam', symlist, nums]
>>> items
['spam', ['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'], [101, 102, 103]]

Prenez soin de bien examiner la sortie ci-dessus. items est une liste avec trois éléments. Le premier élément est une chaîne de caractères, mais les deux autres éléments sont des listes.

Vous pouvez accéder aux éléments des listes imbriquées en utilisant plusieurs opérations d'indexation.

>>> items[0]
'spam'
>>> items[0][0]
's'
>>> items[1]
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']
>>> items[1][1]
'RHT'
>>> items[1][1][2]
'T'
>>> items[2]
[101, 102, 103]
>>> items[2][1]
102
>>>

Même si techniquement il est possible de créer des structures de liste très complexes, en règle générale, il est préférable de garder les choses simples. Habituellement, les listes contiennent des éléments de la même sorte de valeur. Par exemple, une liste composée entièrement de nombres ou une liste de chaînes de caractères. Mélanger différents types de données dans la même liste est souvent un bon moyen de vous faire exploser la tête, il est donc préférable de l'éviter.

Sommaire

Félicitations! Vous avez terminé le laboratoire sur les listes. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.

Présentation des bases des listes Python