Como sair de uma cláusula if

Que tipo de método existe para sair prematuramente de uma ifcláusula?

Há momentos em que estou escrevendo código e quero colocar uma breakinstrução dentro de uma ifcláusula, apenas para lembrar que eles só podem ser usados ​​para loops.

Vamos tomar o seguinte código como exemplo:

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 pensar em uma maneira de fazer isso: supondo que os casos de saída ocorram dentro de instruções if aninhadas, envolva o código restante em um grande bloco else. Exemplo:

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

O problema com isso é que mais locais de saída significam mais código aninhado / indentado.

Como alternativa, eu poderia escrever meu código para que as ifcláusulas fossem as menores possíveis e não exigissem quaisquer saídas.

Alguém conhece uma maneira boa / melhor de sair de uma ifcláusula?

Se houver alguma cláusula else-if e else associada, eu acho que sair iria ignorá-la.

(Este método funciona para ifs, vários loops aninhados e outras construções que você não pode usar breakfacilmente.)

Envolva o código em sua própria função. Em vez de break, use return.

Exemplo:

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:
   ...
   se condição_a:
       # faça alguma coisa
       # e então saia do bloco if externo
       goto .end
   ...
   se condição_b:
       # faça alguma coisa
       # e então saia do bloco if externo
       goto .end
   mais # código aqui

etiqueta .end

(Não use isso, por favor.)

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

Você pode emular a funcionalidade de goto com exceções:

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

Isenção de responsabilidade: apenas quero chamar sua atenção para a possibilidade de fazer as coisas dessa maneira, embora de forma alguma endosso isso como razoável em circunstâncias normais. Como mencionei em um comentário sobre a questão, estruturar o código de modo a evitar as condicionais bizantinas em primeiro lugar é de longe preferível. :-)

Talvez isto?

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

Para o que foi realmente perguntado, minha abordagem é colocar esses ifs dentro de um loop de um loop

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

Teste-o:

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

De um modo geral, não. Se você está aninhando "se" e rompendo com eles, está fazendo errado.

No entanto, se você deve:

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

Observe que as funções não PRECISAM ser declaradas na instrução if, elas podem ser declaradas antecipadamente;) Esta seria uma escolha melhor, pois evitará a necessidade de refatorar um if / then feio posteriormente.

Efetivamente, o que você está descrevendo são instruções goto, que geralmente são bastante deslocadas. Seu segundo exemplo é muito mais fácil de entender.

No entanto, mais limpo ainda seria:

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

Há outra maneira que não depende da definição de funções (porque às vezes é menos legível para pequenos trechos de código), não usa um loop while externo extra (que pode precisar de uma apreciação especial nos comentários para ser compreensível à primeira vista) , não usa goto (...) e o mais importante, permite que você mantenha seu nível de indentação para o externo, caso não precise iniciar o aninhamento.

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

Sim, isso também precisa de uma segunda olhada para legibilidade, no entanto, se os trechos de código forem pequenos, isso não exige o rastreamento de nenhum loop while que nunca se repita e depois de entender para que servem os ifs intermediários, é facilmente legível, tudo em um lugar e com o mesmo recuo.

E deve ser muito eficiente.

Então, aqui eu entendo que você está tentando sair do bloco de código if externo

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

Uma maneira de sair disso é que você pode testar se há uma condição falsa no bloco if externo, que então sairá implicitamente do bloco de código, você então usa um bloco else para aninhar os outros ifs para fazer algo

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

else:
    if condition_a:
        # Do something

    if condition_b:
        # Do something

A única coisa que poderia aplicar isso sem métodos adicionais é elifcomo o exemplo a seguir

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

Esta é outra maneira de lidar com isso. Ele usa um único item para loop que permite que você use apenas continue. Ele evita a necessidade desnecessária de funções extras sem motivo. E, adicionalmente, elimina possíveis loops while infinitos.

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

usar returnna condição if retornará você da função, para que você possa usar return para interromper a condição if.