Si vous voulez faire quelque chose avec une variable foo! = 5, ayant la valeur initiale 5 (par exemple).
Est-ce que quelqu'un connaît une manière plus propre de le faire? Une façon est:
def try1():
foo = 5
aux = False
while (foo != 5) or (aux == False):
aux = True
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
3 Réponses :
Utilisez une boucle infinie qui rompt explicitement si la condition est vraie à la extrémité em> du corps. def try1():
foo = 5
while True:
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
if foo == 5:
break
Si vous recherchez une structure de répétition jusqu'à, il n'y en a pas en Python. Mais vous pouvez obtenir quelque chose de similaire en créant un itérateur. Vous pouvez ensuite utiliser cet itérateur dans une instruction for _ in ... pour obtenir le comportement souhaité.
def loopUntilFalse(): # used in while loop(...):
firstTime = [True]
def loop(condition):
return (firstTime and not firstTime.clear()) or condition
return loop
foo = 5
outcome = loopUntilFalse()
while outcome(foo!=5):
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
Ou repeatWhile () si vous voulez exprimer la suite condition au lieu de la condition d'arrêt. (dans les deux cas, la condition sera testée à la fin de la boucle)
def loopUntilTrue(): # used in while not loop(...):
firstTime = [True]
def loop(condition):
return (not firstTime or firstTime.clear()) and condition
return loop
foo = 5
reached = loopUntilTrue()
while not reached(foo==5):
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
Notez que cette approche fournira un traitement approprié de continue où as while True: ... if foo == 5: break nécessiterait un code supplémentaire (et une attention particulière).
Par exemple:
foo = 5
while True:
foo = (random.randint(1,100) // (foo +1)) +1
if someCondition == True: continue # loop will not stop even if foo == 5
print(foo)
if foo == 5: break
Qu'entendez-vous par «traitement approprié de la poursuite», et pourquoi l'autre approche ne ferait-elle pas cela?
Si vous avez while True et if foo == 5: break à la dernière ligne du bloc d'instructions, utiliser continue n'importe où dans ces instructions n'exécuterait pas la dernière ligne et n'arrêterait donc pas correctement la boucle while (provoquant potentiellement une boucle infinie)
Un autre moyen propre de le faire est d'évaluer la déclaration une fois avant la boucle.
def try1():
foo = 5
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
while foo != 5:
foo = (random.randint(1,100) // (foo +1)) +1
print(foo)
Il n'est pas tout à fait clair pourquoi vous voudriez exécuter la boucle au moins une fois si la valeur initiale est déjà une valeur acceptable pour les itérations ultérieures. La seule différence entre cette boucle et
tandis que foo! = 5est qu'elle avance le générateur de nombres aléatoires d'au moins une valeur.Je ne pense pas que cela compte, mais si vous êtes curieux d'imaginer avoir un réseau de 5 nœuds, vous voulez arrêter le cycle lorsque vous trouvez un chemin qui atteint à nouveau le premier nœud. par exemple. 1-4-2-3-1 fin du cycle. L'exemple que j'ai donné était simplement illustratif pour éviter d'ajouter plus de code
OK, dans ce cas, vous voudrez probablement accumuler les valeurs de
foodans une liste, pas seulement les imprimer.foo = [5].Je sais, c'est ce que je fais dans mon code, j'ai littéralement écrit ce code juste pour montrer l'exemple du problème que j'ai posé. Le vrai code est plus gros et plus déroutant
Dans ce cas, vous avez trop simplifié par inadvertance; Vous avez débarrassé de la raison pour laquelle vous devez répéter la boucle au moins une fois :)