错误和异常处理的详解(8) – python入门教程

到目前为止，错误消息还没有被提及，但是如果您尝试过这些示例，您可能已经看到了一些。有（至少）两种可区分的错误：语法错误和异常。

>>>
>>> while True print('Hello world')
  File "<stdin>", line 1
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

>>>
>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

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

该try语句的工作方式如下。

• 首先，执行try 子句（thetry和 except关键字之间的语句）。
• 如果没有发生异常，则跳过 except 子句try并完成语句的执行。
• 如果在 try 子句执行期间发生异常，则跳过该子句的其余部分。然后如果它的类型匹配以关键字命名的异常 except，则执行except子句，然后在try语句之后继续执行。
• 如果发生与 except 子句中指定的异常不匹配的异常，则将其传递给外部try语句；如果没有找到处理程序，则它是一个未处理的异常，并且执行停止并显示如上所示的消息。

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

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

class B(Exception): 
    pass 
class C(B):
    pass 
class D(C): 
    pass 
for cls in [B, C, D]:
    try: 
        raise cls() 
    except D: 
        print("D") 
    except C: 
        print("C") 
    except B: 
        print("B")

请注意，如果将 except 子句反转（使用first），它将打印 B, B, B — 第一个匹配的 except 子句被触发。except B

最后一个 except 子句可以省略异常名称，作为通配符。使用时要格外小心，因为用这种方式很容易掩盖真正的编程错误！它还可以用于打印错误消息，然后重新引发异常（允许调用者也处理异常）：

import sys 
try: 
    f = open('myfile.txt') 
    s = f.readline() 
    i = int(s.strip()) 
except OSError as err: 
    print("OS error: {0}".format(err)) 
except ValueError: 
    print("Could not convert data to an integer.") 
except: 
    print("Unexpected error:", sys.exc_info()[0]) 
    raise

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

>>>
>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print(type(inst))    # the exception instance
...     print(inst.args)     # arguments stored in .args
...     print(inst)          # __str__ allows args to be printed directly,
...                          # but may be overridden in exception subclasses
...     x, y = inst.args     # unpack args
...     print('x =', x)
...     print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

如果异常有参数，它们将作为未处理异常的消息的最后一部分（“详细信息”）打印。

异常处理程序不仅仅处理在 try 子句中立即发生的异常，而且如果它们发生在 try 子句中调用（甚至间接地）调用的函数内部。例如：

>>>
>>> def this_fails():
...     x = 1/0
...
>>> try:
...     this_fails()
... except ZeroDivisionError as err:
...     print('Handling run-time error:', err)
...
Handling run-time error: division by zero

8.4 引发异常

该raise语句允许程序员强制发生指定的异常。例如：

>>>
>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: HiThere

唯一的参数raise表示要引发的异常。这必须是异常实例或异常类（派生自 的类Exception）。如果传递了一个异常类，它将通过不带参数调用其构造函数来隐式实例化：

raise ValueError # shorthand for 'raise ValueError()'

>>>
>>> try:
...     raise NameError('HiThere')
... except NameError:
...     print('An exception flew by!')
...     raise
...
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
NameError: HiThere

8.5 用户定义的异常

程序可以通过创建新的异常类来命名自己的异常（有关 Python 类的更多信息，请参见 类）。异常通常应该Exception直接或间接地从类派生。

可以定义异常类，它可以做任何其他类可以做的任何事情，但通常保持简单，通常只提供一些属性，允许异常处理程序提取有关错误的信息。当创建一个可能引发多个不同错误的模块时，一种常见的做法是为该模块定义的异常创建一个基类，并为不同的错误条件创建特定的异常类的子类：

class Error(Exception): 
    """Base class for exceptions in this module.""" 
    pass 
class InputError(Error): 
    """Exception raised for errors in the input. Attributes: expression 
    -- input expression in which the error occurred message 
    -- explanation of the error """ 
    def __init__(self, expression, message): 
        self.expression = expression 
        self.message = message 
class TransitionError(Error): 
    """Raised when an operation attempts a state transition that's not allowed. Attributes: previous 
       -- state at beginning of transition next 
       -- attempted new state message 
       -- explanation of why the specific transition is not allowed """ 
    def __init__(self, previous, next, message): 
        self.previous = previous 
        self.next = next 
        self.message = message

>>>
>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

如果存在finally子句，则该finally 子句将作为try 语句完成之前的最后一个任务执行。finally无论try语句是否产生异常，该子句都会运行。以下几点讨论了发生异常时更复杂的情况：

• 如果在子句执行过程中发生try 异常，该异常可以由except 子句处理。如果子句未处理except 异常，则在执行子句后重新引发异常finally 。
• except 在执行orelse子句期间可能会发生异常。finally同样，在执行该子句后重新引发异常。
• 如果try语句到达break, continueorreturn语句，则 finally子句将在 break, continueorreturn 语句执行之前执行。
• 如果finally子句包含return 语句，则返回的值将是 finally子句return语句中的值，而不是try子句语句中的值return 。

例如：

>>> def bool_return():
...     try:
...         return True
...     finally:
...         return False
...
>>> bool_return()
False

一个更复杂的例子：

>>>
>>> def divide(x, y):
...     try:
...         result = x / y
...     except ZeroDivisionError:
...         print("division by zero!")
...     else:
...         print("result is", result)
...     finally:
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

for line in open("myfile.txt"): 
    print(line, end="")

这段代码的问题在于，在这部分代码完成执行后，它使文件处于打开状态的时间不确定。这在简单脚本中不是问题，但对于较大的应用程序可能是一个问题。该with语句允许以确保始终及时正确地清理它们的方式使用文件等对象。

with open("myfile.txt") as f: 
    for line in f: 
        print(line, end="")

执行语句后，文件f始终关闭，即使在处理行时遇到问题。像文件一样，提供预定义清理操作的对象将在其文档中指出这一点。