Come uscire da una clausola if

Che tipo di metodi esistono per uscire prematuramente da una ifclausola?

Ci sono momenti in cui sto scrivendo codice e voglio inserire breakun'istruzione all'interno di una ifclausola, solo per ricordare che quelle possono essere utilizzate solo per i cicli.

Prendiamo il seguente codice come esempio:

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

Posso pensare a un modo per farlo: supponendo che i casi di uscita avvengano all'interno di istruzioni if ​​annidate, avvolgere il codice rimanente in un grande blocco else. Esempio:

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

Il problema con questo è che più posizioni di uscita significano più codice di nidificazione / rientro.

In alternativa, potrei scrivere il mio codice in modo che le ifclausole siano le più piccole possibile e non richiedano alcuna uscita.

Qualcuno conosce un modo buono / migliore per uscire da una ifclausola?

Se ci sono clausole else-if e else associate, immagino che l'uscita le salterebbe.

(Questo metodo funziona per ifs, più cicli annidati e altri costrutti da cui non puoi breakfacilmente.)

Avvolgi il codice nella sua funzione. Invece di break, usa return.

Esempio:

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

da goto import goto, label

if some_condition:
   ...
   if condition_a:
       # fare qualcosa
       # e quindi uscire dal blocco if esterno
       goto .end
   ...
   if condition_b:
       # fare qualcosa
       # e quindi uscire dal blocco if esterno
       goto .end
   # altro codice qui

etichetta .end

(Non usarlo effettivamente, per favore.)

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

Puoi emulare la funzionalità di goto con eccezioni:

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

Dichiarazione di non responsabilità: intendo solo portare alla vostra attenzione la possibilità di fare le cose in questo modo, mentre non lo approvo in alcun modo come ragionevole in circostanze normali. Come ho accennato in un commento alla domanda, è di gran lunga preferibile strutturare il codice in modo da evitare i condizionali bizantini. :-)

forse questo?

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

Per quello che è stato effettivamente chiesto, il mio approccio è quello di inserire questi messaggi ifin un ciclo a un ciclo

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

Provalo:

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

In generale, non farlo. Se annidate i "se" e vi interrompete, lo state facendo in modo sbagliato.

Tuttavia, se devi:

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

Nota, le funzioni non DEVONO essere dichiarate nell'istruzione if, possono essere dichiarate in anticipo;) Questa sarebbe una scelta migliore, poiché eviterà di dover rifattorizzare un brutto if / then in seguito.

In effetti, ciò che stai descrivendo sono istruzioni goto, che in genere vengono stroncate in modo piuttosto pesante. Il tuo secondo esempio è molto più facile da capire.

Tuttavia, più pulito sarebbe ancora:

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

C'è un altro modo che non si basa sulla definizione delle funzioni (perché a volte è meno leggibile per piccoli frammenti di codice), non utilizza un ciclo while esterno aggiuntivo (che potrebbe richiedere un apprezzamento speciale nei commenti per essere comprensibile a prima vista) , non usa goto (...) e, cosa più importante, ti consente di mantenere il tuo livello di rientro per l'esterno se così non devi iniziare a nidificare le cose.

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

Sì, questo richiede anche una seconda occhiata per la leggibilità, tuttavia, se gli snippet di codice sono piccoli non è necessario tenere traccia di alcun ciclo while che non si ripeterà mai e dopo aver capito a cosa servono i se intermedi, è facilmente leggibile, tutto in un posto e con la stessa rientranza.

E dovrebbe essere abbastanza efficiente.

Quindi qui capisco che stai cercando di uscire dal blocco di codice if esterno

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

Un modo per uscirne è che puoi testare una condizione falsa nel blocco if esterno, che quindi uscirà implicitamente dal blocco di codice, quindi usi un altro blocco per annidare gli altri if per fare qualcosa

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

else:
    if condition_a:
        # Do something

    if condition_b:
        # Do something

L'unica cosa che lo applicherebbe senza metodi aggiuntivi è elifil seguente esempio

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

Ecco un altro modo per gestirlo. Utilizza un singolo elemento per il ciclo che ti consente di utilizzare solo continue. Previene l'inutile necessità di avere funzioni extra senza motivo. Inoltre, elimina i potenziali loop while infiniti.

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

l'uso returnnella condizione if ti restituirà dalla funzione, in modo che tu possa usare return per interrompere la condizione if.