Instructions répétitives
Contents
Instructions répétitives#
Il arrive fréquemment qu’une instruction soit répétée un certain nombre de fois. Il est dès lors plus efficace d’écrire une cette instruction au sein d’une instruction répétitive / une boucle.
Par exemple, supposons que nous souhaitions afficher les chiffres de 0 à 5, nous pourrions écrire :
print(0)
print(1)
print(2)
print(3)
print(4)
print(5)
0
1
2
3
4
5
L’instruction print
est répétée un certain nombre de fois. Voyons comment une boucle for
pourrait nous aider à écrire ceci de manière plus concise.
for i in range(6):
print(i)
0
1
2
3
4
5
Si on souhaite traduire cette expression en français, nous pourrions écrire :
Pour \(i\) (for i
) qui prend toutes les valeurs jusqu’à 6 (in range(6)
), afficher la valeur de \(i\) (print(i)
). Comme lors de la création d’une fonction, il faut :
Terminer la première ligne par
:
.Ajouter une indentation aux instructions qui font partie de la boucle. Sans cette indentation, le code ne fonctionnera pas. Vous pouvez également retenir qu’après chaque
:
, il faut au minimum une ligne indentée.
Dans le chapitre sur les listes, nous avons également vu que range
avait un comportement différent en fonction du nombre d’arguments qui sont fournis:
1 argument \(a\) : de 0 (inclus) à \(a\) (non-inclus)
for i in range(5):
print(i)
0
1
2
3
4
2 arguments \(a\) et \(b\) : de \(a\) (inclus) à \(b\) (non-inclus)
for i in range(1, 5):
print(i)
1
2
3
4
3 arguments \(a\), \(b\), et \(c\): de \(a\) (inclus) à \(b\) (non-inclus) par incrément de \(c\)
for i in range(1, 10, 2):
print(i)
1
3
5
7
9
Si l’incrément est négatif, les chiffres affichés seront donc décroissants (il faut que \(a\) > \(b\) dans ce cas).
for i in range(10, 1, -2):
print(i)
10
8
6
4
2
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);
![../../_images/for_56_0.png](/static/python/images/for_56_0.png)
Si vous utilisez IDLE, il est probable que vous rencontriez cette erreur :
![](/static/python/images/erreur_matplotlib.png)
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);
![../../_images/for_59_0.png](../../_images/for_59_0.png)
Exercices#
Exercice 1#
Créez une variable n
égal à 5. Affichez ensuite tous les chiffres entre 1 et n
.
n = 5
for i in range(1,n+1):
print(i)
1
2
3
4
5
Exercice 2#
Demandez à l’utilisateur d’entrer une borne inférieure et une borne supérieure. Stockez ces informations dans les variables a
et b
. Affichez tous les chiffres compris entre ces bornes, a
et b
inclus.
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
Exercice 3#
3A#
A l’aide d’une boucle, créez un compte à rebours qui affiche les chiffres de 10 à 0.
for i in range(10, -1, -1):
print(i)
10
9
8
7
6
5
4
3
2
1
0
3B#
Améliorez le script précédent en utilisant time.sleep(1)
qui permet de faire une pause dans l’exécution de 1 seconde pour avoir un rendu qui ressemble vraiment à un compte à rebours. N’oubliez pas d’importer le module time
.
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
Exercice 4#
Créez une liste a
qui contient les chiffres 2, 5, 8, 9, et 4. Calculez ensuite la somme des éléments de cette liste sans utiliser la fonction sum
.
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.
![](/static/python/images/exercice_double_for.png)
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
Exercice 6#
L’opérateur \(\sum\), très utilisé en mathématiques et statistiques, indique une somme. Par exemple :
Implémentez un script qui calcule et affiche la somme de 1 à \(n\) (supposez que \(n=6\)).
n = 6
somme = 0
for i in range(1, n+1):
somme = somme + i
print(somme)
21
Exercice 7#
L’opérateur \(\Pi\), également très utilisé en mathématiques et statistiques, indique un produit. Par exemple:
Implémentez un script qui calcule et affiche le produit des chiffres entre 1 et \(n\) (supposez que \(n=6\)).
n = 6
produit = 1
for i in range(1, n+1):
produit = produit * i
print(produit)
720