Python pour la data-science
Les boucles
Dans un algorithme, il arrive fréquemment que l'on ait besoin de répéter plusieurs fois les mêmes lignes de code.
Pour cela, il est plus commode d'utiliser des boucles, qui vont exécuter une série d'opérations autant de fois que
nécessaire.
Il existe deux clauses pour définir les boucles en Python : Les clauses for et while .
1. La boucle while
Le mot-clé while signifie "tant que" en anglais. La boucle while permet de répéter un bloc d'instructions tant que la
condition de départ est vraie (ou jusqu'à ce qu'elle soit fausse).
Par exemple, pour déterminer l'indice du mot "trouvé" dans une liste de mots, il suffit de parcourir tous les indices
de la liste jusqu'à trouver la chaîne "trouvé" :
# La liste de mots dans laquelle nous voulons trouver le mot "trouvé".
phrase = ['La', 'boucle', 'while', 'parcourt', 'tous', 'les', 'éléments', 'de',
'la', 'liste', "jusqu'à", 'ce', "qu'elle", 'ait', 'trouvé', 'ce', "qu'elle", 'c
herche', '.']
# La variable i va stocker l'indice dans lequel nous sommes
i=0
# Tant que le mot à l'indice où nous sommes est différent de "trouvé"
while phrase[i] != 'trouvé':
# On incrémente la valeur de i de 1 pour passer à l'indice suivant
i += 1
# La boucle s'arrête lorsque nous avons trouvé le bon mot
print("Le mot 'trouvé' est à l'indice", i)
>>>> Le mot 'trouvé' est à l'indice 14
La structure générale d'une boucle while est la suivante :
while condition:
instruction1
...
instructionN
autre_instruction
À chaque itération de la boucle while , la condition est évaluée. Si la condition est vérifiée, le bloc d'instructions est
éxécuté, sinon la boucle se termine.
Les lignes en dehors du bloc d'instruction ne font pas partie de la boucle, elles ne sont donc exécutées qu'une fois la
boucle terminée.
Si la condition est fausse dès le départ, le bloc d'instruction n’est jamais exécuté.
Inversement, si la condition reste toujours vraie, le bloc d'instruction est exécuté indéfiniment. Il est donc important de
s'assurer que la boucle va se terminer avant de l'exécuter.
(a) Instancier une variable i avec la valeur 1 .
Entrée [ ]:
# Insérez votre code ici
Show solution
Nous disposons d'une liste contenant les temps effectués par des athlètes lors d'une course de 100m.
Les résultats sont triés par ordre croissant.
(c) En utilisant une boucle while , déterminer combien d'athlètes ont réalisé un temps inférieur à 10s.
Ici, l'utilisation de la fonction python len() peut être utile. Cette fonction peut être utilisée pour calculer la longueur
d'une liste, d'un dictionnaire ou d'un ensemble. Par exemple, pour une liste nommée liste avec 3 éléments, len(liste)
donnera 3.
Entrée [ ]:
results = [9.81, 9.89, 9.91, 9.93, 9.94, 9.95, 9.96, 9.97, 9.98, 10.03, 10.04, 10.05, 10.06, 10.08
# Insérez votre code ici
Show solution
2. La boucle for
La boucle for permet de répéter un bloc d'instructions de manière plus contrôlée. En effet, il n'est pas clair avec une
boucle while le nombre de fois que la boucle va s'exécuter.
La boucle for est très explicite par rapport à la variable qui va être modifiée à chaque itération de la boucle et le
nombre d'itérations de la boucle effectuées est toujours fini.
Par exemple, pour afficher une par une les lettres du mot boucle :
for letter in "boucle":
print(letter)
>>> b
>>> o
>>> u
>>> c
>>> l
>>> e
La structure générale d'une boucle for est la suivante :
for element in sequence:
instruction1
...
instructionN
autre_instruction
La boucle for exécute le bloc d'instructions pour chaque élément de la séquence.
Comme pour la boucle while , les lignes en dehors du bloc d'instruction ne font pas partie de la boucle, elles ne sont
donc exécutées qu'une fois lorsque la boucle est terminée.
Les actions se déroulent dans l'ordre suivant :
la variable element prend la valeur du premier élément de sequence .
Le bloc d'instruction est exécuté.
La variable element prend la valeur du deuxième élément de sequence .
Le bloc d'instruction est exécuté.
...
...
La variable element prend la valeur du dernier élément de sequence .
Le bloc d'instruction est exécuté et la boucle se termine.
L'instruction autre_instruction est exécutée.
La séquence peut être tout type d'objet indexable comme une liste , un tuple , une chaîne de caractères, etc...
Dans la boucle for il est inutile de modifier la variable element , Python s'en charge automatiquement.
Attention cependant à ne pas oublier dans la syntaxe in et : qui sont indispensables.
Un professeur a sous-évalué ses élèves, et souhaite réhausser les notes de ceux-ci pour obtenir une moyenne de classe supérieure à
10/20.
Les notes des élèves ont été intégrées à la liste suivante :
bad_marks = [0, 2, 3, 3, 3, 3, 4, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 9, 10, 1
0, 10, 11, 12, 14]
A l'aide de boucles for :
(a) Calculer et afficher la moyenne de la classe. Il y a 30 élèves dans la classe.
(b) Créer une liste good_marks où vous stockerez les notes augmentées de 4 points. Pour cela, vous pouvez créer une liste vide
puis ajouter les notes une par une.
Entrée [ ]:
bad_marks = [0, 2, 3, 3, 3, 3, 4, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 9, 10, 10, 10, 1
# Insérez votre code ici
Show solution
(d) Déterminer le maximum et le minimum de la liste l constituée des éléments [2,3,8,1,4] à l'aide d'une boucle for .
Entrée [ ]:
# Insérez votre code ici
Show solution
On aurait pu également utiliser les fonctions min ou max directement implémentées dans Python et compatible
avec les listes comme cela est visible ci-dessous.
Entrée [ ]:
l = [2,3,8,1,4]
print("Maximum de la liste :",max(l))
print("Minimum de la liste :",min(l))
Souvent, l'utilisation d'une boucle implique de parcourir l'ensemble des éléments d'une structure de données. C'est là
qu'intervient le mot-clé break qui permet de sortir d'une boucle et de passer à l'instruction suivante. On peut par
exemple, l'utiliser pour les boucles for et while lorsqu'une condition spécifique est validée comme cela est visible
sur l'exemple ci-dessous :
Entrée [ ]:
i=0
while(i<15):
print(i)
if i==1:
break # On sort de la boucle while dès que i est égal à 1
i+=1
(e) Construire la liste l avec les éléments suivants : [2,3,4,5,6,4] et afficher l'expression "Le nombre 4 est présent" dès que le
chiffre 4 est détecté. Cette expression doit être affichée une seule fois en sortie. Utiliser pour cela une boucle for et le mot-clé
break .
Entrée [ ]:
# Insérez votre code ici
Show solution
3. La fonction range
La fonction range est souvent utilisée avec les boucles for . Elle prend en argument un début, une fin et un pas. Elle
renvoie une suite de nombres allant du début à la fin (Le nombre de début inclus, mais le nombre de fin est exclu) avec
comme incrément entre deux nombres le pas.
Par défaut le début est 0 et le pas est de 1.
Ainsi :
la saisie de range(5) renvoie la suite des nombres entiers de 0 à 4.
la saisie de range(1, 10) renvoie la suite des nombres entiers de 1 à 9.
la saisie de range(1, 10, 3) renvoie la suite 1, 4, 7.
la saisie de range(10,-1,-1) renvoie la suite des nombres entiers de 10 à 0. La séquence de
nombres commence à 10 (début), se termine à 0 (fin) et va de 10 à 0 (le pas étant négatif).
La suite de Fibonacci ([Link] est une suite d'entiers dans laquelle chaque
terme est la somme des deux termes qui le précèdent.
Pour calculer les termes de la suite de Fibonacci, on fixe les deux premiers termes de la suite :
𝑢0 = 0
𝑢1 = 1
Pour 𝑖 ≥ 2, on calcule les termes 𝑢𝑖 à l'aide de la formule :
𝑢𝑖 = 𝑢𝑖−1 + 𝑢𝑖−2
(a) À l'aide d'une boucle for et de la fonction range , calculer et stocker dans la liste u les 100 premiers termes de la suite de
Entrée [ ]:
# Les deux premiers termes de la suite de Fibonacci
u = [0, 1]
# Insérez votre code ici
Show solution
(b) La surface d'un terrain est de 2000 mètres carrées. Chaque année sa surface est multipliée par 2. Calculer la surface du terrain
au bout de 10 ans à l'aide d'une boucle for .
Entrée [ ]:
# Insérez votre code ici
Show solution
(c) Répondre à nouveau à la question (b) mais cette fois-ci en utilisant une boucle while .
Entrée [ ]:
# Insérez votre code ici
Show solution
(d) A l'aide d'une boucle for uniquement ou en utilisant aussi la fonction range , écrire un programme qui permet d'inverser
l'ordre du mot serre en utilisant l'indexation des listes associé à des chaînes de caractères.
Entrée [ ]:
# Insérez votre code ici
Show solution
Une autre possibilité plus simple est d'utiliser le slicing (découpage) pour inverser l'ordre d'un mot à l'aide de
l'expression [::-1]
Le 1er : indique que le slicing contiendra tous les éléments du début à la fin.
Le 2e : indique la même chose c'est à dire que le découpage sera constitué de tous les éléments de l'indice du
début à la fin.
Le chiffre -1 indique la valeur du pas et signifie que la liste sera parcouru de la fin vers le début (dans le sens
inverse).
Entrée [ ]:
mot = 'serre'
print(mot[::-1])
(e) Utiliser le même slicing pour inverser l'ordre de la liste constituée des éléments [1,2,3,4]
Entrée [ ]:
# Insérez votre code ici
Show solution
4. Boucles emboîtées
Il est possible d'emboiter des boucles les unes dans les autres.
Par exemple, lorsque l'on a une liste de listes, il est possible de parcourir tous ses éléments avec deux boucles
emboîtées.
La syntaxe est la suivante :
# Pour chaque liste dans la liste de listes
for liste in liste_de_listes:
# Pour chaque élément dans la liste
for element in liste:
...
...
Il faut faire très attention à l'indentation des blocs. Comme pour les clauses if , l'indentation délimite le début et la
fin des blocs.
(a) Déterminer le nombre de fois que le caractère 'e' apparait dans le texte suivant. Pour cela, vous pourrez parcourir chaque
mot du texte avec une boucle, puis parcourir chaque lettre de chaque mot en comptant chaque occurence du caractère 'e' .
Entrée [ ]:
text = ['Le', 'Brésil,', 'seule', 'équipe', 'à', 'avoir', 'disputé', 'toutes',
'les', 'phases', 'finales', 'de', 'la', 'compétition,', 'détient', 'le', 'record',
'avec', 'cinq', 'titres', 'mondiaux', 'et', "s'est", 'acquis', 'le', 'droit', 'de',
'conserver', 'la', 'Coupe', 'Jules-Rimet', 'en', '1970', 'après', 'sa', '3e',
'victoire', 'finale', 'dans', 'la', 'compétition,', 'avec', 'Pelé', 'seul',
'joueur', 'triple', 'champion', 'du', 'monde.', "l'", "Italie", 'et',
"l'", "Allemagne", 'comptent', 'quatre', 'trophées.', "l'", "Uruguay,", 'vainqueur',
'à', 'domicile', 'de', 'la', 'première', 'édition,', "l'", "Argentine", 'et',
'la', 'France', 'ont', 'gagné', 'chacune', 'deux', 'fois', 'la', 'Coupe,',
"l'", "Angleterre", 'et', "l'", "Espagne", 'une', 'fois.', 'La', 'dernière', 'édition',
"s'est", 'déroulée', 'en', 'Russie', 'en', '2018,', 'la', 'prochaine', 'doit',
'avoir', 'lieu', 'au', 'Qatar', 'en', '2022.', 'Celle', 'de', '2026,', 'aux',
'États-Unis,', 'au', 'Canada', 'et', 'au', 'Mexique)', 'sera', 'la', 'première',
'édition', 'à', '48', 'équipes', 'participantes.', 'La', 'Coupe', 'du', 'monde',
'de', 'football', 'est', "l'", "événement", 'sportif', 'le', 'plus', 'regardé', 'à',
'la', 'télévision', 'dans', 'le', 'monde', 'avec', 'les', 'Jeux', 'olympiques',
'et', 'la', 'Coupe', 'du', 'monde', 'de', 'cricket.']
# Insérez votre code ici
Show solution
b) Compter le nombre de fois que la lettre i est présente dans la liste constituée des éléments suivant ['serre
iconoclaste', 'invraisemblable imaginer'] à l'aide de boucles for emboîtées et de l'indexation des listes associé à
des chaînes de caractères.
Entrée [ ]:
# Insérez votre code ici
Show solution
5. Compréhension de liste
La compréhension de liste est un concept extrêmement intéressant avec Python, et qui s'inscrit dans l'objectif central
de simplification des codes et de gain de productivité.
En utilisant la syntaxe des boucles for , il permet de définir de manière très compacte et élégante une liste de valeurs.
On souhaite stocker dans une liste les 10 premiers entiers au carré. Pour cela, on peut créer une liste vide et utiliser une
boucle for comme précédemment :
ma_liste = []
for i in range(10):
ma_liste.append(i**2)
Mais Python nous permet de réduire cette écriture, grâce à la compréhension de liste :
ma_liste = [i**2 for i in range(10)]
Ces deux méthodes sont strictement équivalentes.
Ainsi, pour un des exercices précédents où nous voulions augmenter toutes les notes de 4 points, nous aurions pu faire :
good_marks = [mark + 4 for mark in bad_marks]
En utilisant la méthode de compréhension de liste :
(a) Stocker dans une liste nommée puissances_trois les 10 premières puissances de 3.
(b) Une liste liste_nombres vous est donnée. Créer une nouvelle liste liste_double contenant le double de chacun de ses
éléments.
(c) À partir de liste_nombres , créer une liste liste_pairs qui pour chaque nombre de liste_nombres indique
"pair" si le nombre est pair, et "impair" sinon. La parité peut être testée à l'aide de l'opérateur modulo % .
On rappelle la syntaxe de l'assignation conditionnelle :
# Un élève redouble si sa moyenne est inférieure à 10
redouble = True if moyenne < 10 else False
Entrée [ ]:
# La liste de données pour les deux dernières questions
liste_nombres = [10, 12, 7, 3, 26, 2, 19]
# Insérez votre code ici
Show solution
(d) A partir d'une compréhension de liste, extraire d'une liste de mots, une sous-liste constituée de palindromes c'est à dire de
mots qui se lisent dans les 2 sens (exemple : kayak, été). La liste de mots dont il faut extraire les palindromes est constitué des
éléments suivant : "kayak","bonjour","radar","été","voyage" .
Entrée [ ]:
# Insérez votre code ici
Show solution
6. La fonction enumerate
Il est parfois utile d'avoir accès à l'indice d'un élément dans une séquence. Pour ce faire, il est possible d'utiliser la
fonction enumerate dans la clause de la boucle for :
for index, element in enumerate(sequence):
...
Par exemple, si nous souhaitons afficher les différentes positions du mot "le" dans un texte :
texte = ["le", "mot", "le", "est", "le", "mot", "dont", "nous", "cherchons", "l
a", "position"]
# Pour chaque mot du texte
for position, mot in enumerate(texte):
# Si le mot est "le"
if mot == "le":
# On affiche sa position
print(position)
>>> 0
>>> 2
>>> 4
(a) Déterminer l'indice du maximum de la liste L à l'aide de la fonction enumerate . Pour trouver ce maximum, il suffit de stocker
le plus grand élément vu en parcourant la liste.
(b) Afficher l'indice du maximum de la liste.
Entrée [ ]:
L = [22,65,75,93,64,47,91,53,86,53,88,17,94,39]
# Insérez votre code ici
Show solution
7. La fonction ZIP
La fonction zip permet de parcourir parallèlement plusieurs séquences de même longueur dans une seule boucle
for .
La syntaxe est la suivante :
# A chaque itération, on prend un élément de la première séquence et un élément
de la deuxième
for element1, element2 in zip(sequence1, sequence2):
...
Cette syntaxe peut être généralisée à un très grand nombre de séquences.
Nous disposons de 2 listes contenant respectivement les revenus et les dépenses d'individus pendant un mois. Les individus ont le
même indice dans les deux listes.
(a) En faisant la différence entre les revenus et les dépenses de chaque individu, créer une liste contenant les économies qu'ils ont
réalisées pendant ce mois.
Entrée [ ]:
revenus = [1200, 2000, 1500, 0, 1000, 4500, 1200, 500, 1350, 2200, 1650, 1300, 2300]
depenses = [1000, 1700, 2000, 700, 1200, 3500, 200, 500, 1000, 3500, 1350, 1050, 1850]
economies = []
# Insérez votre code ici
Show solution
Conclusion et récap
Les boucles sont des outils indispensables de la programmation. Elles permettent de répéter des instructions de
manière contrôlée.
Dans ce notebook, vous avez appris à :
Définir une boucle while qui s'exécute tant que la condition la définissant est vérifiée.
Définir une boucle for qui permet de parcourir des séquences.
Définir des listes par compréhension, qui constitue l'un des outils les plus élégants de Python.
Utiliser la fonction range pour parcourir des nombres entiers.
Utiliser le mot-clé break pour sortir d'une boucle lorsqu'une condition spécifique est validée.
Utiliser le slicing ::-1 pour inverser l'ordre d'une séquence.
Utiliser la fonction enumerate pour parcourir les indices et les valeurs d'une séquence.
Utiliser la fonction zip pour parcourir plusieurs listes avec une seule boucle.
Unvalidate
