Python boucles FOR expliquées de A à Z

Lorsque tu travailles avec des données, les boucles for Python peuvent être un outil puissant. Mais elles peuvent aussi être un peu déroutantes lorsque tu débutes. C’est la raison pour laquelle je te propose un tutoriel complet sur Python boucles FOR.

Dans cet article, nous allons nous plonger dans les boucles for et apprendre comment elles peuvent être utilisées pour faire toutes sortes de choses intéressantes notamment lorsque tu effectues un nettoyage ou une analyse de données en Python.

Ce tutoriel s’adresse aux débutants en Python mais si tu n’as jamais écrit de ligne de code, tu peux suivre ma formation sur les Fondamentaux de Python afin d’avoir toute la syntaxe de base.

Qu’est-ce qu’une boucle FOR ?

Dans le contexte de la plupart des projets de Data Science, les boucles Python sont utilisées pour parcourir un objet itérable (comme une liste, un tuple, un ensemble, etc.) et effectuer la même action pour chaque entrée. Par exemple, une boucle for nous permettrait de parcourir une liste en effectuant la même action sur chaque élément de la liste.

Un objet itérable est un objet Python qu’on peut parcourir à l’aide d’une boucle et retourner un seul élément à la fois. Les listes, par exemple, sont itérables et retournent un élément de la liste à la fois et dans l’ordre. Les chaînes sont itérables et retournent un caractère à la fois, dans l’ordre d’affichage des caractères.

Tu crées une boucle for en définissant d’abord l’objet itérable que tu souhaites parcourir, puis en définissant les actions que tu souhaites effectuer sur chaque élément de cet objet itérable. Par exemple, lors d’une itération dans une liste, tu spécifies d’abord la liste que tu souhaites parcourir, puis indiques quelle action tu souhaites effectuer sur chaque élément de la liste.

Voyons un exemple rapide : si nous avions une liste de prénoms stockée dans Python, nous pourrions utiliser une boucle for pour parcourir cette liste, en affichant chaque nom jusqu’à la fin.

Ci-dessous, nous allons créer notre liste de noms, puis écrire une boucle for qui la parcourt en affichant chaque entrée de la liste dans l’ordre.

our_list = ['Thomas', 'Pierre', 'Fatima', 'Alex']

for name in our_list:
    print(name)

Thomas
Lily
Fatima
Alex

Ce code dans cette boucle simple soulève cependant une question : d’où vient le nom de la variable name ?

Nous ne l’avons pas défini auparavant dans notre code ! Mais comme les boucles parcourent des listes, des n-uplets, etc. de manière séquentielle, cette variable peut en réalité être appelée par n’importe quel nom (on essaie au maximum de lui donner un nom cohérent, name pour des prénoms semble parfait). Python interprétera tout nom de variable que nous avons placé à cet endroit comme faisant référence à chaque élément de liste au fur et à mesure de l’exécution de la boucle.

Donc, dans le code ci-dessus :

• name pointe vers “Thomas” à la première itération de la boucle…
• Puis “Pierre” à la deuxième itération de la boucle…
• …etc.

Ce sera le cas indépendamment du nom de cette variable. Ainsi, si par exemple, nous réécrivons notre code pour remplacer name par x, nous obtiendrons exactement le même résultat :

for x in our_list:
    print(x)

Thomas
Pierre
Fatima
Alex

Note que cette technique fonctionne avec n’importe quel objet itérable. Par exemple, les chaînes de caractères ‘strings’ sont itérables. Ainsi nous pouvons utiliser le même type de boucle for pour parcourir chaque caractère d’une chaîne string :

for letter in 'Lily':
    print(letter)

L
i
l
y

Utiliser les boucles FOR avec des listes de listes

Dans les projets d’analyse de données, il est peu probable que nous travaillions avec des listes courtes et simples comme celle ci-dessus. En règle générale, nous devrons utiliser des ensembles de données dans un format de tableau, avec plusieurs lignes et colonnes. Ce type de données peut être stocké dans Python sous forme de liste de liste, où chaque ligne d’une table est stockée sous forme de liste dans la liste de listes. Nous pouvons également utiliser des boucles pour les parcourir.

Pour apprendre à le faire, examinons un scénario plus réaliste et explorons ce petit tableau de données contenant les prix et les estimations de portée pour plusieurs voitures électriques.

Nous pouvons exprimer ce même ensemble de données sous forme de liste de listes, comme suit :

ev_data = [['vehicle', 'range', 'price'],
           ['Tesla Model 3 LR', '310', '49900'],
           ['Hyundai Ioniq EV', '124', '30315'],
           ['Chevy Bolt', '238', '36620']]

Tu as peut-être remarqué que, dans la liste ci-dessus, nos valeurs de distance ou portée (range) et de prix (price) sont en réalité stockés sous forme de chaînes strings plutôt que d’entiers. Il n’est pas rare que les données soient stockées de cette manière, mais pour l’analyse, nous souhaitons convertir ces chaînes en entiers pour pouvoir effectuer des calculs. Utilisons une boucle for pour parcourir notre liste de listes, en sélectionnant l’entrée de prix dans chaque liste et en la convertissant en entier.

Pour ce faire, nous devons réaliser quelques manipulations. Premièrement, nous devons ignorer la première ligne de notre tableau, car ce sont les noms de colonne et nous obtiendrons une erreur si nous essayons de convertir une chaîne non numérique comme 'range' en un entier. Nous pouvons le faire en utilisant le slicing pour sélectionner chaque ligne après la première en utilisant ev_data [1:]. (Si tu as besoin de peaufiner ce sujet ou tout autre aspect des listes, consulte mon cours sur les bases de la programmation Python).

Ensuite, nous allons parcourir la liste de listes, et pour chaque itération, nous sélectionnerons l’élément dans la colonne range, qui est la deuxième colonne de notre table. Nous assignerons la valeur trouvée dans cette colonne à une variable appelée ev_range. Pour ce faire, nous allons utiliser le numéro d’index 1 (en Python, la première entrée d’un itératif est à l’indice 0, la deuxième est à l’index 1, etc.).

Enfin, nous convertirons les numéros de plage en nombres entiers à l’aide de la fonction int() de Python et remplacerons les chaînes originales par ces entiers dans notre ensemble de données.

for row in ev_data[1:]:         
    ev_range = row[1]           
    ev_range = int(ev_range)    
    row[1] = ev_range           

print(ev_data)

[['vehicle', 'range', 'price'], ['Tesla Model 3 LR', 310, '49900'], ['Hyundai Ioniq EV', 124, '30315'], ['Chevy Bolt', 238, '36620']]

Maintenant que ces valeurs sont stockées sous forme d’entiers, nous pouvons également utiliser une boucle for pour effectuer certains calculs. Disons, par exemple, que nous voulons déterminer la fourchette moyenne d’une voiture électrique sur cette liste. Nous aurions besoin d’additionner les valeurs de distance, puis de les diviser par le nombre total de voitures de notre liste.

De nouveau, nous pouvons utiliser une boucle for pour sélectionner la colonne spécifique dont nous avons besoin dans notre ensemble de données. Nous allons commencer par créer une variable appelée total_range où nous pouvons stocker la somme des valeurs de distance. Ensuite, nous écrirons une autre boucle for, sautant à nouveau la ligne d’en-tête et identifiant à nouveau la deuxième colonne (index 1) comme valeur range.

Après cela, tout ce que nous avons à faire est d’ajouter cette valeur à total_range dans notre boucle for, puis de calculer la valeur à l’aide de total_range divisée par le nombre de voitures (après achèvement de la boucle).

Note que nous calculons le nombre de voitures en comptant la longueur de notre liste, moins la ligne d’en-tête, dans le code ci-dessous. Avec une liste aussi courte que la nôtre, nous pourrions aussi simplement diviser par 3, car le nombre de voitures est très facile à compter, mais cela casserait notre calcul si des données supplémentaires (de nouveaux véhicules par exemple) étaient ajoutées à la liste. Pour cette raison, il est préférable d’utiliser la fonction len() pour calculer la longueur de notre liste de voitures. Pour tout ajout de véhicule à l’avenir, nous pouvons simplement ré-exécuter ce code et il retournera toujours la réponse correcte.

total_range = 0                     

for row in ev_data[1:]:             
    ev_range = row[1]               
    total_range += ev_range         

number_of_cars = len(ev_data[1:])   

print(total_range / number_of_cars)

224.0

Les boucles Python sont puissantes et tu peux y imbriquer des instructions plus complexes. Pour illustrer cela, répétons les deux étapes ci-dessus pour notre colonne price, cette fois-ci dans une seule boucle For.

total_price = 0                     

for row in ev_data[1:]:             
    price = row[2]                  
    price = int(price)              
    row[2] = price                  
    total_price += price            

number_of_cars = len(ev_data[1:])   

print(total_price / number_of_cars) 

38945.0

Nous pouvons également imbriquer d’autres éléments, tels que les instructions If / Else et même d’autres boucles for dans des boucles for.

Par exemple, imaginons que nous voulions trouver toutes les voitures pouvant parcourir plus de 200 miles. Nous pouvons commencer par créer une nouvelle liste vide pour contenir ces voitures. Ensuite, nous utiliserons une boucle for pour parcourir ev_data, la liste de listes contenant les données de voiture que nous avons créées précédemment. Et on ajoutera la ligne d’une voiture uniquement si la valeur de distance est supérieure à 200 :

long_range_car_list = []       

for row in ev_data[1:]:        
    ev_range = row[1]
    # condition distance supérieur à 200 miles          
    if ev_range > 200:        
        long_range_car_list.append(row)

print(long_range_car_list)

[['Tesla Model 3 LR', 310, 49900], ['Chevy Bolt', 238, 36620]]

D’autres techniques utiles : Range, Break et Continue

Tu peux obtenir des résultats surprenants simplement en maîtrisant les techniques décrites ci-dessus, mais regardons d’autres éléments qui pourraient t’être utiles, même si tu les utilise un peu moins souvent dans le contexte de la Data Science.

Range

Les boucles For peuvent être utilisées simultanément avec la fonction range() de Python pour parcourir chaque nombre dans une plage spécifiée. Par exemple :

for x in range(5, 9):
    print(x)

5
6
7
8

Note que Python n’inclut pas la valeur maximale de range, raison pour laquelle le nombre 9 n’apparaît pas ci-dessus. Si nous voulions que ce code compte de 5 à 9, y compris 9, il faudrait changer range(5, 9) par range(5, 10) :

for x in range(5, 10):
    print(x)

5
6
7
8
9

Si tu ne spécifies qu’un seul nombre dans ta fonction range(), Python le considérera comme la valeur maximale et lui assignera une valeur minimale par défaut de zéro :

for x in range(3):
    print(x)

0
1
2

Tu peux même ajouter un troisième paramètre à la fonction range() pour indiquer que tu souhaites incrémenter chaque valeur par un nombre spécifique. Comme tu peux le voir ci-dessus, la valeur par défaut est 1, mais si tu ajoutes un troisième paramètre égal à 3, par exemple, tu peux utiliser range() avec une boucle for pour compter par trois :

for x in range(0, 9, 3):
    print(x)

0
3
6

Break

Par défaut, une boucle Python for parcourra chaque itération possible de l’objet itérable que tu lui as attribué. Normalement, lorsque nous utilisons une boucle for, c’est correct, car nous souhaitons appliquer la même action à chaque élément de notre liste (par exemple).

Parfois, cependant, nous pouvons vouloir arrêter notre boucle si une certaine condition est remplie. Dans ce cas, l’instruction break est utile. Lorsqu’elle est utilisée avec une instruction if à l’intérieur d’une boucle for, break nous permet de sortir de cette boucle avant la fin.

Voyons d’abord un exemple rapide, en utilisant la liste de noms que nous avons créée précédemment qui se nomme our_list :

for name in our_list:
    break
    print(name)

Lorsque nous exécutons ce code, rien n’est affiché! C’est parce que l’instruction break précède print(name) dans notre boucle for. Lorsque Python voit l’instruction break, il cesse d’exécuter la boucle for et le code suivant ne s’exécute pas.

Ajoutons une instruction if à cette boucle, afin que nous puissions sortir de la boucle lorsque Python obtient le nom Alex :

for name in our_list:
    if name == 'Alex':
        break
    print(name)

Thomas
Pierre
Fatima

Ici, nous pouvons voir que le prénom ‘Alex’ n’a pas été affiché. Voici ce qui se passe à chaque itération de boucle:

1. Python vérifie si le prénom est ‘Alex’. Ce n’est pas le cas, il continue donc d’exécuter le code situé sous notre instruction if et affiche le prénom.
2. Python vérifie si le deuxième prénom est ‘Alex’. Ce n’est toujours pas le cas, il continue donc d’exécuter le code situé sous notre instruction if et affiche le deuxième prénom.
3. Python vérifie si le troisième prénom est ‘Alex’. Ce n’est pas le cas, il continue donc d’exécuter le code situé sous notre instruction if et affiche le troisième prénom.
4. Python vérifie si le quatrième prénom est ‘Alex’. C’est le cas, donc break est exécuté et la boucle for se termine.

Revenons au code que nous avons écrit pour la collecte de données sur les voitures électriques à longue portée et étudions un autre exemple. Nous allons insérer une instruction break qui stoppe l’action dès qu’on rencontre la chaîne 'Tesla' :

long_range_car_list = []

for row in ev_data[1:]:     
    ev_range = row[1]
    if ev_range > 200:
        long_range_car_list.append(row)
    # si on rencontre 'Tesla', on stoppe la boucle
    if 'Tesla' in row[0]:   
            break

print(long_range_car_list)

[['Tesla Model 3 LR', 310, 49900]]

Dans le code ci-dessus, nous pouvons voir que la Tesla est encore ajoutée à long_range_car_list, car nous l’avons ajoutée à cette liste avant l’instruction if où nous avons utilisé break. La Chevy Bolt n’a pas été ajoutée à notre liste, car bien qu’il ait une autonomie supérieure à 200 milles, l’instruction break a mis fin à la boucle avant que Python n’atteigne la ligne Chevy Bolt.

N’oublie pas que les boucles s’exécutent dans un ordre séquentiel. Si la Bolt avait été répertoriée avant la Tesla dans notre datasets d’origine, elle aurait été incluse dans long_range_car_list.

Continue

Lorsque nous parcourons un objet itérable comme une liste, nous pouvons également rencontrer des situations dans lesquelles nous souhaitons ignorer une ou plusieurs lignes particulières. Pour des situations simples telles que le saut d’une ligne d’en-tête, nous pouvons utiliser le découpage par slicing de liste, mais si nous souhaitons ignorer des lignes en fonction de conditions plus complexes, cela devient rapidement impraticable. À la place, nous pouvons utiliser l’instruction continue pour ignorer une seule itération d’une boucle for et passer à la suivante.

Par exemple, lorsque Python voit continue en exécutant une boucle for sur une liste, il s’arrête à ce point et passe à l’élément suivant de la liste. Tout code venant en dessous de continue ne sera pas exécuté.

Reprenons notre liste de prénoms (our_list) et utilisons continue avec une instruction if pour mettre fin à une itération de boucle avant affichage si le prénom est ‘Pierre’ :

for name in our_list:
    if name == 'Pierre':
        continue
    print(name)

Thomas
Fatima
Alex

Ci-dessus, nous pouvons voir que le prénom de Pierre a été ignoré et que les autres prénoms de notre liste ont été affichés en séquence. Cela illustre la différence entre break et continue en un mot :

break met fin à la boucle entièrement. Lorsque Python exécute break, la boucle for est terminée.

continue termine une itération spécifique de la boucle et passe à l’élément suivant de la liste. Lorsque Python est exécuté, il passe immédiatement à la prochaine itération de la boucle, mais il ne termine pas complètement la boucle.

Pour continuer à t’exercer, continuons en dressant une liste des véhicules électriques à courte portée, en utilisant continue pour adopter une approche légèrement différente. Au lieu d’identifier les véhicules électriques avec une portée inférieure à 200 miles, nous écrirons une boucle for qui ajoute chaque véhicule à notre liste à courte portée, mais avec une instruction continue avant l’ajout à la nouvelle liste qui s’exécute si la portée est supérieure à 200 miles :

short_range_car_list = []               

for row in ev_data[1:]:                 
    ev_range = row[1]
    # si la portée est supérieure à 200, on passe à l'élément suivant de la boucle
    if ev_range > 200:                  
        continue                        
    short_range_car_list.append(row)


print(short_range_car_list)

[['Hyundai Ioniq EV', 124, 30315]]

Ce n’est probablement pas le moyen le plus efficace (et le plus lisible) de créer notre liste de voitures à courte portée, mais il montre bien comment la commande continue fonctionne, laisse-moi te décrire précisément ce qui se passe ici.

Sur son premier passage de la boucle, Python regarde la ligne Tesla. Cette voiture a une autonomie de plus de 200 miles. Python exécute l’instruction continue imbriquée dans l’instruction if (si elle est vraie), ce qui la fait immédiatement passer à la ligne suivante de ev_data pour commencer le prochain tour.

Dans le deuxième passage, Python regarde la ligne suivante, celle de Hyundai. Cette voiture a une portée de moins de 200 miles. Python voit donc que l’instruction conditionnelle if n’est pas remplie et exécute le reste du code dans la boucle for, en ajoutant la ligne Hyundai à short_range_car_list.

Au troisième et dernier passage de notre exemple, Python regarde la ligne Chevy. Cette voiture a une autonomie de plus de 200 milles, ce qui signifie que la déclaration conditionnelle if est vraie. Ainsi, Python exécute de nouveau continue, ce qui termine la boucle et, puisqu’il n’y a plus de lignes de données dans notre ensemble de données, met fin à la boucle for.

Plutôt simple, non?

Resources additionnelles de Python boucles FOR

J’espère qu’à ce stade, tu te sens à l’aise avec les boucles for Python et tu as une idée de la façon dont elles peuvent être utiles pour les tâches informatiques courantes telles que le nettoyage, la préparation et l’analyse des données.

Prêt pour le next level? Voici quelques ressources supplémentaires à consulter:

• Tutoriel avancé sur les boucles for – Apprends à utiliser les boucles avec NumPy, Pandas et autres techniques plus avancées dans cette “suite” sur les boucles.
• Documentation officielle de Python sur les boucles For – La documentation officielle n’approfondit pas autant que ce tutoriel mais il passe en revue les bases des boucles for et explique certains concepts connexes tels que les boucles While.
• Formation sur les principes fondamentaux de Python pour la Data Science – Notre cours sur les principes fondamentaux de Python offre une introduction à partir de zéro au codage en Python pour la Data Science. Il couvre les listes, les boucles et bien d’autres choses encore, et tu peux pratiquer directement depuis ta machine avec de nombreux eexercices
• Formation d’analyse de données pour la Data Science – Lorsque tu as la sensation de maîtriser les boucles for et d’autres concepts Python de base, tu pourras à l’aide de ce cours passer le niveau suivant de compétence Data.
• Datasets à disposition – Pratique toi-même des boucles en récupérant un dataset dans l’une de ces sources et en appliquant vos nouvelles compétences à de plus grands ensembles de données issus du monde réel. Les ensembles de données de la première section (pour la visualisation des données) devraient fonctionner particulièrement bien pour les projets pratiques car ils doivent déjà être relativement propres.

Enjoy & happy looping!