一个块中有多个尝试代码

你必须使这个 分开 try块:

try:
code a
except ExplicitException:
pass


try:
code b
except ExplicitException:
try:
code c
except ExplicitException:
try:
code d
except ExplicitException:
pass

这假设您希望在 code b失败时运行 code c 只有。

If you need to run code c 无论如何, 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是因为它是一个盲目忽略所有异常的良好实践 永远不会。你会忽略 MemoryError，KeyboardInterrupt和 SystemExit，否则，你通常不想忽略或拦截没有某种重新提高或有意识的理由来处理这些。

提取(重构)你的语句，然后利用 and和 or的魔力来决定什么时候短路。

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

如果您不想连锁(大量)除了试用子句，您可以在循环中尝试您的代码，并在第一次成功时中断。

可以放入函数的代码示例:

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)

直接在当前作用域中使用任意代码(语句)的示例:

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)

可以使用 操模块。
用 @fuckit装饰器将代码包装在函数中:

@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

假设每个代码都是一个函数，并且它已经写好了，那么下面的代码可以用来遍历你的代码列表，并且在使用“ break”执行一个函数时退出 for 循环。

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

我在这里使用了“ Exception”，所以您可以看到打印的任何错误。如果你知道要期待什么，而你又不在乎(例如，如果代码返回两三个列表项(i，j = msg.split (’.’)) ，那么就关闭打印。

你可以试试 for 循环

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

通过这种方式，您可以循环任意多个函数，而不会使代码看起来很丑陋

我使用了一种不同的方式，使用了一个新变量:

continue_execution = True
try:
command1
continue_execution = False
except:
pass
if continue_execution:
try:
command2
except:
command3

要添加更多的命令，你只需要添加更多像下面这样的表达式:

try:
commandn
continue_execution = False
except:
pass

我遇到了这个问题，但是它在一个循环中执行这些操作，这使得它变成了一个简单的例子，即如果成功的话发出 continue命令。我认为，如果不是循环的话，至少在某些情况下，可以重用这种技术:

while True:
try:
code_a
break
except:
pass


try:
code_b
break
except:
pass


etc


raise NothingSuccessfulError

就像 Elazar 建议的那样: "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)

产出:

1.0
0.25