So beenden Sie eine if-Klausel

Welche Methoden gibt es, um eine ifKlausel vorzeitig zu beenden ?

Es gibt Zeiten, in denen ich Code schreibe und eine breakAnweisung in eine ifKlausel einfügen möchte , nur um mich daran zu erinnern, dass diese nur für Schleifen verwendet werden können.

Nehmen wir als Beispiel den folgenden 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

Ich kann mir einen Weg vorstellen, dies zu tun: Angenommen, die Exit-Fälle treten in verschachtelten if-Anweisungen auf, verpacken Sie den verbleibenden Code in einen großen else-Block. Beispiel:

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

Das Problem dabei ist, dass mehr Exit-Positionen mehr Verschachtelung / eingerückten Code bedeuten.

Alternativ könnte ich meinen Code schreiben, damit die ifKlauseln so klein wie möglich sind und keine Exits erforderlich sind.

Kennt jemand einen guten / besseren Weg, um eine ifKlausel zu beenden?

Wenn es andere else-if- und else-Klauseln gibt, würde das Beenden diese überspringen.

(Diese Methode funktioniert für ifs, mehrere verschachtelte Schleifen und andere Konstrukte, die Sie nicht breakeinfach verwenden können.)

Wickeln Sie den Code in eine eigene Funktion ein. breakVerwenden Sie stattdessen return.

Beispiel:

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()
    ...

von goto import goto, label

wenn some_condition:
   ...
   wenn Bedingung_a:
       # etwas tun
       # und verlassen Sie dann den äußeren if-Block
       gehe zum Ende
   ...
   wenn Bedingung_b:
       # etwas tun
       # und verlassen Sie dann den äußeren if-Block
       gehe zum Ende
   # mehr Code hier

Label .end

(Verwenden Sie dies bitte nicht wirklich.)

while some_condition:
   ...
   if condition_a:
       # do something
       break
   ...
   if condition_b:
       # do something
       break
   # more code here
   break

Sie können die Funktionalität von goto mit Ausnahmen emulieren:

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

Haftungsausschluss: Ich möchte Sie nur auf die Möglichkeit aufmerksam machen, Dinge auf diese Weise zu tun, während ich dies unter normalen Umständen in keiner Weise als angemessen befürworte. Wie ich in einem Kommentar zu dieser Frage erwähnt habe, ist es bei weitem vorzuziehen, Code so zu strukturieren, dass byzantinische Bedingungen überhaupt vermieden werden. :-)

vielleicht das?

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

Für das, was tatsächlich gefragt wurde, besteht mein Ansatz darin, diese ifs in eine Schleife mit einer Schleife zu setzen

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

Probier es aus:

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

Im Allgemeinen nicht. Wenn Sie "Wenns" verschachteln und von ihnen abbrechen, machen Sie es falsch.

Wenn Sie jedoch müssen:

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()

Beachten Sie, dass die Funktionen nicht in der if-Anweisung deklariert werden MÜSSEN, sondern im Voraus deklariert werden können;) Dies wäre eine bessere Wahl, da es nicht erforderlich ist, ein hässliches if / dann später umzugestalten.

Tatsächlich beschreiben Sie goto-Anweisungen, die im Allgemeinen ziemlich stark verschoben werden. Ihr zweites Beispiel ist viel einfacher zu verstehen.

Sauberer wäre jedoch immer noch:

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

Es gibt einen anderen Weg, der nicht auf der Definition von Funktionen beruht (da dies manchmal für kleine Codefragmente weniger lesbar ist), keine zusätzliche äußere while-Schleife verwendet (die möglicherweise eine besondere Berücksichtigung in den Kommentaren erfordert, um auf den ersten Blick verständlich zu sein). , verwendet kein goto (...) und vor allem können Sie Ihre Einrückungsstufe für das Äußere beibehalten, wenn Sie nicht mit dem Verschachteln beginnen müssen.

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

Ja, das erfordert auch einen zweiten Blick auf die Lesbarkeit. Wenn die Codeausschnitte jedoch klein sind, müssen keine while-Schleifen nachverfolgt werden, die sich nie wiederholen. Nachdem Sie verstanden haben, wofür die Zwischen-Ifs gedacht sind, ist sie leicht lesbar ein Ort und mit der gleichen Einkerbung.

Und es sollte ziemlich effizient sein.

Hier verstehe ich also, dass Sie versuchen, aus dem äußeren if-Codeblock auszubrechen

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

Ein Ausweg besteht darin, dass Sie im äußeren if-Block nach einer falschen Bedingung suchen können, die dann implizit aus dem Codeblock austritt. Anschließend verwenden Sie einen else-Block, um die anderen ifs zu verschachteln, um etwas zu tun

if test_for_false:
    # Exit the code(which is the outer if code)

else:
    if condition_a:
        # Do something

    if condition_b:
        # Do something

Das einzige, was dies ohne zusätzliche Methoden anwenden würde, ist elifdas folgende Beispiel

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') 

Hier ist eine andere Möglichkeit, damit umzugehen. Es wird ein einzelnes Element für die Schleife verwendet, mit dem Sie einfach weiter verwenden können. Es verhindert, dass unnötige zusätzliche Funktionen ohne Grund erforderlich sind. Und eliminiert zusätzlich potenzielle unendliche while-Schleifen.

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

Die Verwendung returnin der if-Bedingung gibt Sie aus der Funktion zurück, sodass Sie mit return die if-Bedingung aufheben können.