Cómo salir de una cláusula if

¿Qué tipo de métodos existen para salir prematuramente de una ifcláusula?

Hay momentos en los que estoy escribiendo código y quiero poner una breakdeclaración dentro de una ifcláusula, solo para recordar que solo se pueden usar para bucles.

Tomemos el siguiente código como ejemplo:

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

Puedo pensar en una forma de hacer esto: suponiendo que los casos de salida sucedan dentro de las declaraciones if anidadas, envuelva el código restante en un gran bloque else. Ejemplo:

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

El problema con esto es que más ubicaciones de salida significan más código anidado / sangrado.

Alternativamente, podría escribir mi código para que las ifcláusulas sean lo más pequeñas posible y no requieran ninguna salida.

¿Alguien sabe de una buena / mejor manera de salir de una ifcláusula?

Si hay cláusulas else-if y else asociadas, me imagino que al salir se omitirían.

(Este método funciona para ifs, múltiples bucles anidados y otras construcciones de las que no se puede breakfácilmente).

Envuelve el código en su propia función. En lugar de break, utilice return.

Ejemplo:

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 ir a importar ir a, etiqueta

si alguna_condición:
   ...
   si condition_a:
       # hacer algo
       # y luego salir del bloque if externo
       ir a .end
   ...
   if condition_b:
       # hacer algo
       # y luego salir del bloque if externo
       ir a .end
   # más código aquí

etiqueta .end

(En realidad, no uses esto, por favor).

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

Puede emular la funcionalidad de goto con excepciones:

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

Descargo de responsabilidad: solo quiero llamar su atención sobre la posibilidad de hacer las cosas de esta manera, mientras que de ninguna manera lo apoyo como razonable en circunstancias normales. Como mencioné en un comentario sobre la pregunta, es preferible estructurar el código para evitar los condicionales bizantinos en primer lugar. :-)

¿tal vez esto?

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 lo que realmente se preguntó, mi enfoque es poner esos ifs dentro de un bucle de un bucle

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

Pruébalo:

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 general, no lo hagas. Si está anidando "si" y rompiendo con ellos, lo está haciendo mal.

Sin embargo, si debe:

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

Tenga en cuenta que las funciones no TIENEN que ser declaradas en la instrucción if, se pueden declarar por adelantado;) Esta sería una mejor opción, ya que evitará la necesidad de refactorizar un if / then feo más adelante.

Efectivamente, lo que está describiendo son declaraciones goto, que generalmente se analizan con bastante frecuencia. Su segundo ejemplo es mucho más fácil de entender.

Sin embargo, aún más limpio sería:

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

Hay otra forma que no se basa en la definición de funciones (porque a veces es menos legible para fragmentos de código pequeños), no usa un bucle while externo adicional (que podría necesitar una apreciación especial en los comentarios para incluso ser comprensible a primera vista) , no usa goto (...) y lo más importante es que mantenga su nivel de sangría para el exterior si es así, no tiene que comenzar a anidar cosas.

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í, eso también necesita una segunda mirada para la legibilidad, sin embargo, si los fragmentos de código son pequeños, no es necesario realizar un seguimiento de los bucles while que nunca se repetirán y, después de comprender para qué sirven los if intermedios, es fácilmente legible, todo en un lugar y con la misma sangría.

Y debería ser bastante eficiente.

Entonces, entiendo que estás tratando de salir del bloque 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

Una forma de salir de esto es que puede probar una condición falsa en el bloque if externo, que luego saldrá implícitamente del bloque de código, luego use un bloque else para anidar los otros ifs para hacer 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

Lo único que aplicaría esto sin métodos adicionales es elifel siguiente ejemplo

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

Aquí hay otra forma de manejar esto. Utiliza un solo elemento para bucle que le permite usar continuar. Evita la necesidad innecesaria de tener funciones adicionales sin ningún motivo. Y, además, elimina los posibles bucles 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

use returnen la condición if lo devolverá de la función, de modo que pueda usar return para romper la condición if.