8.错误和异常
到目前为止,错误消息还没有提到,但是如果你已经尝试过这些例子,你可能已经看过了一些。存在(至少)两种可区分的错误:语法错误和异常。
8.1。语法错误
语法错误(也称为解析错误)可能是您在学习Python时最常见的抱怨:
>>>
>>> while True print('Hello world')
File "<stdin>", line 1
while True print('Hello world')
^
SyntaxError: invalid syntax
解析器重复出现违规行,并显示一个指向检测到错误的行中最早点的“箭头”。该错误是由箭头前面的令牌(或至少在其处检测到)引起的:在该示例中,在函数处检测到错误print()
,因为冒号(':'
)之前缺少冒号()。打印文件名和行号,以便您知道输入来自脚本的位置。
8.2。例外
即使语句或表达式在语法上是正确的,但在尝试执行它时可能会导致错误。在执行期间检测到的错误称为异常,并且不是无条件致命的:您将很快学会如何在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
错误消息的最后一行表示发生了什么。异常有不同的类型,类型作为消息的一部分打印出来:示例中的类型是ZeroDivisionError
,NameError
和TypeError
。作为异常类型打印的字符串是发生的内置异常的名称。对于所有内置异常都是如此,但对于用户定义的异常不一定是这样(尽管它是一个有用的约定)。标准异常名称是内置标识符(不是保留关键字)。
该行的其余部分根据异常类型及其原因提供详细信息。
错误消息的前一部分以堆栈回溯的形式显示发生异常的上下文。通常它包含列出源代码行的堆栈回溯; 但是,它不会显示从标准输入读取的行。
内置异常列出了内置异常及其含义。
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
声明如下工作。
- 首先,执行try子句(
try
和except
关键字之间的语句)。 - 如果没有异常发生,则跳过except子句并
try
完成语句的执行 。 - 如果在执行try子句期间发生异常,则跳过该子句的其余部分。然后,如果其类型匹配在
except
关键字后面命名的异常 ,则执行except子句,然后在try
语句之后继续执行。 - 如果发生的异常与except子句中指定的异常不匹配,则将其传递给外部
try
语句; 如果没有找到处理程序,则它是一个未处理的异常,执行将停止,并显示如上所示的消息。
一个try
语句可能有不止一个,除了子句,分别指定处理不同的异常。最多将执行一个处理程序。处理程序仅处理相应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 - 第一个匹配的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
该try
... except
语句有一个可选的else子句,其中,如果存在的话,必须遵循所有的条款除外。如果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
因为它避免意外捕获由try
... except
语句保护的代码未引发的异常。
发生异常时,它可能具有关联值,也称为异常参数。参数的存在和类型取决于异常类型。
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
如果异常有参数,则它们将作为未处理异常的消息的最后一部分(“详细信息”)打印。
异常处理程序不仅处理异常(如果它们立即出现在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。用户定义的异常
程序可以通过创建新的异常类来命名它们自己的异常(有关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.6。定义清理操作
该try
语句有另一个可选子句,用于定义必须在所有情况下执行的清理操作。例如:
>>>
>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
一个finally子句在离开之前一直执行try
的语句,是否已经发生也不例外。当try
子句中发生异常且未被except
子句处理 (或者它已经发生在except
or else
子句中)时,在finally
子句执行后重新引发它。该finally
条款也被执行“的出路”的时候,任何其他条款try
的语句是通过左 break
,continue
或return
声明。一个更复杂的例子:
>>>
>>> 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.7。预定义的清理操作
某些对象定义了在不再需要该对象时要执行的标准清理操作,无论使用该对象的操作是成功还是失败。请查看以下示例,该示例尝试打开文件并将其内容打印到屏幕上。
for line in open("myfile.txt"):
print(line, end="")
此代码的问题在于,在代码完成执行后,它会使文件保持打开一段不确定的时间。这在简单脚本中不是问题,但对于较大的应用程序可能是一个问题。该with
语句允许以一种方式使用文件等对象,以确保始终及时正确地清理它们。
with open("myfile.txt") as f:
for line in f:
print(line, end="")
执行语句后,即使在处理行时遇到问题,文件f也始终关闭。与文件一样,提供预定义清理操作的对象将在其文档中指出这一点。