Question :
What sorts of methods exist for prematurely exiting an if clause?
There are times when I’m writing code and want to put a break statement inside of an if clause, only to remember that those can only be used for loops.
Lets take the following code as an example:
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
I can think of one way to do this: assuming the exit cases happen within nested if statements, wrap the remaining code in a big else block. Example:
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
The problem with this is that more exit locations mean more nesting/indented code.
Alternatively, I could write my code to have the if clauses be as small as possible and not require any exits.
Does anyone know of a good/better way to exit an if clause?
If there are any associated else-if and else clauses, I figure that exiting would skip over them.
Answer #1:
(This method works for ifs, multiple nested loops and other constructs that you can’t break from easily.)
Wrap the code in its own function. Instead of break, use return.
Example:
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()
...
Answer #2:
from goto import goto, label if some_condition: ... if condition_a: # do something # and then exit the outer if block goto .end ... if condition_b: # do something # and then exit the outer if block goto .end # more code here label .end
(Don’t actually use this, please.)
Answer #3:
while some_condition:
...
if condition_a:
# do something
break
...
if condition_b:
# do something
break
# more code here
break
Answer #4:
You can emulate goto’s functionality with exceptions:
try:
# blah, blah ...
# raise MyFunkyException as soon as you want out
except MyFunkyException:
pass
Disclaimer: I only mean to bring to your attention the possibility of doing things this way, while in no way do I endorse it as reasonable under normal circumstances. As I mentioned in a comment on the question, structuring code so as to avoid Byzantine conditionals in the first place is preferable by far. 🙂
Answer #5:
may be this?
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
Answer #6:
For what was actually asked, my approach is to put those ifs inside a one-looped 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
Test it:
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
Answer #7:
Generally speaking, don’t. If you are nesting “ifs” and breaking from them, you are doing it wrong.
However, if you must:
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()
Note, the functions don’t HAVE to be declared in the if statement, they can be declared in advance 😉 This would be a better choice, since it will avoid needing to refactor out an ugly if/then later on.
Answer #8:
Effectively what you’re describing are goto statements, which are generally panned pretty heavily. Your second example is far easier to understand.
However, cleaner still would be:
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
