• 8.3. 处理异常

    8.3. 处理异常

    可以编写处理所选异常的程序。请看下面的例子,它会要求用户一直输入,直到输入的是一个有效的整数,但允许用户中断程序(使用 Control-C 或操作系统支持的其他操作);请注意用户引起的中断可以通过引发 KeyboardInterrupt 异常来指示。:

    1. >>> while True:
    2. ... try:
    3. ... x = int(input("Please enter a number: "))
    4. ... break
    5. ... except ValueError:
    6. ... print("Oops! That was no valid number. Try again...")
    7. ...

    try 语句的工作原理如下。

    • 首先,执行 try 子句tryexcept 关键字之间的(多行)语句)。

    • 如果没有异常发生,则跳过 except 子句 并完成 try 语句的执行。

    • 如果在执行try 子句时发生了异常,则跳过该子句中剩下的部分。然后,如果异常的类型和 except 关键字后面的异常匹配,则执行 except 子句 ,然后继续执行 try 语句之后的代码。

    • 如果发生的异常和 except 子句中指定的异常不匹配,则将其传递到外部的 try 语句中;如果没有找到处理程序,则它是一个 未处理异常,执行将停止并显示如上所示的消息。

    一个 try 语句可能有多个 except 子句,以指定不同异常的处理程序。 最多会执行一个处理程序。 处理程序只处理相应的 try 子句中发生的异常,而不处理同一 try 语句内其他处理程序中的异常。 一个 except 子句可以将多个异常命名为带括号的元组,例如:

    1. ... except (RuntimeError, TypeError, NameError):
    2. ... pass

    如果发生的异常和 except 子句中的类是同一个类或者是它的基类,则异常和except子句中的类是兼容的(但反过来则不成立 —- 列出派生类的except 子句与基类兼容)。例如,下面的代码将依次打印 B, C, D

    1. class B(Exception):
    2. pass
    3.  
    4. class C(B):
    5. pass
    6.  
    7. class D(C):
    8. pass
    9.  
    10. for cls in [B, C, D]:
    11. try:
    12. raise cls()
    13. except D:
    14. print("D")
    15. except C:
    16. print("C")
    17. except B:
    18. print("B")

    请注意如果 except 子句被颠倒(把 except B 放到第一个),它将打印 B,B,B —- 即第一个匹配的 except 子句被触发。

    最后的 except 子句可以省略异常名,以用作通配符。但请谨慎使用,因为以这种方式很容易掩盖真正的编程错误!它还可用于打印错误消息,然后重新引发异常(同样允许调用者处理异常):

    1. import sys
    2.  
    3. try:
    4. f = open('myfile.txt')
    5. s = f.readline()
    6. i = int(s.strip())
    7. except OSError as err:
    8. print("OS error: {0}".format(err))
    9. except ValueError:
    10. print("Could not convert data to an integer.")
    11. except:
    12. print("Unexpected error:", sys.exc_info()[0])
    13. raise

    tryexcept 语句有一个可选的 else 子句,在使用时必须放在所有的 except 子句后面。对于在try 子句不引发异常时必须执行的代码来说很有用。例如:

    1. for arg in sys.argv[1:]:
    2. try:
    3. f = open(arg, 'r')
    4. except OSError:
    5. print('cannot open', arg)
    6. else:
    7. print(arg, 'has', len(f.readlines()), 'lines')
    8. f.close()

    使用 else 子句比向 try 子句添加额外的代码要好,因为它避免了意外捕获由 tryexcept 语句保护的代码未引发的异常。

    发生异常时,它可能具有关联值,也称为异常 参数 。参数的存在和类型取决于异常类型。

    except 子句可以在异常名称后面指定一个变量。这个变量和一个异常实例绑定,它的参数存储在 instance.args 中。为了方便起见,异常实例定义了 str() ,因此可以直接打印参数而无需引用 .args 。也可以在抛出之前首先实例化异常,并根据需要向其添加任何属性。:

    1. >>> try:
    2. ... raise Exception('spam', 'eggs')
    3. ... except Exception as inst:
    4. ... print(type(inst)) # the exception instance
    5. ... print(inst.args) # arguments stored in .args
    6. ... print(inst) # __str__ allows args to be printed directly,
    7. ... # but may be overridden in exception subclasses
    8. ... x, y = inst.args # unpack args
    9. ... print('x =', x)
    10. ... print('y =', y)
    11. ...
    12. <class 'Exception'>
    13. ('spam', 'eggs')
    14. ('spam', 'eggs')
    15. x = spam
    16. y = eggs

    如果异常有参数,则它们将作为未处理异常的消息的最后一部分('详细信息')打印。

    异常处理程序不仅处理 try 子句中遇到的异常,还处理 try 子句中调用(即使是间接地)的函数内部发生的异常。例如:

    1. >>> def this_fails():
    2. ... x = 1/0
    3. ...
    4. >>> try:
    5. ... this_fails()
    6. ... except ZeroDivisionError as err:
    7. ... print('Handling run-time error:', err)
    8. ...
    9. Handling run-time error: division by zero