Nous nous intéressons dans ce chapitre aux tableaux list qui sont des collections ordonnées de valeurs mutables.

Syntaxe

Les valeurs de la collection sont entourées par des crochets [], leurs éléments sont séparés par des virgules.

Les éléments d'une liste peuvent avoir des types différents.


Entrée
ma_liste = [ 1, 'deux' , 3]
type(ma_liste)
Résultat
list

Longueur et accés aux éléments

On peut facilement accéder à la longueur de la liste grace à la fonction len et à chacun de ces éléments grâce à leur index (Attention le premier élement à l'index 0)


Entrée
len(ma_liste)
Résultat
3

Entrée
ma_liste[0]
Résultat
1

Entrée
ma_liste[2]
Résultat
3

On peut inversement connaître l'indice correspondant à une valeur grâce à l'attribut index.


Entrée
ma_liste.index('deux')
Résultat
1

Ajout et suppression d'éléments

Comme les listes sont mutables, on peut ajouter des éléments à la liste à la fin avec la méthode append, ou à un indice quelconque avec la méthode insert.


Entrée
ma_liste.append(4)
ma_liste
Résultat
[1, 'deux', 3, 4]

Entrée
ma_liste.insert(0, 'zéro')
ma_liste
Résultat
['zéro', 1, 'deux', 3, 4]

On peut au contraire supprimer des éléments de la liste à la fin avec la méthode pop(), ou à un indice quelconque avec la méthode pop(indice).


Entrée
ma_liste.pop()
ma_liste
Résultat
['zéro', 1, 'deux', 3]

Entrée
ma_liste.pop(1)
ma_liste
Résultat
['zéro', 'deux', 3]

Itération sur les valeurs de la liste

On peut utiliser les index ou une méthode simplifiée implémentée dans Python.

Méthode simplifiée

On fait une itération des directe des valeurs du tableau.


Entrée
for e in ma_liste:
    print(e)
Sortie
zéro
deux
3

Itération avec l'index

C'est la méthode classique utilisée dans les langages impératifs.


Entrée
for i in range(len(ma_liste)):
    print("indice:", i, "valeur:", ma_liste[i])
Sortie
indice: 0 valeur: zéro
indice: 1 valeur: deux
indice: 2 valeur: 3

Tableau donné en compréhension

Plutôt que de remplir un tableau par énumération de ces éléments dans une boucle, on peut définir des listes en compréhension, c'est-à-dire des listes dont le contenu est défini par filtrage du contenu d'une autre liste.

Boucle classique

On commence par créer une liste vide, puis, on ajoute grâce à une boucle les éléments un à un à la liste grâce à la méthode append().

Voici par exemple comment créer une liste contenant les puissances de 2 de 212^1 à 2122^{12}.


Entrée
L = []
for i in range(13):
    L.append(2**i)
L
Résultat
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]

Ecriture en compréhension

Cette construction syntaxique offre des avantages de lisibilité et de concision et se rapproche de la notation utilisée en mathématiques :

S={2nnN,n<13}S=\{2^{n} | n\in {\mathbb{N}}, n<13\}
Entrée
L = [2**n for n in range(13)]
L
Résultat
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]

On peut même ajoter des conditions, exemple ici on crée une liste des puissance de 2 des puissance paires.


Entrée
L = [2**n for n in range(13) if n % 2 == 0]
L
Résultat
[1, 4, 16, 64, 256, 1024, 4096]
Syntaxe complète avec else

Il est possible d'utiliser une clause else dans les conditions grâce à l'opérateur ternaire: valeur_si_vrai if condition else valeur_si_faux

[f(x) if condition else g(x) for x in sequence]

Par exemple:

[str(i) + " est pair" if i % 2 == 0 else str(i) + " est impair" for i in range(5)]

renvoie: ['0 est pair', '1 est impair', '2 est pair', '3 est impair', '4 est pair']

Tableaux à deux dimensions: les matrices

Pour représenter un tableau de données, on peut utiliser une liste de liste.

(123246369)\begin{pmatrix} 1 & 2 & 3\\ 2 & 4 & 6\\ 3 & 6 & 9 \end{pmatrix}
Entrée
M = [[1, 2, 3],
     [2, 4, 6],
     [3, 6, 9]]
M
Résultat
[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

On accéde alors aux éléments en précisant l'index de ligne et le colonne: M[i ligne][i colonne].

Par exemple pour accéder au troisième élément de la première ligne.


Entrée
M[0][2]
Résultat
3

Accés au deuxième élément de la troisième ligne.


Entrée
M[2][1]
Résultat
6