Chapitre 2: Tableaux

Nous nous intéressons dans ce chapitre aux tableaux qui sont implémentées en Python dans le type list. Tout comme les p-uplets, il s'agit de collections ordonnées de valeurs. cependant, à la différence de ces derniers, les listes sont mutables* ce qui les rend particulièrement pratique pour stocker des valeurs lors d'un boucle par exemple.

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.

ma_liste = [ 1, 'deux' , 3]
type(ma_liste)

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)

len(ma_liste)

3

ma_liste[0]

1

ma_liste[2]

3

On peut inversement connaître l'indice correspondant à une valeur grâce à la méthode index.

ma_liste.index('deux')

1

Ajout et suppression d'éléments

Comme les listes sont mutables, on peut:

• modifier des valeurs,

ma_liste[1] = 2.0
ma_liste

[1, 2.0, 3]

• ajouter des éléments à la liste à la fin avec la méthode append, ou à un indice quelconque avec la méthode insert.

ma_liste.append(4)
ma_liste

[1, 2.0, 3, 4]

ma_liste.insert(0, 'zéro')
ma_liste

['zéro', 1, 2.0, 3, 4]

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

ma_liste.pop()
ma_liste

['zéro', 1, 2.0, 3]

ma_liste.pop(1)
ma_liste

['zéro', 2.0, 3]

Itération sur une liste

On peut itérer sur les valeurs ou sur les index.

Itération sur les valeurs

On fait une itération des directe des valeurs du tableau en utilisant le mot-clé in.

for val in ma_liste:
    print(val)

zéro
2.0
3

Itération sur les index

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

for i in range(len(ma_liste)):
    val = ma_liste[i]
    print("indice:", i, "valeur:", val)

indice: 0 valeur: zéro
indice: 1 valeur: 2.0
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 $2^1$ à $2^{12}$.

L = []
for i in range(13):
    L.append(2**i)
L

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 :

L = [2**n for n in range(13)]
L

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

L = [2**n for n in range(13) if n % 2 == 0]
L

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

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

Tableaux à deux dimensions: les matrices

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

M = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]
M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Accés aux éléments

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.

M[0][2]

3

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

M[2][1]

8

Accés aux lignes et colonnes

L'accés à une ligne est aisé, par exemple pour la deuxième ligne.

M[1]

[4, 5, 6]

L'accés aux colonnes est plus délicat, on peut par exemple utiliser une liste en compréhension, par exemple pour accéder à la première colonne.

[ligne[0] for ligne in M]

[1, 4, 7]

Itérations sur les valeurs

Comme il s'agit d'une structure imbriquée, nous devons utiliser deux boucles imbriquées.

On peut par exemple itérer sur les valeurs des lignes.

for ligne in M:
    for val in ligne:
        print(val)

1
2
3
4
5
6
7
8
9