Vidéo 24 : Parcours de liste

\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\)

Vidéo 24 : Parcours de liste

Parcours complet d’une liste par indices

Comme on peut accéder à chaque élément d’une liste de \(n\) éléments par son indice \(i\) avec \(0\leq i < n\), un usage très fréquent de la boucle for est le parcours d’une liste par ses indices.

Par exemple, soit une liste de nombres, comme t = [65, 31, 9, 32, 81, 82, 46, 12]. On cherche à afficher le produit \(\mathtt{10\times x}\) pour chaque terme \(\mathtt{x}\) de la liste :

1
2
3
4
t = [65, 31, 9, 32, 81, 82, 46, 12]

for i in range(8):
    print(10 * t[i])

 5
 6
 7
 8
 9
10
11
12
650
310
90
320
810
820
460
120
  • Ligne 1: t contient 8 éléments donc pour parcourir t avec un indice i, on utilise l’en-tête for i in range(8)
  • Ligne 4 : t[i] permet d’accéder à l’élément courant de t.

Code amélioré

Pour une meilleure lisibilité et une meilleure maintenance, un des deux codes ci-dessous est nettement préférable au code précédent :

1
2
3
4
5
t = [65, 31, 9, 32, 81, 82, 46, 12]
n = len(t)

for i in range(n):
    print(10 * t[i])

et

1
2
3
4
t = [65, 31, 9, 32, 81, 82, 46, 12]

for i in range(len(t)):
    print(10 * t[i])
  • Ligne 2 ou ligne 8 : la longueur de t n’est pas écrite littéralement : si dans le code ligne 1, on modifie t en rajoutant un élément, le code en-dessous n’a pas besoin d’être modifié.

Parcours de liste : indices voisins de l’indice courant

L’avantage de parcourir une liste via ses indices est que l’on peut accéder à l’indice suivant ou l’indice précédent. Par exemple, soit à afficher toutes les sommes de deux termes successifs de la liste t = [65, 31, 9, 32, 81, 82, 46, 12], à savoir les sommes suivantes :

96, 40, 41, etc.

L’algorithme de base consiste à parcourir t jusqu’à son avant-dernier terme, et à afficher \(x+y\) où \(x\) est le terme courant de t et \(y\) le terme suivant dans t :

1
2
3
4
5
t = [65, 31, 9, 32, 81, 82, 46, 12]
n= len(t)

for i in range(n-1):
    print(t[i] + t[i+1])

 6
 7
 8
 9
10
11
12
96
40
41
113
163
128
58
  • Ligne 4 : Le choix de (n-1) se justifie par le fait que le parcours de t s’arrête à l’avant-dernier terme de t puisqu’il faut à chaque étape du parcours considérer le terme suivant.
  • Ligne 5 : t[i+1] est le terme suivant du terme courant, ce qui suppose que \(i+1<n\) et donc que \(i< n-1\)
  • Ligne 4 : écrire range(n) au lieu de range(n-1) entraînerait une erreur (un débordement d’indice) lorsque \(i=n-1\) et que l’interpréteur calcule t[i+1].

Boucle for et calcul de maximum

La technique de la « variable accumulatrice » peut s’adapter au calcul du plus grand élément des termes d’une liste :

1
2
3
4
5
6
7
8
9
L = [10, 3, 12, 5]
maxi = L[0]
n = len(L)

for i in range(1, n):
    if L[i] > maxi:
        maxi = L[i]

print(maxi)

10
12
  • Ligne 1 : on observe que le plus grand élément de L est 12.
  • Ligne 2 : variable initialisée au premier terme de la liste et qui, en fin de programme, contiendra le maximum la liste L.
  • Lignes 5-7 : la liste est parcourue et à la fin de chaque itération, maxi est le plus grand de tous les termes examinés.
  • Ligne 5 : le range commence à 1 car comme maxi est initialisé à L[0], il est inutile d’effectuer la comparaison pour i = 0 puisque L[0] > maxi (cf. ligne 6) autrement dit L[0] > L[0] vaut False.

Même si ce n’est pas formellement interdit, on évitera d’appeler max la variable accumulatrice du maximum car cela empêcherait d’utiliser la fonction Python native nommé max. De même on évitera le nom min pour un minimum.

Il aurait été possible de ne pas utiliser d’indice pour parcourir la liste :

1
2
3
4
5
6
7
8
9
L = [10, 3, 12, 5]
maxi = L[0]
n = len(L)

for z in L:
    if z > maxi:
        maxi = z

print(maxi)

Le seul inconvénient est que le premier passage dans l’instruction if compare maxi avec lui-même.