Comment quitter une clause if

Quelles sortes de méthodes existent pour sortir prématurément d'une ifclause?

Il y a des moments où j'écris du code et que je veux mettre une breakinstruction à l'intérieur d'une ifclause, seulement pour me rappeler que ceux-ci ne peuvent être utilisés que pour les 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 faire cela: en supposant que les cas de sortie se produisent dans des instructions if imbriquées, enveloppez 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 signifie plus de code d'imbrication / indenté.

Alternativement, je pourrais écrire mon code pour que les ifclauses soient aussi petites que possible et ne nécessitent aucune sortie.

Quelqu'un connaît-il une bonne / meilleure façon de sortir d'une ifclause?

S'il y a des clauses else-if et else associées, je suppose que quitter les ignorerait.

(Cette méthode fonctionne pour les ifs, plusieurs boucles imbriquées et d'autres constructions que vous ne pouvez pas breakfacilement.)

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 une_condition:
   ...
   si condition_a:
       # faire quelque chose
       # puis quittez le bloc if externe
       aller .end
   ...
   si condition_b:
       # faire quelque chose
       # puis quittez le bloc if externe
       aller .end
   # plus de code ici

label .end

(Ne l'utilisez pas vraiment, 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 les fonctionnalités de goto avec des exceptions:

try:
    # blah, blah ...
    # raise MyFunkyException as soon as you want out
except MyFunkyException:
    pass

Clause de non-responsabilité: Je veux seulement attirer votre attention sur la possibilité de faire les choses de cette manière, alors que je ne le considère en aucun cas comme raisonnable dans des circonstances normales. Comme je l'ai mentionné dans un commentaire sur la question, structurer le code de manière à éviter les conditionnelles byzantines en premier lieu 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

Pour ce qui a été réellement demandé, mon approche est de mettre ces ifs dans une boucle en une seule 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 général, ne le faites pas. Si vous imbriquez des «si» et que vous vous en débarrassez, 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 évitera d'avoir à refactoriser un si / puis laid plus tard.

En fait, ce que vous décrivez sont des déclarations goto, qui sont généralement assez fortement analysé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

Il existe un autre moyen qui ne repose pas sur la définition de fonctions (car parfois c'est moins lisible pour les petits extraits de code), n'utilise pas une 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 vous permet de garder votre niveau d'indentation pour l'extérieur si c'est le cas, vous n'avez pas à commencer à imbriquer des choses.

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 regard pour la lisibilité, cependant, si les extraits de code sont petits, cela ne nécessite pas de suivre des boucles while qui ne se répéteront jamais et après avoir compris à quoi servent les ifs intermédiaires, il est facilement lisible, tout en un endroit et avec la même indentation.

Et cela devrait être assez efficace.

Alors là, je comprends que vous essayez de sortir du bloc de code externe si

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 façon de s'en sortir est que vous pouvez tester une condition fausse dans le bloc if externe, qui sortira ensuite 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

La seule chose qui appliquerait cela sans méthodes supplémentaires est elifl'exemple suivant

a = ['yearly', 'monthly', 'quartly', 'semiannual', 'monthly', 'quartly', 'semiannual', 'yearly']
# start the condition
if 'monthly' in b: 
    print('monthly') 
elif 'quartly' in b: 
    print('quartly') 
elif 'semiannual' in b: 
    print('semiannual') 
elif 'yearly' in b: 
    print('yearly') 
else: 
    print('final') 

Voici une autre façon de gérer cela. Il utilise un seul élément pour la boucle qui vous permet d'utiliser simplement continuer. Cela évite le besoin inutile d'avoir des fonctions supplémentaires sans raison. Et élimine en outre les boucles while potentielles infinies.

if something:
    for _ in [0]:
        # Get x
        if not x:
            continue

        # Get y
        if not y:
            continue

        # Get z
        if not z:
            continue

        # Stuff that depends on x, y, and z

utiliser returndans la condition if vous fera sortir de la fonction, de sorte que vous puissiez utiliser return pour rompre la condition if.