Python Language
Boucles

Introduction

Syntaxe

• while <expression booléenne>:
• pour <variable> dans <iterable>:
• pour <variable> dans la plage (<nombre>):
• pour <variable> dans la plage (<numéro_premier>, <numéro_final>):
• pour <variable> dans la plage (<numéro_premier>, <numéro_endmin>, <taille_touche>):
• pour i, <variable> en enumerate (<iterable>): # avec index i
• pour <variable1>, <variable2> dans zip (<iterable1>, <iterable2>):

Paramètres

Itération sur les listes

Pour parcourir une liste, vous pouvez utiliser for :

for x in ['one', 'two', 'three', 'four']:
    print(x)

Cela imprimera les éléments de la liste:

one
two
three
four

La fonction range génère des nombres qui sont également souvent utilisés dans une boucle for.

for x in range(1, 6):
    print(x)

Le résultat sera un type de séquence de plage spécial dans python> = 3 et une liste dans python <= 2. Les deux peuvent être bouclés en utilisant la boucle for.

1
2
3
4
5

Si vous voulez effectuer une boucle à la fois sur les éléments d'une liste et avoir un index pour les éléments, vous pouvez utiliser la fonction d' enumerate de Python:

for index, item in enumerate(['one', 'two', 'three', 'four']):
    print(index, '::', item)

enumerate va générer des tuples, décompressés en index (entier) et en item (valeur réelle de la liste). La boucle ci-dessus s'imprimera

(0, '::', 'one')
(1, '::', 'two')
(2, '::', 'three')
(3, '::', 'four')

Itérer sur une liste avec manipulation de valeur en utilisant map et lambda , c'est-à-dire appliquer la fonction lambda sur chaque élément de la liste:

x = map(lambda e :  e.upper(), ['one', 'two', 'three', 'four'])
print(x)

Sortie:

['ONE', 'TWO', 'THREE', 'FOUR'] # Python 2.x

NB: dans Python 3.x, la map retourne un itérateur au lieu d'une liste, donc vous devez, si vous avez besoin d'une liste, lancer l' print(list(x)) du résultat print(list(x)) (voir http://www.riptutorial.com/python/ exemple / 8186 / map-- dans http://www.riptutorial.com/python/topic/809/incompatibilities-moving-from-python-2-to-python-3 ).

Pour les boucles

for boucles, parcourez une collection d'éléments, tels que list ou dict , et exécutez un bloc de code avec chaque élément de la collection.

for i in [0, 1, 2, 3, 4]:
    print(i)

Le ci-dessus for boucle itère sur une liste de nombres.

Chaque itération définit la valeur de i sur l'élément suivant de la liste. Donc, d'abord, il sera 0 , puis 1 , puis 2 , etc. La sortie sera la suivante:

0  
1
2
3
4

range est une fonction qui renvoie une série de nombres sous une forme itérable, ainsi elle peut être utilisée for boucles:

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

donne exactement le même résultat que le premier for boucle. Notez que 5 n'est pas imprimé car la plage représente les cinq premiers chiffres à partir de 0 .

Objets à parcourir et itérateurs

for loop peut itérer sur tout objet itérable qui est un objet qui définit une fonction __getitem__ ou __iter__ . La fonction __iter__ renvoie un itérateur, qui est un objet avec une fonction next utilisée pour accéder à l'élément suivant de l'itérable.

Pause et continuer dans les boucles

déclaration de break

Lorsqu'une instruction break s'exécute dans une boucle, le flux de contrôle "se casse" immédiatement de la boucle:

i = 0
while i < 7:
    print(i)
    if i == 4:
        print("Breaking from loop")
        break
    i += 1

La condition conditionnelle ne sera pas évaluée après l'exécution de l'instruction break . Notez que les instructions break ne sont autorisées qu'à l' intérieur des boucles , syntaxiquement. Une instruction break dans une fonction ne peut pas être utilisée pour mettre fin aux boucles appelées cette fonction.

L'exécution de la commande suivante imprime chaque chiffre jusqu'au numéro 4 lorsque l'instruction de break est remplie et que la boucle s'arrête:

0
1
2
3
4
Breaking from loop

break instructions break peuvent également être utilisées à l'intérieur for boucles, l'autre construction en boucle fournie par Python:

for i in (0, 1, 2, 3, 4):
    print(i)
    if i == 2:
        break

L'exécution de cette boucle imprime maintenant:

0
1
2

Notez que 3 et 4 ne sont pas imprimés depuis la fin de la boucle.

Si une boucle a une clause else , elle ne s'exécute pas lorsque la boucle est terminée par une instruction break .

continue déclaration

Une instruction continue passera à la prochaine itération de la boucle en contournant le reste du bloc en cours mais en continuant la boucle. Comme avec break , continue ne peut apparaître qu'à l'intérieur des boucles:

for i in (0, 1, 2, 3, 4, 5):
    if i == 2 or i == 4:
        continue
    print(i)

0
1
3
5

Notez que 2 et 4 ne sont pas imprimés, c'est parce que continue va à l'itération suivante au lieu de continuer à print(i) quand i == 2 ou i == 4 .

Boucles imbriquées

break and continue ne fonctionne que sur un seul niveau de boucle. L'exemple suivant ne sortir de l'intérieur for la boucle, et non l'extérieur while boucle:

while True:
    for i in range(1,5):
        if i == 2:
            break    # Will only break out of the inner loop!

Python n'a pas la capacité de sortir de plusieurs niveaux de boucle à la fois - si ce comportement est souhaité, le remaniement d'une ou de plusieurs boucles dans une fonction et le remplacement de la break avec le return peuvent être la solution.

Utiliser le return d'une fonction comme une break

L' instruction return quitte une fonction sans exécuter le code qui suit.

Si vous avez une boucle dans une fonction, utiliser return depuis l'intérieur de cette boucle équivaut à avoir une break car le reste du code de la boucle n'est pas exécuté ( notez que tout code après la boucle n'est pas exécuté non plus ):

def break_loop():
    for i in range(1, 5):
        if (i == 2):
            return(i)
        print(i)
    return(5)

Si vous avez des boucles imbriquées, l'instruction return interrompt toutes les boucles:

def break_all():
    for j in range(1, 5):
        for i in range(1,4):
            if i*j == 6:
                return(i)
            print(i*j)

va sortir:

1 # 1*1
2 # 1*2
3 # 1*3
4 # 1*4
2 # 2*1
4 # 2*2
# return because 2*3 = 6, the remaining iterations of both loops are not executed

Boucles avec une clause "else"

Les instructions composites for while ) peuvent avoir une clause else (en pratique, cette utilisation est assez rare).

L' else clause exécute seulement après une for la boucle se termine par itérer jusqu'à la fin, ou après un while boucle se termine par son expression conditionnelle devient fausse.

for i in range(3):
    print(i)
else:
    print('done')

i = 0
while i < 3:
    print(i)
    i += 1
else:
    print('done')

sortie:

 0
 1
 2
 done

La clause else ne s'exécute pas si la boucle se termine d'une autre manière (via une instruction break ou en levant une exception):

for i in range(2):
    print(i)
    if i == 1:
        break
else:
    print('done')

sortie:

0
1

La plupart des autres langages de programmation ne disposent pas de cette clause facultative else de boucles. L'utilisation du mot clé else en particulier est souvent considérée comme source de confusion.

Le concept original d'une telle clause remonte à Donald Knuth et la signification du mot clé else devient claire si nous réécrivons une boucle en termes d'instructions if et goto des jours précédents avant la programmation structurée ou à partir d'un langage d'assemblage de niveau inférieur.

Par exemple:

while loop_condition():
    ...
    if break_condition():
        break
    ...

est équivalent à:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>

<<end>>:

Celles-ci restent équivalentes si nous attachons une clause else à chacune d’elles.

Par exemple:

while loop_condition():
    ...
    if break_condition():
        break
    ...
else:
    print('done')

est équivalent à:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>
else:
    print('done')

<<end>>:

Une boucle for avec une clause else peut être comprise de la même façon. D'un point de vue conceptuel, il existe une condition de boucle qui reste vraie tant que l'objet ou la séquence itérable contient encore quelques éléments.

Pourquoi utiliserait cette construction étrange?

Le principal cas d'utilisation de la construction for...else est une implémentation concise de la recherche, par exemple:

a = [1, 2, 3, 4]
for i in a:
    if type(i) is not int:
        print(i)
        break
else:
    print("no exception") 

Pour rendre le else dans cette construction moins déroutant, on peut le considérer comme " sinon casser " ou " si non trouvé ".

Quelques discussions à ce sujet peuvent être trouvées dans [Python-ideas] Résumé de pour ... Threads , Pourquoi python utilise-t-il les boucles after pour et while? et autres clauses sur les instructions de boucle

Itération sur les dictionnaires

Considérant le dictionnaire suivant:

 d = {"a": 1, "b": 2, "c": 3}

Pour parcourir ses clés, vous pouvez utiliser:

for key in d:
    print(key)

Sortie:

"a"
"b"
"c"

Ceci est équivalent à:

for key in d.keys():
    print(key)

ou en Python 2:

for key in d.iterkeys():
    print(key)

Pour parcourir ses valeurs, utilisez:

for value in d.values():
    print(value)

Sortie:

1
2
3

Pour parcourir ses clés et ses valeurs, utilisez:

for key, value in d.items():
    print(key, "::", value)

Sortie:

a :: 1
b :: 2
c :: 3

Notez que dans Python 2, .keys() , .values() et .items() renvoient un objet list . Si vous devez simplement parcourir le résultat, vous pouvez utiliser les équivalents .iterkeys() , .itervalues() et .iteritems() .

La différence entre .keys() et .iterkeys() , .values() et .itervalues() , .items() et .iteritems() est que les méthodes iter* sont des générateurs. Ainsi, les éléments du dictionnaire sont fournis un par un au fur et à mesure de leur évaluation. Lorsqu'un objet list est renvoyé, tous les éléments sont regroupés dans une liste, puis renvoyés pour une évaluation ultérieure.

Notez également que dans Python 3, l'ordre des éléments imprimés de la manière ci-dessus ne suit aucun ordre.

En boucle

A while boucle ramènerai les instructions de boucle à exécuter jusqu'à ce que la condition de la boucle est Falsey . Le code suivant exécutera les instructions de boucle 4 fois au total.

i = 0 
while i < 4:
    #loop statements
    i = i + 1

Alors que la boucle ci-dessus peut facilement être convertie en une boucle for élégante, while boucles sont utiles pour vérifier si certaines conditions ont été remplies. La boucle suivante continuera à s'exécuter jusqu'à myObject que myObject soit prêt.

myObject = anObject()
while myObject.isNotReady():
    myObject.tryToGetReady()

while boucles while peuvent également s'exécuter sans condition en utilisant des nombres (complexes ou réels) ou True :

import cmath

complex_num = cmath.sqrt(-1)
while complex_num:      # You can also replace complex_num with any number, True or a value of any type
    print(complex_num)   # Prints 1j forever

Si la condition est toujours vraie, la boucle while sera exécutée pour toujours (boucle infinie) si elle n'est pas terminée par une instruction break ou return ou une exception.

while True:
    print "Infinite loop"
# Infinite loop
# Infinite loop
# Infinite loop
# ...

La déclaration de passage

pass est une instruction vide pour lorsqu'une instruction est requise par la syntaxe python (comme dans le corps d'un for ou while la boucle), mais aucune action est nécessaire ou souhaitée par le programmeur. Cela peut être utile comme espace réservé pour le code qui doit encore être écrit.

for x in range(10):
    pass #we don't want to do anything, or are not ready to do anything here, so we'll pass

Dans cet exemple, rien ne se passera. La boucle for se terminera sans erreur, mais aucune commande ou code ne sera activé. pass nous permet d'exécuter notre code avec succès sans que toutes les commandes et actions soient complètement implémentées.

De même, pass peut être utilisé dans les boucles while , ainsi que dans les sélections et les définitions de fonctions, etc.

while x == y:
    pass

Itérer différentes parties d'une liste avec différentes tailles de pas

Supposons que vous ayez une longue liste d'éléments et que vous ne soyez intéressé que par tous les autres éléments de la liste. Vous souhaitez peut-être examiner uniquement le premier ou le dernier élément, ou une plage spécifique d'entrées dans votre liste. Python possède de puissantes fonctionnalités intégrées d'indexation. Voici quelques exemples de réalisation de ces scénarios.

Voici une liste simple qui sera utilisée dans tous les exemples:

lst = ['alpha', 'bravo', 'charlie', 'delta', 'echo']

Itération sur toute la liste

Pour parcourir chaque élément de la liste, une boucle for comme ci-dessous peut être utilisée:

for s in lst:
    print s[:1] # print the first letter

La boucle for assigne des s à chaque élément de lst . Cela va imprimer:

a
b
c
d
e

Vous avez souvent besoin à la fois de l'élément et de l'index de cet élément. Le mot clé enumerate exécute cette tâche.

for idx, s in enumerate(lst):
    print("%s has an index of %d" % (s, idx))

L'index idx commencera par zéro et par incrément pour chaque itération, tandis que le s contiendra l'élément en cours de traitement. L'extrait de code précédent affichera:

alpha has an index of 0
bravo has an index of 1
charlie has an index of 2
delta has an index of 3
echo has an index of 4

Itérer sur la sous-liste

Si vous souhaitez effectuer une itération sur une plage (en vous rappelant que Python utilise l'indexation basée sur zéro), utilisez le mot clé range .

for i in range(2,4):
    print("lst at %d contains %s" % (i, lst[i]))

Cela produirait:

lst at 2 contains charlie
lst at 3 contains delta

La liste peut également être tranchée. La notation de tranche suivante va d'un élément à l'index 1 à la fin avec un pas de 2. Les deux for boucles donnent le même résultat.

for s in lst[1::2]:
    print(s)

for i in range(1, len(lst), 2):
    print(lst[i])

Les extraits de code ci-dessus:

bravo
delta

L'indexation et le découpage sont un sujet à part.

Le "demi-boucle" à faire

Contrairement à d'autres langages, Python n'a pas de construction à faire ou à faire (cela permettra l'exécution du code une fois avant le test de la condition). Cependant, vous pouvez combiner un while True avec un break pour atteindre le même objectif.

a = 10
while True:
    a = a-1
    print(a)
    if a<7:
        break
print('Done.')

Cela va imprimer:

9
8
7
6
Done.

En boucle et déballage

Si vous souhaitez parcourir une liste de tuples par exemple:

collection = [('a', 'b', 'c'), ('x', 'y', 'z'), ('1', '2', '3')]

au lieu de faire quelque chose comme ça:

for item in collection:
    i1 = item[0]
    i2 = item[1]
    i3 = item[2]
    # logic

ou quelque chose comme ça:

for item in collection:
    i1, i2, i3 = item
    # logic

Vous pouvez simplement faire ceci:

for i1, i2, i3 in collection:
    # logic

Cela fonctionnera également pour la plupart des types d'itérables, pas seulement les tuples.