Boucles while, break et continue

Répéter tant qu'une condition est vraie

Une boucle while vérifie une condition avant chaque tour et exécute son bloc tant que la condition est True. Utilisez-la quand vous ne savez pas à l'avance combien de tours il faut : diviser un ordre par deux jusqu'à ce qu'il soit assez petit, attendre qu'un prix franchisse un niveau, faire croître un solde jusqu'à un objectif. Quelque chose dans le bloc doit modifier la condition, sinon la boucle ne se termine jamais.

# Halve an order until it is small enough to trade at once
quantity, limit = 1000, 100
steps = 0
while quantity > limit:
    quantity = quantity / 2
    steps += 1
print(steps, quantity)  # 4 62.5

for ou while ?

Utilisez for quand vous avez déjà les éléments ou connaissez leur nombre : il ne peut pas tourner indéfiniment. Utilisez while quand le point d'arrêt dépend de ce qui se passe pendant la boucle. Un bon test : si vous pouvez dire « pour chacun de ceux-ci », écrivez for ; si vous dites « jusqu'à ce que ceci devienne vrai », écrivez while.

break : quitter la boucle tout de suite

break met fin à la boucle sur-le-champ et poursuit avec la ligne qui la suit. C'est le moyen de s'arrêter dès que vous avez votre réponse, comme le premier prix qui franchit une limite. Ici, la boucle parcourt des positions avec un indice qu'elle incrémente elle-même.

# break leaves the loop at once
prices = [184.25, 184.5, 186.0, 185.0]
limit = 185.5
index = 0
while index < len(prices):
    if prices[index] > limit:
        print("breach at", index)  # breach at 2
        break
    index += 1

continue : passer au tour suivant

continue saute le reste du tour en cours et retourne à la condition. C'est pratique pour ignorer des données invalides sans imbriquer le vrai travail dans un if. Dans une boucle while, modifiez la variable de boucle avant continue ; sinon la boucle retombe indéfiniment sur le même élément.

# continue skips the rest of the pass; step first, or it never moves on
fills = [100, -5, 250, 0, 75]
total = 0
index = 0
while index < len(fills):
    value = fills[index]
    index += 1
    if value <= 0:
        continue
    total += value
print(total)  # 425

Des boucles qui cherchent ou convergent

De nombreuses tâches de quant sont du type « continuer jusqu'à ce que » : capitaliser jusqu'à un objectif, affiner une estimation jusqu'à ce qu'elle ne bouge plus, réessayer jusqu'à ce qu'une requête réussisse. while True: avec un break au milieu est une forme courante quand le test de sortie se place au milieu du travail.

# How many years until 10,000 grows to 15,000 at 7% a year?
balance, target, rate = 10_000, 15_000, 0.07
years = 0
while balance < target:
    balance = balance * (1 + rate)
    years += 1
print(years)  # 6

# while True + break: the exit test sits in the middle
attempt = 0
while True:
    attempt += 1
    if attempt * 25 >= 100:
        break
print(attempt)  # 4

• La condition utilise une variable que la boucle modifie.
• La modification a lieu à chaque tour, même avant un continue.
• Utilisez break dès que la réponse est connue.

À suivre : définir et appeler des fonctions, pour donner un nom à un bloc de code et le réutiliser.

Lab : ce qui est noté

• Compter les divisions par deux d'un ordre avec halving_steps25 pts
• Trouver le premier prix au-dessus d'une limite avec first_breach25 pts
• Additionner les exécutions valides jusqu'au marqueur de fin avec sum_until_zero25 pts
• Capitaliser un solde jusqu'à un objectif avec years_to_target25 pts