在编程的过程中,总是无法避免处理异常的情况,这些异常也有可能是错误,也有可能是一些偶现的异常,Python中提供了处理这些情况的有效机制。
语法错误
语法错误,即解析错误,也许会是你学习Python的过程中遇到最多的错误:
>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax
解析器会指定文件名和错误的行,并且使用一个'^'指向出现错误的位置:在这个例子中,错误被探测在函数print(),由于它之前缺少了':'。
异常
即使语句在语法上是正确的,当执行它的时候任然可能引起一个错误。执行期间的错误叫做异常,后面将讲述在Python中怎么处理异常。下面展示了一些异常的信息:
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly
错误信息的最后一行提示了错误的原因。异常有很多不同的类型,这也被打印作为了信息的一部分:在上面的例子中有ZeroDivisionError、NameError和TypeError,这里的打印就是异常的名字,所有的内嵌异常都是打印的异常名,但用户自定义异常不一定(虽然这是一个有用的惯例)。最后一行提示信息的其余部分提供了异常的细节,包括引起异常的原因。
错误信息的前面部分展示了异常发生的上下文,包括堆栈信息。
处理异常
可以在代码中对指定的异常做出处理,看下面的例子,请求用户输入直到获取到一个有效的整数,但允许用户中断程序(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语句按下面的方式工作:1)首先try和except间的语句块将被执行;
2)如果没有异常出现,except子句将被略过,try语句块执行完成;
3)如果try语句块执行时出现异常,语句块的其余部分被略过,如果异常的类型匹配except对应的异常名,except子句将被执行;
4)如果异常出现,并且在except子句中没有匹配的异常名,它将被传递到外层的try语句块中;如果没有处理器被发现,它就是一个未处理的异常,执行将停止并打印异常信息。
try语句可以有多个except子句,对不同的异常提供不同的处理器,一次最多一个处理器被执行。一个except可以对应多个异常,例如:
except (RuntimeError, TypeError, NameError):
pass
最后一个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子句,必须跟随在所有except子句的后面。当你希望在try中没有出现异常的情况下执行一些代码时可以使用。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
当一个异常出现时,它可以有一个关联的值,称之为异常参数。参数的残在和类型取决于异常类型。异常子句可以在异常名后指定一个变量,这个变量绑定到一个异常实例,并且将异常参数值保存在instance.args。异常实例定义了__str__()以方便直接打印参数。也可以实例化一个异常,然后抛出它,并且为它添加希望的属性:
>>> 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)
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
如果一个异常有参数,如果该异常未被处理,则参数将被打印作为信息的最后部分。异常字块不仅能处理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: int division or modulo by zero
raise子句
使用raise可以抛出一个指定的异常,例如:
>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: HiThere
raise的参数就是被抛出的异常,参数必须是一个异常实例或者一个异常类(Exception的子类)。如果你需要确定一个异常是否被抛出了,但是不想处理它,你可以使用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 ?
NameError: HiThere
用户自定义异常
如果内建的异常无法满足你的要求,则需要创建你自己的异常类。自定义的异常类应该是Exception的子类(直接或者间接)。例如
>>> class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
>>> try:
raise MyError(2*2)
except MyError as e:
print('My exception occurred, value:', e.value)
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'
在这个例子中,异常默认的__init__()方法被重载,新的行为创建一个value属性,这代替了args属性的默认行为。异常类能做其它类做的任何事情,但是最好保持异常类的简单,通常仅定义能够反映错误的必要信息。当创建一个能抛出多种不同异常的模块时,一个惯例是创建一个异常的基类,然后其它子类来分别代表不同的错误。
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
大部分的异常名以"Error"结尾,类似于标准异常的命名。通常标准模块都会定义他们自己的异常,用户报告他们顶一个函数中出现的错误。
finally
有另一个可选的子句是finally子句,用于定义在任何情况下都会执行的代码,通常用于做清理操作,例如:
>>> try:
raise KeyboardInterrupt
finally:
print('Goodbye, world!')
Goodbye, world!
KeyboardInterrupt
finally子句总是在离开try块钱执行,无论是否出现了异常。当一个异常出现在try块中,并且没有被except子句处理(或者出现在except或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 ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
正如你看到的,finally子句在任何情况下都会被执行。两个字符串相除导致的TypeError没有被except子句处理,因此在finally执行后重新被抛出。在实际的应用中,finally子句是非常有用的,通常用于释放资源(如文件或者网络连接),不用担心资源的使用中出现异常。
预定义清理行为
一些对象定义标准的清理行为,当对象不再被需要时调用,不关心使用对象的操作是否成功。看下面的例子,尝试打开一个文件并打印它的内容:
for line in open("myfile.txt"):
print(line, end="")
这个代码的问题是代码执行完成后没有关闭文件,在简单的脚本中,这不是问题,但是在大型应用中则会带来问题。with子句可以确保文件(或者其它资源)在使用后总是被关闭:
with open("myfile.txt") as f:
for line in f:
print(line, end="")
语句在执行完成后,文件f总是会被关闭,即使在执行期间出现了异常。像文件这种提供了预定义清理行为对象会在文档中说明。