Cet article décrit comment utiliser la boucle for en Python.
- Les bases de la boucle for en Python
- pour l’instruction en Python
- Terminez la boucle for :
break - Passez au cycle suivant :
continue - Exécuter après l’arrêt normal :
else
- Fonctions utiles dans les instructions for
- Extraire seulement certains éléments : slice
- Compteur (indice) :
range() - Éléments et compteur :
enumerate() - Plusieurs listes :
zip() - Listes multiples et compteur :
enumerate(), zip() - Ordre inverse:
reversed() - Boucles imbriquées :
itertools.product()
- Autres sujets
- dict dans la déclaration
- Lister les compréhensions
Consultez l’article suivant pour une boucle avec une instruction while qui se répète tant que l’expression conditionnelle est True.
pour l’instruction en Python
Une instruction for (for-loop) dans de nombreux langages de programmation comme C est écrite à l’aide d’une variable de compteur et d’une condition de continuation.
for(int i = 0; i < 10; i++)
...
Contrairement à C, l’instruction for en Python s’écrit comme suit. Vous pouvez attribuer n’importe quel nom à la variable.
for variable in iterable object:
...
Correspondant à une instruction foreach dans d’autres langages, les éléments d’objets itérables tels que les listes sont séquentiellement affectés à des variables et traités. Le processus est répété pour tous les éléments.
l = ['Alice', 'Bob', 'Charlie']
for name in l:
print(name)
# Alice
# Bob
# Charlie
Terminez la boucle for :break
Vous pouvez terminer la boucle for par break.
l = ['Alice', 'Bob', 'Charlie']
for name in l:
if name == 'Bob':
print('!!BREAK!!')
break
print(name)
# Alice
# !!BREAK!!
Consultez l’article suivant pour plus de détails sur l’instruction if.
Passez au cycle suivant :continue
Vous pouvez ignorer le cycle et passer au suivant en continuant.
break termine l’intégralité de la boucle for, mais continue ne saute que le code après l’instruction continue dans le cycle.
l = ['Alice', 'Bob', 'Charlie']
for name in l:
if name == 'Bob':
print('!!SKIP!!')
continue
print(name)
# Alice
# !!SKIP!!
# Charlie
Exécuter après l’arrêt normal :else
Utilisez else pour exécuter quelque chose une fois la boucle for terminée avec succès.
l = ['Alice', 'Bob', 'Charlie']
for name in l:
print(name)
else:
print('!!FINISH!!')
# Alice
# Bob
# Charlie
# !!FINISH!!
Si la boucle for se termine par break, la suite de la clause else n’est pas exécutée.
for name in l:
if name == 'Bob':
print('!!BREAK!!')
break
print(name)
else:
print('!!FINISH!!')
# Alice
# !!BREAK!!
Dans le cas de continue, la suite de la clause else est exécutée.
for name in l:
if name == 'Bob':
print('!!SKIP!!')
continue
print(name)
else:
print('!!FINISH!!')
# Alice
# !!SKIP!!
# Charlie
# !!FINISH!!
En utilisant else et continue, vous pouvez sortir des boucles imbriquées (boucles multiples). Voir l’article suivant pour plus de détails.
Si vous souhaitez extraire uniquement certains éléments, spécifiez la plage avec une tranche comme [start:stop]. Pour le démarrage et l’arrêt, spécifiez l’index commençant par 0. Notez que l’élément à la position d’arrêt n’est pas inclus.
l = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
for c in l[2:5]:
print(c)
# C
# D
# E
Vous pouvez omettre start et stop, ou obtenir l’élément pour chaque étape avec [start:stop:step]. Un exemple d’extraction uniquement des éléments d’index impair et des éléments d’index pair est le suivant.
for c in l[::2]:
print(c)
# A
# C
# E
# G
for c in l[1::2]:
print(c)
# B
# D
# F
Consultez l’article suivant pour plus d’informations sur les tranches.
Compteur (indice) :range()
Vous pouvez obtenir le compteur (index) dans la boucle for par range().
for i in range(3):
print(i)
# 0
# 1
# 2
range() renvoie un objet de type range.
print(range(3))
print(type(range(3)))
# range(0, 3)
# <class 'range'>
Pour plus d’explications, convertissez-le en liste avec list(). Vous n’avez pas besoin de le convertir en liste lorsque vous l’utilisez dans une instruction for comme dans l’exemple ci-dessus.
range(stop) renvoie les nombres de 0 <= i <stop.
print(list(range(3)))
# [0, 1, 2]
print(list(range(6)))
# [0, 1, 2, 3, 4, 5]
Si vous souhaitez spécifier une plage, spécifiez deux arguments tels que range(start, stop).
print(list(range(10, 13)))
# [10, 11, 12]
Si vous souhaitez spécifier l’étape, spécifiez trois arguments tels que range(start, stop, step).
print(list(range(0, 10, 3)))
# [0, 3, 6, 9]
print(list(range(10, 0, -3)))
# [10, 7, 4, 1]
Voici un exemple d’instruction for.
for i in range(10, 0, -3):
print(i)
# 10
# 7
# 4
# 1
Voir l’article suivant pour plus de détails sur range().
Éléments et compteur :enumerate()
Vous pouvez obtenir l’élément et le compteur (index) simultanément par enumerate().
l = ['Alice', 'Bob', 'Charlie']
for name in l:
print(name)
# Alice
# Bob
# Charlie
for i, name in enumerate(l):
print(i, name)
# 0 Alice
# 1 Bob
# 2 Charlie
Une valeur de départ peut être spécifiée comme second argument de enumerate().
for i, name in enumerate(l, 1):
print(i, name)
# 1 Alice
# 2 Bob
# 3 Charlie
for i, name in enumerate(l, 42):
print(i, name)
# 42 Alice
# 43 Bob
# 44 Charlie
enumerate() n’a pas d’argument pour spécifier l’étape comme range(), mais cela peut être fait comme suit.
step = 3
for i, name in enumerate(l):
print(i * step, name)
# 0 Alice
# 3 Bob
# 6 Charlie
Plusieurs listes :zip()
Plusieurs objets itérables peuvent être gérés par zip().
names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]
for name, age in zip(names, ages):
print(name, age)
# Alice 24
# Bob 50
# Charlie 18
Il est également possible de combiner trois objets itérables ou plus.
points = [100, 85, 90]
for name, age, point in zip(names, ages, points):
print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 90
Consultez l’article suivant pour plus de détails, par exemple lorsque le nombre d’éléments est différent.
Comme dans l’exemple ci-dessus, zip() renvoie les éléments de plusieurs objets itérables dans l’ordre. Si vous souhaitez obtenir toutes les combinaisons d’éléments de plusieurs objets itérables, utilisez itertools.product() décrit plus tard.
Listes multiples et compteur :enumerate(), zip()
Vous pouvez utiliser enumerate() et zip() ensemble. Notez que les noms de variable entiers pour zip() doivent être placés entre parenthèses ().
names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]
for i, (name, age) in enumerate(zip(names, ages)):
print(i, name, age)
# 0 Alice 24
# 1 Bob 50
# 2 Charlie 18
Ordre inverse:reversed()
Vous pouvez obtenir les éléments d’un objet itérable dans l’ordre inverse par reversed().
l = ['Alice', 'Bob', 'Charlie']
for name in reversed(l):
print(name)
# Charlie
# Bob
# Alice
L’objet plage peut également être inversé. Vous pouvez spécifier une valeur négative pour step sans utiliser reversed().
for i in reversed(range(3)):
print(i)
# 2
# 1
# 0
for i in range(2, -1, -1):
print(i)
# 2
# 1
# 0
L’objet d’énumération ne peut pas être inversé. Vous devez le convertir en liste avec list().
# for i, name in reversed(enumerate(l)):
# print(i, name)
# TypeError: 'enumerate' object is not reversible
for i, name in reversed(list(enumerate(l))):
print(i, name)
# 2 Charlie
# 1 Bob
# 0 Alice
Si vous ne voulez pas inverser l’index, utilisez reversed() dans enumerate().
for i, name in enumerate(reversed(l)):
print(i, name)
# 0 Charlie
# 1 Bob
# 2 Alice
L’objet zip ne peut pas être inversé. Vous devez le convertir en liste avec list().
l2 = [24, 50, 18]
# for name, age in reversed(zip(l, l2)):
# print(name, age)
# TypeError: 'zip' object is not reversible
for name, age in reversed(list(zip(l, l2))):
print(name, age)
# Charlie 18
# Bob 50
# Alice 24
Vous pouvez écrire des boucles imbriquées en Python comme suit. En Python, les blocs sont représentés par des retraits, il suffit donc d’ajouter plus de retraits.
l1 = [1, 2, 3]
l2 = [10, 20, 30]
for i in l1:
for j in l2:
print(i, j)
# 1 10
# 1 20
# 1 30
# 2 10
# 2 20
# 2 30
# 3 10
# 3 20
# 3 30
Vous pouvez obtenir le même résultat avec itertools.product().
import itertools
l1 = [1, 2, 3]
l2 = [10, 20, 30]
for i, j in itertools.product(l1, l2):
print(i, j)
# 1 10
# 1 20
# 1 30
# 2 10
# 2 20
# 2 30
# 3 10
# 3 20
# 3 30
Il est également possible de passer trois itérables ou plus comme arguments à itertools.product(). Voir l’article suivant pour plus de détails.
Si vous souhaitez sortir de la boucle à l’intérieur des multiples boucles avec break, il est facile d’utiliser itertools.product().
dict dans la déclaration
L’objet dict dans l’instruction for renvoie des clés.
d = {'key1': 1, 'key2': 2, 'key3': 3}
for k in d:
print(k)
# key1
# key2
# key3
Si vous souhaitez obtenir des valeurs ou des paires clé-valeur, utilisez values() et items().
for v in d.values():
print(v)
# 1
# 2
# 3
for k, v in d.items():
print(k, v)
# key1 1
# key2 2
# key3 3
Voir l’article suivant pour plus de détails.
Lister les compréhensions
Pour générer une nouvelle liste en traitant les éléments d’objets itérables, il est plus simple d’écrire en utilisant des compréhensions de liste que l’instruction for.
La compréhension de la liste s’écrit comme suit.
[expression for variable_name in iterable]
Voici des exemples de compréhensions de liste et d’instruction for. Les compréhensions de liste sont plus concises.
squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]
squares = []
for i in range(5):
squares.append(i**2)
print(squares)
# [0, 1, 4, 9, 16]
Consultez l’article suivant pour plus de détails sur les compréhensions de liste.