一个块中多个尝试代码

Question

我的 try 块中的代码有问题。 为了简单起见，这是我的代码：

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

这样的事情可能吗？

Answer 1

你必须制作这个单独的

try

块：

try:
    code a
except ExplicitException:
    pass

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

这假设您想要在

code c

失败时运行 code b

only

。

如果你需要运行

code c

不管，你需要将

try

块一个接一个地放置：

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

，通常你不想忽略或拦截它们，除非有某种重新加注或有意识的理由来处理它们。

Answer 2

您可以使用fuckit模块。
使用

@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

Answer 3

提取（重构）您的陈述。并利用

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

Answer 4

如果您不想链接（大量）try- except 子句，您可以在循环中尝试代码并在第一次成功时中断。

可放入函数中的代码示例：

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)

Answer 5

假设每个代码都是一个函数并且已经编写完毕，那么可以使用以下内容来迭代您的编码列表，并在使用“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('.'))），请关闭打印。

Answer 6

你可以尝试 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

这样你就可以循环任意数量的函数，而不会让代码看起来很难看

Answer 7

我遇到了这个问题，但随后它在循环中执行这些操作，这将其变成了如果成功则发出

continue

命令的简单情况。我认为如果不在循环中，至少在某些情况下可以重用该技术：

while True:
    try:
        code_a
        break
    except:
        pass

    try:
        code_b
        break
    except:
        pass

    etc

    raise NothingSuccessfulError

Answer 8

我使用不同的方式，使用一个新变量：

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

要添加更多命令，您只需添加更多表达式，如下所示：

try:
    commandn
    continue_execution = False
except:
    pass

Answer 9

就像埃拉扎尔建议的那样： “我认为装饰器适合这里。”

# 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

Answer 10

基于 kxr 的答案（没有足够的代表来发表评论），您可以使用 For/Else （参见文档）来避免检查

i

值。

else

子句仅在

for

正常完成时执行，因此当

break

执行

时它会被跳过

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:
        continue
else:
    print("it failed: %s" % ev)