Comment construire des boucles for en Python 3

L'utilisation de boucles dans la programmation informatique nous permet d'automatiser et de répéter des tâches similaires à plusieurs reprises. Dans ce didacticiel, nous allons couvrir lesfor loop de Python.

Une bouclefor implémente l'exécution répétée de code basé sur un compteur de boucle ou une variable de boucle. Cela signifie que les bouclesfor sont utilisées le plus souvent lorsque le nombre d'itérations est connu avant d'entrer dans la boucle, contrairement auxwhile loops qui sont conditionnellement basés.

Pour les boucles

En Python, les bouclesfor sont construites comme ceci:

for [iterating variable] in [sequence]:
    [do something]

Le travail en cours sera exécuté jusqu'à la fin de la séquence.

Examinons une bouclefor qui parcourt une plage de valeurs:

for i in range(0,5):
   print(i)

Lorsque nous exécutons ce programme, la sortie ressemble à ceci:

Output0
1
2
3
4

Cette bouclefor définiti comme sa variable itérative, et la séquence existe dans la plage de 0 à 5.

Ensuite, dans la boucle, nous imprimons une itération d’entier par boucle. N'oubliez pas qu'en programmation, nous avons tendance à commencer à l'indice 0. C'est pourquoi, bien que 5 nombres soient imprimés, ils vont de 0 à 4.

Vous verrez et utiliserez généralement les bouclesfor lorsqu'un programme doit répéter un bloc de code plusieurs fois.

Boucles For utilisant range ()

L'un des types de séquence immuables intégrés à Python estrange(). Dans les boucles,range() est utilisé pour contrôler le nombre de répétitions de la boucle.

Lorsque vous travaillez avecrange(), vous pouvez lui passer entre 1 et 3 arguments entiers:

start indique la valeur entière à laquelle la séquence commence, si elle n'est pas incluse, alorsstart commence à 0
stop est toujours requis et est l'entier compté jusqu'à mais non inclus
step définit de combien augmenter (ou diminuer dans le cas de nombres négatifs) l'itération suivante, si cela est omis alorsstep prend la valeur par défaut 1

Nous allons examiner quelques exemples de transmission de différents arguments àrange().

Tout d'abord, passons uniquement l'argumentstop, de sorte que notre configuration de séquence soitrange(stop):

for i in range(6):
   print(i)

Dans le programme ci-dessus, l'argumentstop est 6, donc le code itérera de 0 à 6 (à l'exclusion de 6):

Output0
1
2
3
4
5

Ensuite, nous examineronsrange(start, stop), avec des valeurs transmises pour le moment où l'itération doit démarrer et pour le moment où elle doit s'arrêter:

for i in range(20,25):
   print(i)

Ici, la plage va de 20 (inclus) à 25 (exclusif), ainsi le résultat ressemble à ceci:

Output20
21
22
23
24

L'argumentstep derange() est similaire àspecifying stride while slicing strings en ce qu'il peut être utilisé pour sauter des valeurs dans la séquence.

Avec les trois arguments,step arrive en position finale:range(start, stop, step). Tout d'abord, utilisons unstep avec une valeur positive:

for i in range(0,15,3):
   print(i)

Dans ce cas, la bouclefor est configurée de sorte que les nombres de 0 à 15 s'impriment, mais à unstep de 3, de sorte que seul un nombre sur trois soit imprimé, comme ceci:

Output0
3
6
9
12

Nous pouvons également utiliser une valeur négative pour notre argumentstep pour itérer en arrière, mais nous devrons ajuster nos argumentsstart etstop en conséquence:

for i in range(100,0,-10):
   print(i)

Ici, 100 est la valeur destart, 0 est la valeur destop et-10 est la plage, donc la boucle commence à 100 et se termine à 0, diminuant de 10 à chaque itération. Nous pouvons voir que cela se produit dans la sortie:

Lors de la programmation en Python, les bouclesfor utilisent souvent le type de séquencerange() comme paramètres d'itération.

Boucles For utilisant des types de données séquentiels

LesLists et d'autres types de séquences de données peuvent également être exploités comme paramètres d'itération dans les bouclesfor. Plutôt que de parcourir unrange(), vous pouvez définir une liste et parcourir cette liste.

Nous allons assigner une liste à une variable, puis parcourir la liste:

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for shark in sharks:
   print(shark)

Dans ce cas, nous imprimons chaque élément de la liste. Bien que nous ayons utilisé la variableshark, nous aurions pu appeler la variable n'importe quel autrevalid variable name et nous obtiendrions la même sortie:

Outputhammerhead
great white
dogfish
frilled
bullhead
requiem

La sortie ci-dessus montre que la bouclefor a parcouru la liste et imprimé chaque élément de la liste par ligne.

Les listes et autresdata types basés sur des séquences commestrings ettuples sont couramment utilisés avec des boucles car ils sont itérables. Vous pouvez combiner ces types de données avecrange() pour ajouter des éléments à une liste, par exemple:

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for item in range(len(sharks)):
   sharks.append('shark')

print(sharks)

Output['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Ici, nous avons ajouté une chaîne d'espace réservé de'shark' pour chaque élément de la longueur de la listesharks.

Vous pouvez également utiliser une bouclefor pour construire une liste à partir de zéro:

integers = []

for i in range(10):
   integers.append(i)

print(integers)

Dans cet exemple, la listeintegers est initialisée vide, mais la bouclefor remplit la liste comme ceci:

Output[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

De même, nous pouvons parcourir les chaînes:

sammy = 'Sammy'

for letter in sammy:
   print(letter)

OutputS
a
m
m
y

L'itération à traverstuples est effectuée dans le même format que l'itération à travers les listes ou les chaînes ci-dessus.

Lors de l'itération d'undictionary, il est important de garder à l'esprit la structure clé: valeur pour vous assurer que vous appelez l'élément correct du dictionnaire. Voici un exemple qui appelle à la fois la clé et la valeur:

sammy_shark = {'name': 'Sammy', 'animal': 'shark', 'color': 'blue', 'location': 'ocean'}

for key in sammy_shark:
   print(key + ': ' + sammy_shark[key])

Outputname: Sammy
animal: shark
location: ocean
color: blue

Lors de l'utilisation de dictionnaires avec des bouclesfor, la variable itérante correspond aux clés du dictionnaire, etdictionary_variable[iterating_variable] correspond aux valeurs. Dans le cas ci-dessus, la variable itérativekey a été utilisée pour représenter la clé etsammy_shark[key] pour les valeurs.

Les boucles sont souvent utilisées pour itérer et manipuler des types de données séquentiels.

Nested For Loops

Les boucles peuvent être imbriquées dans Python, comme avec d'autres langages de programmation.

Une boucle imbriquée est une boucle qui se produit dans une autre boucle, structurellement similaire ànested if statements. Ceux-ci sont construits comme suit:

for [first iterating variable] in [outer loop]: # Outer loop
    [do something]  # Optional
    for [second iterating variable] in [nested loop]:   # Nested loop
        [do something]

Le programme rencontre d'abord la boucle externe et exécute sa première itération. Cette première itération déclenche la boucle interne imbriquée, qui se termine ensuite à son terme. Ensuite, le programme retourne au sommet de la boucle externe, terminant la deuxième itération et déclenchant à nouveau la boucle imbriquée. Là encore, la boucle imbriquée s'exécute jusqu'à la fin et le programme revient en haut de la boucle externe jusqu'à ce que la séquence soit terminée ou qu'une instructionbreak ou autre perturbe le processus.

Implémentons une bouclefor imbriquée afin que nous puissions regarder de plus près. Dans cet exemple, la boucle externe parcourra une liste d'entiers appeléenum_list, et la boucle interne parcourra une liste de chaînes appeléealpha_list.

num_list = [1, 2, 3]
alpha_list = ['a', 'b', 'c']

for number in num_list:
    print(number)
    for letter in alpha_list:
        print(letter)

Lorsque nous exécuterons ce programme, nous recevrons le résultat suivant:

Output1
a
b
c
2
a
b
c
3
a
b
c

La sortie montre que le programme termine la première itération de la boucle externe en imprimant1, qui déclenche ensuite l'achèvement de la boucle interne, en imprimant lesa,b,c consécutivement . Une fois la boucle interne terminée, le programme retourne en haut de la boucle externe, imprime2, puis imprime à nouveau la boucle interne dans son intégralité (a,b,c) s), etc.

Les bouclesfor imbriquées peuvent être utiles pour parcourir des éléments dans des listes composées de listes. Dans une liste composée de listes, si nous n'utilisons qu'une seule bouclefor, le programme affichera chaque liste interne en tant qu'élément:

list_of_lists = [[hammerhead', 'great white', 'dogfish'],[0, 1, 2],[9.9, 8.8, 7.7]]

for list in list_of_lists:
    print(list)

Output['hammerhead', 'great white', 'dogfish']
[0, 1, 2]
[9.9, 8.8, 7.7]

Afin d'accéder à chaque élément individuel des listes internes, nous allons implémenter une bouclefor imbriquée:

list_of_lists = [[hammerhead', 'great white', 'dogfish'],[0, 1, 2],[9.9, 8.8, 7.7]]

for list in list_of_lists:
    for item in list:
        print(item)

Outputhammerhead
great white
dogfish
0
1
2
9.9
8.8
7.7

Lorsque nous utilisons une bouclefor imbriquée, nous pouvons parcourir les éléments individuels contenus dans les listes.

Nous pouvons voir les bouclesfor imbriquées en cours d'utilisation dans un programme de travail dans notre tutoriel sur lesNatural Language Processing Toolkit (NLTK).

Conclusion

Ce tutoriel a expliqué comment les bouclesfor fonctionnent en Python et comment les construire. For loops continue à parcourir un bloc de code fourni un certain nombre de fois.

À partir de là, vous pouvez continuer à en apprendre davantage sur la boucle en lisant des didacticiels surwhile loops etbreak, continue, and pass statements.

Pour utiliser les bouclesfor dans les projets, suivez les didacticiels suivants:

TOC