Parcours de listes

Parcours de listes#

La boucle for permet de parcourir (list traversal), en accédant tour à tour à chacun de ses éléments:

liste = ['a', 'b', 'c', 'd']

for element in liste:
    print(element)

a
b
c
d

Chaque élément de liste a été affecté tour à tour à element, puis le bloc d’instruction a été exécuté déclenchant son affichage.

Dans l’exemple suivante, la fonction somme combine un parcours de liste avec un accumulateur (la variable somme) pour calculer la somme de tous les éléments de la liste passée en paramètre:

def somme(liste):
    somme = 0
    for i in liste:
        somme += i
    return somme

somme([1, 2, 3, 4, 5])

15

somme([0, -1, -2, -3, -4])

-10

somme([])

0

Exercice

Définissez les fonctions maximum et minimum qui renvoient respectivement le maximum et le minimum d’une liste d’entiers.

Indication

Utilisez un accumulateur, initialisé avec le premier élément de la liste, et mis à jour si nécessaire à chaque tour de boucle pour contenir la plus grande (respectivement petite) valeur rencontrée jusqu’à là.

def maximum(liste):
    ### BEGIN SOLUTION
    m = liste[0]
    for element in liste:
        if element > m:
            m = element
    return m
    ### END SOLUTION

# Tests
assert maximum([1, 2, 3, 4, 5]) == 5
assert maximum([-10, -5, -2, -3]) == -2
assert maximum([10]) == 10

def minimum(liste):
    ### BEGIN SOLUTION
    m = liste[0]
    for element in liste:
        if element < m:
            m = element
    return m
    ### END SOLUTION

# Tests pour la fonction minimum
assert minimum([1, 2, 3, 4, 5]) == 1
assert minimum([-10, -5, -2, -3]) == -10
assert minimum([10]) == 10

Parcours d’une liste par ses indices#

Dans les parcours de liste ci-dessus, il n’y avait besoin que d’accéder aux valeurs de ces éléments. Dans d’autre cas, il peut être nécessaire d’accéder non seulement aux valeurs des éléments, mais aussi à leurs indices: où sont ils positionnés dans la liste.

Pour cela, une première approche est de parcourir les indices de la liste avec la fonction range(), et d’accéder à la valeur de chacun de ses éléments par son indice.

Rappel : La fonction range()

La fonction range renvoie une séquence d’entiers. Elle est souvent utilisée dans les boucles pour répéter une action un certain nombre de fois. Elle peut-être utilisée sous trois formes :

  • range(fin) : génère une séquence d’entiers de 0 à fin exclu.

  • range(début, fin) : génère une séquence d’entiers de début à fin exclu.

  • range(début, fin, pas) : génère une séquence d’entiers de début à fin exclu, par pas de pas.

Considérons par exemple la liste suivante:

liste = [10, 6, 3, 9, 0]

La boucle for suivante affiche tous les éléments de la liste avec leurs indices:

for i in range(len(liste)): # pour i allant de 0 à 5 exclus (la taille de la liste)
    print("l'élément", liste[i], "est à l'indice", i) # On affiche l'élément liste[i] et l'indice i

l'élément 10 est à l'indice 0
l'élément 6 est à l'indice 1
l'élément 3 est à l'indice 2
l'élément 9 est à l'indice 3
l'élément 0 est à l'indice 4

Le parcours d’une liste par ses indices permet notamment de modifier en place certains éléments de la liste. Dans l’exemple suivant, toutes les valeurs inférieures à 10 d’une liste de notes sont remplacées par 10:

notes = [12, 5, 14, 7, 18, 6, 19]

for i in range(len(notes)):
    if notes[i] < 10:
        notes[i] = 10

notes

[12, 10, 14, 10, 18, 10, 19]

Le parcours d’une liste par ses indices permet aussi de comparer des éléments consécutifs. L’exemple suivant, part d’une liste de températures moyenne journalières, et affiche les jours où la température a baissé. Notez que l’indice commence à 1 pour pouvoir comparer les indices i et i-1.

temperatures = [20, 22, 21, 23, 25, 24, 26]

for i in range(1, len(temperatures)):
    if temperatures[i] < temperatures[i - 1]:
        print ("La température a baissé de", temperatures[i - 1], "à",  temperatures[i], "au jour", i)

La température a baissé de 22 à 21 au jour 2
La température a baissé de 25 à 24 au jour 5

Exercice

Définissez la fonction dernier_indice_maximum qui renvoie l’indice du maximum d’une liste. Si le maximum apparaît plusieurs fois dans la liste, on veut l’indice de sa dernière occurrence.

def dernier_indice_maximum(liste):
    ### BEGIN SOLUTION
    valeur_max = liste[0]
    indice_max = 0
    for i in range(len(liste)):
        if liste[i] >= valeur_max:
            valeur_max = liste[i]
            indice_max = i
    return indice_max
    ### END SOLUTION

assert dernier_indice_maximum([1, 2, 3, 4, 5]) == 4
assert dernier_indice_maximum([1, 5, 3, 5, 4]) == 3
assert dernier_indice_maximum([7, 7, 7, 7]) == 3
assert dernier_indice_maximum([10]) == 0

Parcours d’une liste avec enumerate#

La fonction enumerate fournit un idiome élégant pour parcourir simultanément les indices et les valeurs d’une liste. Étant donné une liste (ou plus généralement un conteneur ou un itérable), elle génère une séquence de paires (indice, valeur):

liste = ['a', 'b', 'c', 'd']

list(enumerate(liste))

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

On peut alors parcourir les indices et valeurs d’une liste comme suit:

for indice, valeur in enumerate(liste):
    print("la valeur", valeur, "est à l'indice", indice)

la valeur a est à l'indice 0
la valeur b est à l'indice 1
la valeur c est à l'indice 2
la valeur d est à l'indice 3

Avantages du parcours de liste avec enumerate

Le parcours d’une liste avec enumerate évite les accès indexés ainsi que les raisonnements sur le début ou la fin d’indices. Cela limite le risque d’erreur. Cela donne aussi de la généralité à l’idiome: il peut être utilisé sur des conteneurs ou itérables sans accès indexé ou dont l’on ne connaît pas à l’avance la taille.

Contenu