Parcourir une liste#

Pour afficher séparémment chaque élément d’une liste, on peut utiliser une boucle. Dans une liste de \(n\) éléments, les éléments sont indexés de la position 0 à la position \(n-1\). Il faut donc créer une variable qui prendra les valeurs de 0 (inclus) à \(n\) (non-inclus). Pour accéder à la longueur de la liste, et donc connaître \(n\), nous pouvons utiliser la fonction len.

voyelles = ['a', 'e', 'i', 'o', 'u', 'y']

for i in range(len(voyelles)):
    print(voyelles[i])

a
e
i
o
u
y

Il est également possible de parcourir une liste de la façon suivante :

voyelles = ['a', 'e', 'i', 'o', 'u', 'y']

for voyelle in voyelles:
    print(voyelle)

a
e
i
o
u
y

Cette façon de parcourir la liste est plus intuitive et plus lisible. Toutefois, il ne sera pas toujours possible d’utiliser cette 2ème méthode, notamment lorsqu’on aura besoin d’effectuer des manipulations sur la liste qui nécessite de connaître la position de l’élément au sein de la liste, comme le tri d’une liste par exemple.

Compteur#

Dans cette section, nous ne considérerons que des listes composées uniquement de chiffres entiers. Maintenant que nous sommes capables de parcourir la liste, nous allons pouvoir réaliser des scripts permettant de calculer la somme des éléments, de trouver le minimum et le maximum, etc.

Pour calculer la somme d’une liste, nous devons commencer par initialiser une variable somme=0. Ensuite, nous allons parcourir chaque élément de la liste à l’aide d’une boucle for et ajouter successivement chacun de ces chiffres à la somme.

Pour implémenter un compteur, la logique est très semblable. Comme précédemment, nous initialisons une variable compteur à 0 et ensuite, nous augmentons la valeur du compteur à chaque élément.

a = [1, 2, 3, 4, 5]
compteur = 0
for i in range(len(a)):
    compteur = compteur + 1

print(compteur)

5

Ce script n’est pas très utile car il renvoie la même information que la longueur de la liste. Par contre, nous pouvons légèrement modifier ce script de manière à compter uniquement les chiffres qui respectent une certaine condition. Par exemple, pour compter le nombre de chiffres pairs (ou impairs) d’une liste, nous pouvons écrire:

a = [1, 2, 3, 4, 5]
nb_pairs = 0
nb_impairs = 0
for i in range(len(a)):
    if a[i] % 2 == 0:
        nb_pairs = nb_pairs + 1 
    else:
        nb_impairs = nb_impairs + 1 

print("Nombres pairs :", nb_pairs)
print("Nombres impairs :", nb_impairs)

Nombres pairs : 2
Nombres impairs : 3

Pour calculer le minimum d’une liste, nous allons initialiser une variable minimum. Cependant, nous ne pouvons pas lui donner une valeur telle que 0 car ce chiffre n’est peut-être pas dans la liste. C’est d’ailleurs le cas dans notre exemple. Nous allons donc considérer que, dans un premier temps, le minimum sera égal au premier chiffre de la liste. Ensuite, nous parcourons l’entièreté de la liste et nous testons si le chiffre en question est plus petit que le minimum actuel. Si oui, nous effectuons le remplacement (et nous avons une nouvelle valeur pour le minimum).

a = [8, 2, 5, 3, 4]
minimum = a[0]
for i in range(len(a)):
    if a[i] < minimum:
        minimum = a[i]

print("Minimum:", minimum)

Minimum: 2

Double boucle#

Nous avons également vu dans le chapitre précédent qu’une liste pouvait contenir d’autres listes. Cette structure s’apparente au concept mathématique de matrices. Nous allons créer une matrice (3x3) qui contient les chiffres de 1 à 9.

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

Si nous souhaitons afficher chaque élément de manière séparée, il faudrait écrire 9 instructions print.

print(matrice[0][0])
print(matrice[0][1])
print(matrice[0][2])
#------------------#
print(matrice[1][0])
print(matrice[1][1])
print(matrice[1][2])
#------------------#
print(matrice[2][0])
print(matrice[2][1])
print(matrice[2][2])

1
2
3
4
5
6
7
8
9

A l’aide de ce qui vient d’être vu précédemment, on pourrait obtenir le même résulat à l’aide d’une instruction for. Vous pouvez remarquer que 3 blocs ont été séparés à l’aide de #—#. Bien que ça n’ait aucun effet sur le code, étant donné que c’est un commentaire, cela permet de constater que la seule différence entre ces trois blocs est la valeur du chiffre dans le premier crochet. Nous pouvons donc écrire:

for i in range(3):
    print(matrice[i][0])
    print(matrice[i][1])
    print(matrice[i][2])

1
2
3
4
5
6
7
8
9

Mais ce n’est pas tout ! En effet, on constate maintenant (même si on aurait déjà pu le constater plus tôt) que les instructions au sein de la boucle for sont similaires, à l’exception près du chiffre qui se trouve cette fois-ci dans le deuxième crochet. Nous allons donc pouvoir écrire une 2ème boucle au sein de la première. Nous utiliserons la lettre j.

for i in range(3):
    for j in range(3):
        print(matrice[i][j])

1
2
3
4
5
6
7
8
9

Top ! On est passé de 9 lignes de codes à 3 lignes, tout ça pour obtenir le même résultat. Pour obtenir un output plus qualitatif et avoir un affichage qui s’apparente à celui d’une matrice, il conviendrait maintenant d’afficher 3 chiffres, puis de passer à la ligne, d’afficher les 3 chiffres suivants, et ainsi de suite. Rappelez-vous que par défaut, l’instruction print passe à la ligne, mais qu’il est possible de changer de comportement par défault en indiquant end=… et ce que l’on souhaite voir afficher après avoir affiché les différents éléments du print. Si nous décidons “d’afficher” une tabulation, obtenu à l’aide de \t après chaque chiffre, ceci devient:

for i in range(3):
    for j in range(3):
        print(matrice[i][j], end="\t")

1	2	3	4	5	6	7	8	9	

On constate maintenant que tous les chiffres sont affichés sur la même ligne. Il ne reste plus qu’à “afficher” un retour à la ligne à chaque fois que 3 chiffres ont été affichés. Ceci revient à afficher un retour à la ligne une fois que la boucle intérieure (celle avec la variable j) est terminée.

for i in range(3):
    for j in range(3):
        print(matrice[i][j], end="\t")
    print("")

1	2	3	
4	5	6	
7	8	9	

Break#

L’instruction break permet de stopper une boucle, si une condition particulière est rencontrée.

for i in range(1, 10):
    print(i)
    if i == 5:
        break

1
2
3
4
5

Notez que si l’instruction break se situe avant l’instruction print, alors le résultat n’est pas tout à fait le même.

for i in range(1, 10):
    if i == 5:
        break
    print(i)

1
2
3
4

Continue#

L’instruction continue permet de continuer la boucle tout en passant une itération particulière. Supposons qu’on souhaite diviser 10 par tous les chiffres compris entre -5 et 5. Nous savons qu’une division par 0 entraînera une erreur. Il faut donc passer cette itération.

for i in range(-5, 6):
    if i == 0:
        print('Pas de division par zero')
        continue
    print("10 /", i, " =", round(10/i, 2))

10 / -5  = -2.0
10 / -4  = -2.5
10 / -3  = -3.33
10 / -2  = -5.0
10 / -1  = -10.0
Pas de division par zero
10 / 1  = 10.0
10 / 2  = 5.0
10 / 3  = 3.33
10 / 4  = 2.5
10 / 5  = 2.0

Pass#

L’instruction pass permet d’indiquer qu’on complètera une partie de code plus tard. Dans l’exemple ci-dessous, on parcourt la liste qui contient les chiffres de 1 à 10. Pour les chiffres pairs, on complètera les instructions à réaliser plus tard. Pour les chiffres impairs, on se contente de les afficher.

a = list(range(1, 10))
for i in a:
    if i % 2 == 0:
        # to-do : complete this part 
        pass 
    else:
        print(i)

1
3
5
7
9

Les compréhensions de liste#

Nous avons vu comment créer des fonctions et comment parcourir une liste. Nous allons maintenant voir comment appliquer une fonction sur l’ensemble des éléments d’une liste.

Nous allons créer une liste a qui contient les chiffres entre 1 et 5. Ensuite, nous allons définir une fonction square qui permet de calculer le carré d’un chiffre. Finalement, on appliquera la fonction sur chaque élément de la liste et chaque valeur sera stockée dans la liste a_square.

a = list(range(1, 6))

def square(x):
    return x**2 

a_square = []
for i in a:
    a_square.append(square(i))
    
print(a_square)

[1, 4, 9, 16, 25]

Une autre possibilité est d’utiliser la syntaxe suivante :

a_square = [square(i) for i in a]
print(a_square)

[1, 4, 9, 16, 25]

Voyons comment utiliser cette syntaxe si on souhaite représenter une fonction:

Nous représentons les valeurs entre -3 et 5.

def f(x):
    return 2*x**2 - 4*x + 3

x = list(range(-3, 6))
y = [f(i) for i in x]

print(x)
print(y)

[-3, -2, -1, 0, 1, 2, 3, 4, 5]
[33, 19, 9, 3, 1, 3, 9, 19, 33]

Ensuite, on importe la librairie matplotlib et plus spécifiquement le module pyplot.

import matplotlib.pyplot as plt

plt.plot(x, y);

Si vous utilisez IDLE, il est probable que vous rencontriez cette erreur :

Cette erreur signifie que la librairie n’est pas installée. Dans ce cas, vous pouvez :

• installer via IDLE (voir instructions sur Moodle).

• utiliser une solution en ligne (https://colab.research.google.com/ - nécessite un compte Google et une connexion à internet)

• installer Anaconda (https://www.anaconda.com/)

Pour améliorer l’allure de la courbe, il est nécessaire de représenter plus de points. Notez qu’il n’est pas possible d’avoir un incrément décimal dans la fonction range. Pour contourner ceci, nous générons une liste de chiffres entre -30 et 50 et ensuite, nous divisons tous ces points par 10.

x = list(range(-30, 51))
x = [i/10 for i in x]
y = [f(i) for i in x]
plt.plot(x, y);

Exercices#

n = 5
for i in range(1,n+1):
    print(i)

1
2
3
4
5

a = int(input("Entrez une borne inferieure: "))
b = int(input("Entrez une borne superieure: "))
for i in range(a, b+1):
    print(i)

Entrez une borne inferieure: 2
Entrez une borne superieure: 10
2
3
4
5
6
7
8
9
10

for i in range(10, -1, -1):
    print(i)

10
9
8
7
6
5
4
3
2
1
0

import time
for i in range(10, -1, -1):
    print(i)
    time.sleep(1)

10
9
8
7
6
5
4
3
2
1
0

a = [2, 5, 8, 9, 4]

somme = 0
n = len(a)
for i in range(n):
    somme = somme + a[i]
print(somme)

28

Exercice 5#

Reproduisez le contenu (uniquement la zone bleue) de l’image ci-dessous. Chaque chiffre correspond à la somme entre le numéro de ligne et le numéro de colonne.

n = 5
for i in range(n+1):
    for j in range(n+1):
        print(i+j, end="\t")
    print("")

0	1	2	3	4	5	
1	2	3	4	5	6	
2	3	4	5	6	7	
3	4	5	6	7	8	
4	5	6	7	8	9	
5	6	7	8	9	10	

n = 6
somme = 0 
for i in range(1, n+1):
    somme = somme + i
print(somme)

21

n = 6
produit = 1
for i in range(1, n+1):
    produit = produit * i
print(produit)

720