8. 错误和异常

到目前为止,错误消息还没有被提到过,但是如果您尝试过这些示例,您可能已经看到了一些。有(至少)两种可区分的错误: 语法错误exception .

8.1. 语法错误

语法错误,也称为解析错误,可能是您在学习Python时遇到的最常见的抱怨:

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

分析器重复出现问题的行,并显示一个小箭头,指向检测到错误的行中最早的点。错误是由令牌(或至少检测到)引起的 前面的 箭头:在示例中,在函数处检测到错误 print() ,因为结肠 (':' )之前就不见了。文件名和行号都会被打印出来,这样您就知道在输入来自脚本的情况下该从何处查找。

8.2. 例外情况

即使一个语句或表达式在语法上是正确的,当试图执行它时,它也可能导致错误。调用执行过程中检测到的错误 exception 并且不是无条件地致命:您很快就会了解如何在Python程序中处理它们。但是,大多数异常不由程序处理,并导致错误消息,如下所示:

>>> 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

错误消息的最后一行指示发生了什么。异常以不同的类型出现,类型作为消息的一部分打印:示例中的类型为 ZeroDivisionErrorNameErrorTypeError . 作为异常类型打印的字符串是发生的内置异常的名称。这对于所有内置异常都是正确的,但对于用户定义的异常不必是正确的(尽管它是一个有用的约定)。标准异常名称是内置标识符(不是保留关键字)。

行的其余部分提供了基于异常类型及其原因的详细信息。

错误消息的前一部分以堆栈回溯的形式显示发生异常的上下文。一般来说,它包含列出源代码行的堆栈回溯;但是,它不会显示从标准输入读取的行。

内置异常 列出内置异常及其含义。

8.3. 处理异常

可以编写处理选定异常的程序。看看下面的例子,它要求用户输入一个有效的整数,但允许用户中断程序(使用 Control-C 或操作系统支持的任何内容);请注意,用户生成的中断是通过提高 KeyboardInterrupt 例外。::

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

这个 try 声明的作用如下。

  • 首先, 试用子句 (以下双方之间的声明) tryexcept 关键字)被执行。

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

  • 如果在执行try子句期间发生异常,则跳过该子句的其余部分。然后,如果其类型与以 except 关键字,执行except子句,然后在 try 语句。

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

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

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

班里的一个类 except 如果子句是同一个类或其基类(但不是相反的),则它与异常兼容—列出派生类的except子句与基类不兼容。例如,以下代码将按此顺序打印b、c、d::

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 B 首先),它将打印b,b,b---触发第一个匹配的except子句。

最后一个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

这个 tryexcept 语句有一个可选的 否则子句 ,当存在时,必须遵循除条款之外的所有条款。如果try子句没有引发异常,则对于必须执行的代码很有用。例如::

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()

使用的 else 子句优于向 try 子句,因为它可以避免意外捕获未由受保护的代码引发的异常。 tryexcept 语句。

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

except子句可以在异常名称后指定变量。变量绑定到异常实例,其中的参数存储在 instance.args . 为了方便起见,异常实例定义 __str__() 所以参数可以直接打印而不必引用 .args . 也可以在引发异常之前先实例化它,并根据需要向它添加任何属性。::

>>> 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

如果异常具有参数,则它们将作为未处理异常的消息的最后一部分(“detail”)打印。

异常处理程序不仅处理在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()'

如果您需要确定是否引发了异常,但不打算处理它,那么 raise 语句允许您重新引发异常::

>>> 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. 异常链接

这个 raise 语句允许可选的 from 这将启用链接异常。例如::

# exc must be exception instance or None.
raise RuntimeError from exc

这在转换异常时非常有用。例如::

>>> def func():
...     raise ConnectionError
...
>>> try:
...     func()
... except ConnectionError as exc:
...     raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
ConnectionError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

内引发异常时,会自动进行异常链接。 exceptfinally 部分。可以使用以下命令禁用此功能 from None 成语:

>>> try:
...     open('database.sqlite')
... except IOError:
...     raise RuntimeError from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError

有关链接机制的更多信息,请参见 内置异常

8.6. 用户定义异常

程序可以通过创建新的异常类来命名自己的异常(请参见 Classes 有关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

大多数异常都是以“错误”结尾的名称定义的,类似于标准异常的命名。

许多标准模块定义自己的异常以报告它们定义的函数中可能发生的错误。有关课程的更多信息,请参见第章。 Classes .

8.7. 定义清理操作

这个 try 语句还有另一个可选子句,用于定义在所有情况下必须执行的清理操作。例如::

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

如果A finally 条款存在,则 finally 子句将作为 try 语句完成。这个 finally 子句是否运行 try 语句产生异常。以下几点讨论发生异常时更复杂的情况:

  • 如果在执行 try 子句,异常可以由 except 条款。如果异常不是由 except 子句后重新引发异常 finally 子句已执行。

  • 在执行 exceptelse 条款。同样,在 finally 子句已执行。

  • 如果 try 语句到达 breakcontinuereturn 语句 finally 子句将在 breakcontinuereturn 语句的执行。

  • 如果A 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'

如你所见, finally 在任何情况下执行子句。这个 TypeError 通过分隔两个字符串引发的不由 except 条款,因此在 finally 子句已执行。

在实际应用中, finally 子句对于释放外部资源(如文件或网络连接)很有用,不管资源的使用是否成功。

8.8. 预定义的清理操作

有些对象定义了当不再需要对象时要执行的标准清理操作,不管使用对象的操作是否成功或失败。请看下面的示例,它试图打开一个文件并将其内容打印到屏幕上。::

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

此代码的问题在于,在该部分代码执行完毕后,它会将文件打开一段不确定的时间。这在简单的脚本中不是一个问题,但对于较大的应用程序来说可能是一个问题。这个 with 语句允许像文件这样的对象以一种确保它们总是被及时和正确地清理的方式使用。::

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

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