Each Answer to this Q is separated by one/two green lines.
I have a problem with my code in the try block.
To make it easy this is my code:
try: code a code b #if b fails, it should ignore, and go to c. code c #if c fails, go to d code d except: pass
Is something like this possible?
You’ll have to make this separate
try: code a except ExplicitException: pass try: code b except ExplicitException: try: code c except ExplicitException: try: code d except ExplicitException: pass
This assumes you want to run
code c only if
code b failed.
If you need to run
code c regardless, you need to put the
try blocks one after the other:
try: code a except ExplicitException: pass try: code b except ExplicitException: pass try: code c except ExplicitException: pass try: code d except ExplicitException: pass
except ExplicitException here because it is never a good practice to blindly ignore all exceptions. You’ll be ignoring
SystemExit as well otherwise, which you normally do not want to ignore or intercept without some kind of re-raise or conscious reason for handling those.
You can use fuckit module.
Wrap your code in a function with
@fuckit def func(): code a code b #if b fails, it should ignore, and go to c. code c #if c fails, go to d code d
Extract (refactor) your statements. And use the magic of
or to decide when to short-circuit.
def a(): try: # a code except: pass # or raise else: return True def b(): try: # b code except: pass # or raise else: return True def c(): try: # c code except: pass # or raise else: return True def d(): try: # d code except: pass # or raise else: return True def main(): try: a() and b() or c() or d() except: pass
If you don’t want to chain (a huge number of) try-except clauses, you may try your codes in a loop and break upon 1st success.
Example with codes which can be put into functions:
for code in ( lambda: a / b, lambda: a / (b + 1), lambda: a / (b + 2), ): try: print(code()) except Exception as ev: continue break else: print("it failed: %s" % ev)
Example with arbitrary codes (statements) directly in the current scope:
for i in 2, 1, 0: try: if i == 2: print(a / b) elif i == 1: print(a / (b + 1)) elif i == 0: print(a / (b + 2)) break except Exception as ev: if i: continue print("it failed: %s" % ev)
Lets say each code is a function and its already written then the following can be used to iter through your coding list and exit the for-loop when a function is executed without error using the “break”.
def a(): code a def b(): code b def c(): code c def d(): code d for func in [a, b, c, d]: # change list order to change execution order. try: func() break except Exception as err: print (err) continue
I used “Exception ” here so you can see any error printed. Turn-off the print if you know what to expect and you’re not caring (e.g. in case the code returns two or three list items (i,j = msg.split(‘.’)).
You could try a for loop
for func,args,kwargs in zip([a,b,c,d], [args_a,args_b,args_c,args_d], [kw_a,kw_b,kw_c,kw_d]): try: func(*args, **kwargs) break except: pass
This way you can loop as many functions as you want without making the code look ugly
I use a different way, with a new variable:
continue_execution = True try: command1 continue_execution = False except: pass if continue_execution: try: command2 except: command3
to add more commands you just have to add more expressions like this:
try: commandn continue_execution = False except: pass
I ran into this problem, but then it was doing the things in a loop which turned it into a simple case of issueing the
continue command if successful. I think one could reuse that technique if not in a loop, at least in some cases:
while True: try: code_a break except: pass try: code_b break except: pass etc raise NothingSuccessfulError
Like Elazar suggested:
“I think a decorator would fit here.”
# decorator def test(func): def inner(*args, **kwargs): try: func(*args, **kwargs) except: pass return inner # code blocks as functions @test def code_a(x): print(1/x) @test def code_b(x): print(1/x) @test def code_c(x): print(1/x) @test def code_d(x): print(1/x) # call functions code_a(0) code_b(1) code_c(0) code_c(4)