Lorsque vous travaillez avec des données, les boucles for Python peuvent être un outil puissant. Mais elles peuvent aussi être un peu déroutantes lorsque vous débutez. C’est la raison pour laquelle je vous propose un tutoriel complet sur les boucles FOR Python.
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 vous effectuez un nettoyage ou une analyse de données en Python.

Ce tutoriel s’adresse aux débutants en Python mais si vous n’avez jamais écrit de ligne de code, vous pouvez 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.

Vous créez une boucle for en définissant d’abord l’objet itérable que vous souhaitez parcourir, puis en définissant les actions que vous souhaitez effectuer sur chaque élément de cet objet itérable. Par exemple, lors d’une itération dans une liste, vous spécifiez d’abord la liste que vous souhaitez parcourir, puis indiquez quelle action vous souhaitez 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

Notez 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.

vehiclerangeprice
Tesla Model 3 LR31049900
Hyundai Ioniq EV12430315
Chevy Bolt23836620

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']]

Vous avez 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 vous avez besoin de peaufiner ce sujet ou tout autre aspect des listes, consultez 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 ‘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).

Notez 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 vous pouvez 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

Vous pouvez obtenir des résultats surprenants simplement en maîtrisant les techniques décrites ci-dessus, mais regardons d’autres éléments qui pourraient vous être utiles, même si vous les utilisez 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

Notez 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 vous ne spécifiez qu’un seul nombre dans votre 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

Vous pouvez même ajouter un troisième paramètre à la fonction range() pour indiquer que vous souhaitez incrémenter chaque valeur par un nombre spécifique. Comme vous pouvez le voir ci-dessus, la valeur par défaut est 1, mais si vous ajoutez un troisième paramètre égal à 3, par exemple, vous pouvez 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 vous lui avez 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é à 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’oubliez pas que les boucles s’exécutent dans un ordre séquentiel. Si la Bolt avait été répertorié avant la Tesla dans notre datasets d’origine, elle aurait été inclus 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 à vous 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, laissez-moi vous 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:

J’espère qu’à ce stade, vous vous sentez à l’aise avec les boucles for Python et vous avez 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 – Apprenez à 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 tuto, 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 vous pouvez pratiquer directement depuis votre machine avec de nombreux exos.
  • Formation d’analyse de données pour la Data Science – Lorsque vous avez la sensation de maîtriser les boucles for et d’autres concepts Python de base, vous pourrez à l’aide de ce cours passer le niveau suivant de compétence Data.
  • Datasets à disposition – Pratiquez vous-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!