异常处理：try、except、else、finally 的执行顺序-Python教程-PHP中文网

答案：try块首先执行，无异常时执行else块，有异常时由except块处理，finally块始终最后执行。无论是否发生异常、是否被捕获，finally块都会在try、except或else之后执行，确保清理代码运行。

异常处理：try、except、else、finally 的执行顺序

在Python的异常处理机制里，

try

登录后复制

、

except

登录后复制

、

else

登录后复制

、

finally

登录后复制

这几个关键词的执行顺序，其实是个动态过程，它完全取决于

try

登录后复制

块内部是否“风平浪静”还是“波澜迭起”。核心逻辑是这样的：

try

登录后复制

块永远是第一个被尝试执行的。如果

try

登录后复制

块里的代码一切正常，没有抛出任何异常，那么它会顺利执行完，然后紧接着是

else

登录后复制

块，最后才轮到

finally

登录后复制

块。但如果

try

登录后复制

块在执行过程中遭遇了异常，那么

try

登录后复制

块的剩余部分会被立即跳过，程序会寻找匹配的

except

登录后复制

块来处理这个异常；如果找到了，

except

登录后复制

块就会执行；如果没找到，异常就会向上抛出。无论异常是否发生、是否被

except

登录后复制

块捕获，

finally

登录后复制

块都会在所有这些操作（包括

else

登录后复制

或

except

登录后复制

的执行，甚至

return

登录后复制

语句）之后，程序离开

try-except-else-finally

登录后复制

结构之前，坚定不移地执行。

解决方案

理解

try-except-else-finally

登录后复制

的执行流程，关键在于把握其核心目的：

try

登录后复制

尝试执行可能出错的代码，

except

登录后复制

捕获并处理错误，

else

登录后复制

在无错误时执行特定逻辑，

finally

登录后复制

确保无论如何都要执行的清理工作。

我们来看几种典型情况：

try

登录后复制

块中没有发生任何异常：

在这种最理想的情况下，程序的执行路径是：

try

登录后复制

else

登录后复制

finally

登录后复制

。

print("--- 场景1：无异常 ---")
try:
    print("在 try 块中执行代码...")
    result = 10 / 2
    print(f"try 块执行完毕，结果: {result}")
except ZeroDivisionError:
    print("在 except 块中处理 ZeroDivisionError...")
except Exception as e:
    print(f"在 except 块中处理其他异常: {e}")
else:
    print("在 else 块中执行代码，因为 try 块没有异常。")
finally:
    print("在 finally 块中执行代码，无论如何都会执行。")
print("结构外部代码继续执行。\n")

登录后复制

输出会清晰地展示这个顺序：

在 try 块中执行代码...

登录后复制

try 块执行完毕，结果: 5.0

登录后复制

在 else 块中执行代码，因为 try 块没有异常。

登录后复制

在 finally 块中执行代码，无论如何都会执行。

登录后复制

结构外部代码继续执行。

登录后复制

try

登录后复制

块中发生异常，并被
except
登录后复制
捕获：

当

try

登录后复制

块遇到问题时，执行路径变为：

try

登录后复制

(直到异常发生) ->

except

登录后复制

(匹配的) ->

finally

登录后复制

。这里的

else

登录后复制

块会被完全跳过。

print("--- 场景2：发生异常并被捕获 ---")
try:
    print("在 try 块中执行代码...")
    result = 10 / 0  # 这里会引发 ZeroDivisionError
    print(f"try 块执行完毕，结果: {result}") # 这行不会被执行
except ZeroDivisionError:
    print("在 except 块中处理 ZeroDivisionError...")
except Exception as e:
    print(f"在 except 块中处理其他异常: {e}")
else:
    print("在 else 块中执行代码，因为 try 块没有异常。") # 这行不会被执行
finally:
    print("在 finally 块中执行代码，无论如何都会执行。")
print("结构外部代码继续执行。\n")

登录后复制

输出：

在 try 块中执行代码...

登录后复制

在 except 块中处理 ZeroDivisionError...

登录后复制

在 finally 块中执行代码，无论如何都会执行。

登录后复制

结构外部代码继续执行。

登录后复制

try

登录后复制

块中发生异常，但没有匹配的
except
登录后复制
捕获：

如果异常发生了，但没有

except

登录后复制

块能处理它，那么执行路径是：

try

登录后复制

(直到异常发生) ->

finally

登录后复制

-> (异常向上抛出)。注意，即使异常未被处理，

finally

登录后复制

块依旧会执行。

print("--- 场景3：发生异常但未被捕获 ---")
try:
    print("在 try 块中执行代码...")
    my_list = [1, 2]
    print(my_list[3]) # 这里会引发 IndexError
except ZeroDivisionError: # 只能捕获 ZeroDivisionError
    print("在 except 块中处理 ZeroDivisionError...")
else:
    print("在 else 块中执行代码...")
finally:
    print("在 finally 块中执行代码，无论如何都会执行。")
print("结构外部代码继续执行。") # 这行不会被执行，因为异常未被处理

登录后复制

输出：

在 try 块中执行代码...

登录后复制

在 finally 块中执行代码，无论如何都会执行。

登录后复制

Traceback (most recent call last):

登录后复制

File "...", line X, in <module>

登录后复制

print(my_list[3]) # 这里会引发 IndexError

登录后复制

IndexError: list index out of range

登录后复制

可以看到，

finally

登录后复制

仍然执行了，然后程序才因未捕获的

IndexError

登录后复制

而终止。

Python中

else

登录后复制

块什么时候会被跳过？

else

登录后复制

块的命运，在我看来，完全取决于它前面的

try

登录后复制

块是否“安然无恙”。简单来说，只要

try

登录后复制

块中抛出了任何异常，无论是被

except

登录后复制

捕获了，还是根本没有

except

登录后复制

块去捕获导致异常向上冒泡，

else

登录后复制

块都会被无情地跳过。它的存在，就像是一个“奖励”性质的代码区，只有当

try

登录后复制

块的代码从头到尾都顺利执行完毕，没有遇到任何错误时，

else

登录后复制

块才有机会被执行。

举个例子，如果你在

try

登录后复制

块里打开了一个文件，然后做一些操作，如果文件打开成功且操作也没问题，你可能想在

else

登录后复制

块里打印一个“操作成功”的提示。但如果文件打不开，或者操作中途出错了，那么这个“操作成功”的提示就不应该出现，

else

登录后复制

块自然也就不会执行。

行者AI

行者AI绘图创作，唤醒新的灵感，创造更多可能

100

查看详情

所以，记住一点：

else

登录后复制

块与

try

登录后复制

块是强绑定的，它代表着

try

登录后复制

块的“无异常成功”分支。一旦

try

登录后复制

块不再是“无异常成功”，

else

登录后复制

块就失去了执行的资格。

为什么

finally

登录后复制

块总是会执行，即使有

return

登录后复制

语句？

finally

登录后复制

块的设计理念，就是为了提供一个“无论如何都要执行”的代码区域。它的主要职责是资源清理，比如关闭文件、释放锁、断开数据库连接等等。这些操作至关重要，因为它们确保了程序即使在异常情况下也能保持系统的健壮性和资源的有效利用。

这种“无条件执行”的特性，甚至凌驾于

return

登录后复制

语句之上。当

try

登录后复制

块或

except

登录后复制

块中包含

return

登录后复制

语句时，程序并不会立即退出函数。它会先执行

finally

登录后复制

块中的代码，然后才真正地执行

return

登录后复制

操作，将控制权交还给调用者。

我们来看一个函数中的例子：

def example_function():
    print("函数开始执行...")
    try:
        print("在 try 块中...")
        # 假设这里有一些操作
        return "从 try 块返回" # 尝试返回
    except Exception as e:
        print(f"在 except 块中处理异常: {e}")
        return "从 except 块返回" # 尝试返回
    finally:
        print("在 finally 块中执行清理工作...")
        # 即使上面有 return，这里也会执行

print(example_function())
print("\n--- 另一个带有异常的例子 ---")

def another_example_function():
    print("函数开始执行...")
    try:
        print("在 try 块中...")
        result = 1 / 0 # 制造一个异常
        return "从 try 块返回"
    except ZeroDivisionError:
        print("在 except 块中处理 ZeroDivisionError...")
        return "从 except 块返回 (ZeroDivisionError)"
    finally:
        print("在 finally 块中执行清理工作，即使有异常和返回...")

print(another_example_function())

登录后复制

你会发现，即使

return

登录后复制

语句在

try

登录后复制

或

except

登录后复制

块中被触发，

finally

登录后复制

块的打印语句仍然会出现在实际的返回值之前。这正是

finally

登录后复制

块强大而可靠的体现，它保证了关键的清理逻辑不会因为程序的正常退出、异常处理甚至提前返回而被跳过。这是我个人觉得 Python 在异常处理设计上非常周全的一个点，避免了许多潜在的资源泄露问题。

多层

try-except

登录后复制

嵌套时，异常如何传递和处理？

当

try-except

登录后复制

结构出现嵌套时，异常的传递和处理机制就变得更有意思了。核心原则是：异常会沿着调用栈向上冒泡，直到找到一个能够处理它的

except

登录后复制

块。

想象一下，你有一个外层的

try-except

登录后复制

，里面又套了一个内层的

try-except

登录后复制

。

内层

try

登录后复制

发生异常，内层
except
登录后复制
捕获并处理：这种情况下，异常在内层就被“消化”了，外层对这个异常一无所知，它会认为内层

try-except

登录后复制

结构正常完成，然后继续执行。

print("--- 场景：内层捕获并处理 ---")
try:
    print("外层 try 开始")
    try:
        print("内层 try 开始")
        value = int("abc") # 制造 ValueError
        print("内层 try 结束")
    except ValueError as e:
        print(f"内层 except 捕获到: {e}")
    finally:
        print("内层 finally 执行")
    print("外层 try 结束")
except Exception as e:
    print(f"外层 except 捕获到: {e}")
finally:
    print("外层 finally 执行")
print("程序继续")

登录后复制

输出会显示内层

except

登录后复制

处理了错误，外层

try

登录后复制

块的剩余部分以及外层的

finally

登录后复制

也会正常执行。

内层

try

登录后复制

发生异常，但内层
except
登录后复制
未捕获（或根本没有
except
登录后复制
），异常向上冒泡：此时，内层

try

登录后复制

块中的

finally

登录后复制

会先执行，然后异常会传递给外层的

try-except

登录后复制

结构。外层的

except

登录后复制

块会尝试捕获并处理这个异常。如果外层也没有匹配的

except

登录后复制

，异常会继续向上抛出，直到程序终止或被更上层的代码捕获。

print("\n--- 场景：内层未捕获，外层捕获 ---")
try:
    print("外层 try 开始")
    try:
        print("内层 try 开始")
        result = 10 / 0 # 制造 ZeroDivisionError
        print("内层 try 结束")
    except ValueError as e: # 内层只捕获 ValueError
        print(f"内层 except 捕获到: {e}")
    finally:
        print("内层 finally 执行") # 内层 finally 仍会执行
    print("外层 try 结束") # 这行不会被执行
except ZeroDivisionError as e: # 外层捕获 ZeroDivisionError
    print(f"外层 except 捕获到: {e}")
finally:
    print("外层 finally 执行")
print("程序继续")

登录后复制

这里，内层的