Jak wyjść z klauzuli if

Jakie są rodzaje metod przedwczesnego wychodzenia z ifklauzuli?

Są chwile, kiedy piszę kod i chcę umieścić breakinstrukcję wewnątrz ifklauzuli, tylko po to, aby pamiętać, że mogą one być używane tylko do pętli.

Jako przykład weźmy następujący kod:

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

Mogę wymyślić jeden sposób, aby to zrobić: zakładając, że przypadki wyjścia mają miejsce w zagnieżdżonych instrukcjach if, zawiń pozostały kod w duży blok else. Przykład:

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

Problem polega na tym, że więcej lokalizacji wyjścia oznacza więcej zagnieżdżonego / wciętego kodu.

Alternatywnie mógłbym napisać kod, aby ifklauzule były jak najmniejsze i nie wymagały żadnych wyjść.

Czy ktoś zna dobry / lepszy sposób na wyjście z ifklauzuli?

Jeśli są jakieś powiązane klauzule else-if i else, myślę, że zakończenie spowoduje ich pominięcie.

(Ta metoda działa dla ifs, wielu zagnieżdżonych pętli i innych konstrukcji, z których nie można breakłatwo.)

Zawiń kod w jego własnej funkcji. Zamiast breakużywać return.

Przykład:

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

from goto import goto, label

if some_condition:
   ...
   if condition_a:
       # Zrób coś
       # a następnie wyjdź z zewnętrznego bloku if
       goto .end
   ...
   if condition_b:
       # Zrób coś
       # a następnie wyjdź z zewnętrznego bloku if
       goto .end
   # więcej kodu tutaj

etykieta .end

(Nie używaj tego, proszę.)

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

Możesz emulować funkcjonalność goto z wyjątkami:

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

Zastrzeżenie: chcę tylko zwrócić uwagę na możliwość robienia rzeczy w ten sposób, podczas gdy w żaden sposób nie popieram tego jako rozsądnego w normalnych okolicznościach. Jak wspomniałem w komentarzu do pytania, zdecydowanie lepszym rozwiązaniem jest ustrukturyzowanie kodu tak, aby w pierwszej kolejności uniknąć bizantyjskich warunków warunkowych. :-)

może to?

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

O co właściwie pytano, moje podejście polega na umieszczeniu ich ifw pętli z jedną pętlą

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

Sprawdź to:

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

Ogólnie mówiąc, nie. Jeśli zagnieżdżasz "jeśli" i odrywasz się od nich, robisz to źle.

Jeśli jednak musisz:

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

Zwróć uwagę, że funkcje nie MUSZĄ być deklarowane w instrukcji if, można je zadeklarować z wyprzedzeniem;) Byłby to lepszy wybór, ponieważ pozwoli to uniknąć późniejszej refaktoryzacji brzydkiego „jeśli / potem”.

W rzeczywistości to, co opisujesz, to instrukcje goto, które są generalnie dość mocno panoramowane. Twój drugi przykład jest dużo łatwiejszy do zrozumienia.

Jednak czystszy nadal byłby:

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

Jest inny sposób, który nie polega na definiowaniu funkcji (ponieważ czasami jest to mniej czytelne dla małych fragmentów kodu), nie używa dodatkowej zewnętrznej pętli while (która może wymagać szczególnego uznania w komentarzach, aby być zrozumiałym nawet na pierwszy rzut oka) , nie używa goto (...) i co najważniejsze, pozwólmy ci zachować poziom wcięcia dla zewnętrznego, jeśli tak, nie musisz zaczynać zagnieżdżania rzeczy.

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

Tak, to również wymaga ponownego spojrzenia na czytelność, jednak jeśli fragmenty kodu są małe, nie wymaga to śledzenia żadnych pętli while, które nigdy się nie powtórzą, a po zrozumieniu, do czego służą pośrednie, jeśli są, są łatwe do odczytania, wszystko w w jednym miejscu iz tym samym wcięciem.

I powinno być całkiem wydajne.

Więc rozumiem, że próbujesz wyrwać się z zewnętrznego bloku if 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

Jednym ze sposobów rozwiązania tego problemu jest to, że możesz przetestować pod kątem fałszywego warunku w zewnętrznym bloku if, który następnie niejawnie wyjdzie z bloku kodu, a następnie użyj innego bloku else do zagnieżdżenia drugiego ifs, aby coś zrobić

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

else:
    if condition_a:
        # Do something

    if condition_b:
        # Do something

Jedyną rzeczą, która zastosowałaby to bez dodatkowych metod, jest elifponiższy przykład

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

Oto inny sposób radzenia sobie z tym. Używa pojedynczego elementu dla pętli, która umożliwia po prostu użycie kontynuacji. Zapobiega niepotrzebnej potrzebie posiadania dodatkowych funkcji bez powodu. A dodatkowo eliminuje potencjalne nieskończone pętle while.

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

użycie returnw warunku if zwróci cię z funkcji, więc możesz użyć return do złamania warunku if.