Comment sortir d'une clause if
Quelles sortes de méthodes existent pour sortir prématurément d'une clause if?
Il arrive que, lorsque j'écris du code et que je veuille insérer une instruction break dans une clause if, je me souvienne seulement que ceux-ci ne peuvent être utilisés que pour des boucles.
Prenons le code suivant comme exemple:
if some_condition:
...
if condition_a:
# do something
# and then exit the outer if block
...
if condition_b:
# do something
# and then exit the outer if block
# more code here
Je peux penser à une façon de procéder: en supposant que les cas de sortie se produisent dans des instructions if imbriquées, encapsulez le code restant dans un gros bloc else. Exemple:
if some_condition:
...
if condition_a:
# do something
# and then exit the outer if block
else:
...
if condition_b:
# do something
# and then exit the outer if block
else:
# more code here
Le problème avec ceci est que plus d'emplacements de sortie signifient plus de code imbriqué/en retrait.
Alternativement, je pourrais écrire mon code pour que les clauses if soient aussi petites que possible et ne nécessitent aucune sortie.
Est-ce que quelqu'un connaît un bon/meilleur moyen de sortir d'une clause if?
S'il y a des clauses associées-if et else, je pense que les renvoyer passeraient par-dessus.
(Cette méthode fonctionne pour ifs, plusieurs boucles imbriquées et autres constructions que vous ne pouvez pas break facilement.)
Enveloppez le code dans sa propre fonction. Au lieu de break, utilisez return.
Exemple:
def some_function():
if condition_a:
# do something and return early
...
return
...
if condition_b:
# do something else and return early
...
return
...
return
if outer_condition:
...
some_function()
...
de goto import goto, label si quelque condition: ... si condition_a: # faire quelque chose # puis quittez le bloc if si extérieur goto .end ... si condition_b: # faire quelque chose # puis quittez le bloc if si extérieur goto .end # plus de code ici label .end
(Ne l'utilisez pas réellement, s'il vous plaît.)
while some_condition:
...
if condition_a:
# do something
break
...
if condition_b:
# do something
break
# more code here
break
Vous pouvez émuler la fonctionnalité de goto avec des exceptions:
try:
# blah, blah ...
# raise MyFunkyException as soon as you want out
except MyFunkyException:
pass
Déni de responsabilité: Je veux seulement attirer votre attention sur la possibilité de faire les choses de cette façon, bien que je ne soutienne en aucune manière que cela soit raisonnable dans des circonstances normales. Comme je l'ai mentionné dans un commentaire sur la question, la structuration du code de manière à éviter les conditions byzantines est de loin préférable. :-)
peut être ça?
if some_condition and condition_a:
# do something
Elif some_condition and condition_b:
# do something
# and then exit the outer if block
Elif some_condition and not condition_b:
# more code here
else:
#blah
if
De manière générale, ne le faites pas. Si vous imbriquez des "si" et que vous vous en séparez, vous le faites mal.
Cependant, si vous devez:
if condition_a:
def condition_a_fun():
do_stuff()
if we_wanna_escape:
return
condition_a_fun()
if condition_b:
def condition_b_fun():
do_more_stuff()
if we_wanna_get_out_again:
return
condition_b_fun()
Notez que les fonctions NE DOIVENT PAS être déclarées dans l'instruction if, elles peuvent être déclarées à l'avance;) Ce serait un meilleur choix, car cela éviterait de devoir refactoriser plus tard si c'est très laid.
Pour ce qui a été demandé, mon approche consiste à placer ces ifs dans une boucle à une boucle.
while (True):
if (some_condition):
...
if (condition_a):
# do something
# and then exit the outer if block
break
...
if (condition_b):
# do something
# and then exit the outer if block
break
# more code here
# make sure it is looped once
break
Essaye-le:
conditions = [True,False]
some_condition = True
for condition_a in conditions:
for condition_b in conditions:
print("\n")
print("with condition_a", condition_a)
print("with condition_b", condition_b)
while (True):
if (some_condition):
print("checkpoint 1")
if (condition_a):
# do something
# and then exit the outer if block
print("checkpoint 2")
break
print ("checkpoint 3")
if (condition_b):
# do something
# and then exit the outer if block
print("checkpoint 4")
break
print ("checkpoint 5")
# more code here
# make sure it is looped once
break
En réalité, ce que vous décrivez sont des déclarations goto, qui sont généralement très sollicitées. Votre deuxième exemple est beaucoup plus facile à comprendre.
Cependant, plus propre serait toujours:
if some_condition:
...
if condition_a:
your_function1()
else:
your_function2()
...
def your_function2():
if condition_b:
# do something
# and then exit the outer if block
else:
# more code here
utiliser return dans la condition if vous renvoie à la fonction, .__, afin que vous puissiez utiliser return pour rompre la condition if.
Il existe un autre moyen qui ne repose pas sur la définition de fonctions (car parfois, cela est moins lisible pour de petits extraits de code), n'utilise pas de boucle while externe supplémentaire (qui peut nécessiter une appréciation particulière dans les commentaires pour être même compréhensible à première vue) , n'utilise pas goto (...) et, surtout, conservez votre niveau d'indentation pour l'extérieur si vous n'avez pas à commencer à imbriquer des éléments.
if some_condition:
...
if condition_a:
# do something
exit_if=True # and then exit the outer if block
if some condition and not exit_if: # if and only if exit_if wasn't set we want to execute the following code
# keep doing something
if condition_b:
# do something
exit_if=True # and then exit the outer if block
if some condition and not exit_if:
# keep doing something
Oui, cela nécessite également un deuxième coup d'œil pour la lisibilité, cependant, si les extraits de code sont petits, cela ne nécessite pas de suivre les boucles while qui ne se répéteront jamais et après avoir compris à quoi servent les ifs intermédiaires, il est facilement lisible un endroit et avec la même indentation.
Et ça devrait être assez efficace.
Donc, je comprends que vous essayez de sortir de l’extérieur si le bloc de code
if some_condition:
...
if condition_a:
# do something
# and then exit the outer if block
...
if condition_b:
# do something
# and then exit the outer if block
# more code here
Une solution consiste à rechercher une condition fausse dans le bloc if externe, qui sortira alors implicitement du bloc de code. Vous utiliserez ensuite un bloc else pour imbriquer les autres ifs pour faire quelque chose
if test_for_false:
# Exit the code(which is the outer if code)
else:
if condition_a:
# Do something
if condition_b:
# Do something