Chapitre 2 : Les tableaux (listes Python)¶

Programme officiel (B.O.)¶

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Tableau indexé, tableau donné en compréhension	Lire et modifier les éléments d'un tableau grâce à leurs index. Construire un tableau par compréhension. Utiliser des tableaux de tableaux pour représenter des matrices.	Seuls les tableaux dont les éléments sont du même type sont présentés. Aucune connaissance des mécanismes internes de l'allocation de mémoire n'est exigible.

1. Qu'est-ce qu'un tableau ?¶

1.1 Définition¶

Un tableau est une collection ordonnée et modifiable d'éléments du même type. En Python, on utilise le type list pour représenter les tableaux.

>>> notes = [15, 12, 18, 9, 14]
>>> prenoms = ["Alice", "Bob", "Charlie"]
>>> vide = []

Tableau vs Liste

En NSI, on parle de tableau (au sens informatique : éléments du même type, taille éventuellement fixe). En Python, le type list est plus souple qu'un vrai tableau (taille variable, types mélangés possibles), mais en Première on l'utilise comme un tableau : éléments du même type.

1.2 Différence avec les tuples¶

	Tuple	Tableau (liste)
Syntaxe	`(a, b, c)`	`[a, b, c]`
Modifiable	Non	Oui
Types mélangés	Oui	Non (en NSI)
Usage	Données constantes	Collections de données

2. Accéder aux éléments¶

2.1 Lecture par indice¶

Les indices commencent à 0 :

>>> notes = [15, 12, 18, 9, 14]
>>> notes[0]      # premier élément
15
>>> notes[2]      # troisième élément
18
>>> notes[-1]     # dernier élément
14
>>> notes[-2]     # avant-dernier
9

2.2 Modification par indice¶

Contrairement aux tuples, on peut modifier un élément :

>>> notes = [15, 12, 18, 9, 14]
>>> notes[3] = 11
>>> notes
[15, 12, 18, 11, 14]

2.3 Longueur¶

>>> len(notes)
5

2.4 Tranches (slicing)¶

On peut extraire une portion du tableau :

>>> notes = [15, 12, 18, 9, 14]
>>> notes[1:3]     # indices 1 et 2 (le 3 est exclu)
[12, 18]
>>> notes[:3]      # du début jusqu'à l'indice 2
[15, 12, 18]
>>> notes[2:]      # de l'indice 2 jusqu'à la fin
[18, 9, 14]

3. Parcourir un tableau¶

3.1 Parcours par élément¶

notes = [15, 12, 18, 9, 14]
for note in notes:
    print(note)

3.2 Parcours par indice¶

notes = [15, 12, 18, 9, 14]
for i in range(len(notes)):
    print(f"notes[{i}] = {notes[i]}")

3.3 Quand utiliser l'un ou l'autre ?¶

Situation	Parcours adapté
Lire les valeurs	Par élément (`for x in t`)
Modifier les valeurs	Par indice (`for i in range(len(t))`)
Comparer deux tableaux élément par élément	Par indice
Accéder à l'indice et à la valeur	`enumerate`

notes = [15, 12, 18, 9, 14]
for i, note in enumerate(notes):
    print(f"Note n°{i + 1} : {note}")

4. Opérations courantes¶

4.1 Ajouter et supprimer¶

>>> t = [1, 2, 3]
>>> t.append(4)        # ajouter à la fin
>>> t
[1, 2, 3, 4]

>>> t.insert(1, 10)    # insérer 10 à l'indice 1
>>> t
[1, 10, 2, 3, 4]

>>> t.pop()            # retirer le dernier
4
>>> t
[1, 10, 2, 3]

>>> t.pop(1)           # retirer l'élément d'indice 1
10
>>> t
[1, 2, 3]

>>> t.remove(2)        # retirer la première occurrence de 2
>>> t
[1, 3]

4.2 Autres opérations¶

>>> [1, 2] + [3, 4]          # concaténation
[1, 2, 3, 4]

>>> [0] * 5                  # répétition
[0, 0, 0, 0, 0]

>>> 3 in [1, 2, 3, 4]        # appartenance
True

>>> t = [3, 1, 4, 1, 5]
>>> t.sort()                  # tri en place
>>> t
[1, 1, 3, 4, 5]

>>> t.reverse()               # inversion en place
>>> t
[5, 4, 3, 1, 1]

>>> sorted([3, 1, 4])         # tri sans modifier l'original
[1, 3, 4]

5. Tableaux en compréhension¶

5.1 Principe¶

La compréhension de liste est une syntaxe compacte pour construire un tableau à partir d'une règle :

# Syntaxe : [expression for variable in itérable]

>>> carres = [x ** 2 for x in range(6)]
>>> carres
[0, 1, 4, 9, 16, 25]

C'est équivalent à :

carres = []
for x in range(6):
    carres.append(x ** 2)

5.2 Avec un filtre¶

On peut ajouter une condition avec if :

# Syntaxe : [expression for variable in itérable if condition]

>>> pairs = [x for x in range(10) if x % 2 == 0]
>>> pairs
[0, 2, 4, 6, 8]

>>> grands = [note for note in notes if note >= 14]
>>> grands
[15, 18, 14]

5.3 Exemples pratiques¶

# Table de multiplication par 7
>>> table7 = [7 * i for i in range(11)]
>>> table7
[0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70]

# Mettre en majuscules
>>> mots = ["bonjour", "python", "nsi"]
>>> majuscules = [m.upper() for m in mots]
>>> majuscules
['BONJOUR', 'PYTHON', 'NSI']

# Initiales d'une liste de prénoms
>>> prenoms = ["Alice", "Bob", "Charlie"]
>>> initiales = [p[0] for p in prenoms]
>>> initiales
['A', 'B', 'C']

6. Tableaux de tableaux (matrices)¶

6.1 Principe¶

Un tableau de tableaux permet de représenter une grille (ou matrice) à deux dimensions :

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

Cette matrice représente :

1  2  3
4  5  6
7  8  9

6.2 Accéder aux éléments¶

On utilise deux indices : matrice[ligne][colonne].

>>> matrice[0]         # première ligne
[1, 2, 3]

>>> matrice[0][2]      # ligne 0, colonne 2
3

>>> matrice[2][1]      # ligne 2, colonne 1
8

6.3 Parcourir une matrice¶

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

# Parcours avec double boucle
for i in range(len(matrice)):
    for j in range(len(matrice[i])):
        print(matrice[i][j], end=" ")
    print()

6.4 Créer une matrice par compréhension¶

# Matrice 3x4 remplie de 0
>>> zeros = [[0 for j in range(4)] for i in range(3)]
>>> zeros
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Piège classique

Ne jamais créer une matrice avec [[0] * 4] * 3. Les trois lignes seraient le même objet en mémoire, et modifier une case modifierait toutes les lignes :

>>> m = [[0] * 4] * 3
>>> m[0][0] = 5
>>> m
[[5, 0, 0, 0], [5, 0, 0, 0], [5, 0, 0, 0]]    # catastrophe !

Utiliser la compréhension [[0] * 4 for _ in range(3)] à la place.

6.5 Exemple : image en niveaux de gris¶

Une image en niveaux de gris peut se représenter comme une matrice de valeurs entre 0 (noir) et 255 (blanc) :

image = [
    [0,   0,   0,   0,   0],
    [0, 255, 255, 255,   0],
    [0, 255,   0, 255,   0],
    [0, 255, 255, 255,   0],
    [0,   0,   0,   0,   0]
]

# Négatif de l'image
negatif = [[255 - pixel for pixel in ligne] for ligne in image]

7. Copie de tableaux¶

7.1 Le piège de l'affectation¶

Affecter un tableau à une nouvelle variable ne crée pas de copie : les deux variables pointent vers le même objet en mémoire.

>>> a = [1, 2, 3]
>>> b = a              # b est un alias de a
>>> b[0] = 99
>>> a
[99, 2, 3]             # a est aussi modifié !

7.2 Faire une vraie copie¶

>>> a = [1, 2, 3]
>>> b = list(a)        # copie
>>> b = a[:]           # autre façon de copier
>>> b[0] = 99
>>> a
[1, 2, 3]              # a n'est pas modifié

Attention

Pour un tableau de tableaux (matrice), a[:] ne copie que le premier niveau. Pour une copie complète, utiliser le module copy :

import copy
copie = copy.deepcopy(matrice)

8. Résumé¶

Propriété	Tableau (`list`)
Syntaxe	`[a, b, c]`
Ordonné	Oui
Modifiable	Oui (mutable)
Accès	`t[i]`, `t[i:j]`
Ajout	`t.append(x)`, `t.insert(i, x)`
Suppression	`t.pop()`, `t.remove(x)`
Compréhension	`[expr for x in iterable if cond]`
Matrice	`m[i][j]` (tableau de tableaux)
Copie	`list(t)` ou `t[:]` (pas `b = a`)