16.异常处理

异常处理

什么是异常

本节开始介绍之前，先看看如下程序：

>>> print(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> 

是不是很熟悉，这是我们前面经常看到的程序运行出现的错误。

作为Python初学者，在学习Python编程的过程中，经常会看到一些报错信息，使你编写的程序不能如期工作，如我们前面看到过的NameError、SyntaxError、TypeError、ValueError等，这些都是异常。

异常是一个事件，该事件会在程序执行过程中发生，影响程序的正常执行。一般情况下，在Python无法正常处理程序时就会发生异常。异常是Python的对象，表示一个错误。当Python脚本发生异常时，我们需要捕获并处理异常，否则程序会终止执行。

每一个异常都是一些类的实例，这些实例可以被引用，并且可以用很多种方法进行捕捉，使得错误可以被处理，而不是让整个程序失败。

异常处理

出现异常怎么办呢？

就如我们使用的工具出了点小毛病，我们可以想办法修理好它。程序也一样，前辈们经过不断积累与思考，创造了不少好方法处理程序中的异常，最简单的是使用try语句处理。

try语句的基本形式为try / except。try / except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。如果你不想在发生异常时结束程序，只需在try语句块中捕获异常即可。

捕获异常的语法如下：

try:
    <语句>　　#运行别的代码
except <名字>：
    <语句>　　#如果在try部分引发了异常

try的工作原理是，开始一个try语句后，Python就在当前程序的上下文中做标记，当出现异常时就可以回到做标记的地方。首先执行try子句，接下来发生什么依赖于执行时是否出现异常。

如果try后的语句执行时发生异常，程序就跳回try并执行except子句。异常处理完毕后，控制流就可以通过整个try语句了（除非在处理异常时又引发新异常）。

例如以下示例所示（exp_exception.py）：

def exp_exception(x, y):
    try:
        result = x / y
        print('计算结果: ', result)
    except:
        print('程序出错: 除数不能为零')

程序执行结果如下：

程序出错: 除数不能为零

由执行结果看到，程序最后执行的是except子句，如果语句正常，应该打印name变量的值。

抛出异常

Python使用raise语句抛出一个指定异常。我们可以使用类(Exception的子类)或实例参数调用raise语句引发异常。使用类时程序会自动创建实例。

例如：

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

由操作结果看到，第一个示例raise Exception引发了一个没有相关错误信息的普通异常，第二个示例输出了一些错误提示。

如果只想知道是否抛出了异常，并不想处理，使用一个简单的raise语句就可以再次把异常抛出，例如：

try:
    raise NameError('This is NameError')
except NameError:
    print('An exception happened')
    # raise 不加reise 输出对应字符结束程序
    
try:
    raise NameError('This is NameError')  # 当前语句中的信息被输出
except NameError:
    print('An exception happened')
    # 添加raise则打印对应字符并再次显示异常
    raise

由输出结果看到，使用raise可以输出更深层次的异常。在使用过程中，可以借助该方法得到更详尽的异常信息。

异常中的else

如果程序执行完异常还需要做其他事情，怎么办呢？

异常为我们提供了try…except…else语句实现该功能，语法如下：

try:
    <语句>　　# 运行别的代码
except <名字>：
    <语句>　　# 如果在try部分引发了异常
else:
    <语句>　　# 如果没有发生异常

如果在try子句执行时没有发生异常，就会执行else语句后的语句（如果有else）。使用else子句比把所有语句都放在try子句里面更好，这样可以避免一些意想不到而except又没有捕获的异常。

例如：

def model_exception(x, y):
    try:
        a = x / y
    except:
        print('程序出现异常...')
    else:
        print('程序无异常则执行此语句...')


model_exception(2, 1)

执行结果如下：

程序无异常则执行此语句...

由执行结果看到，没有发生异常时，会执行else子句的流程。

综上所述，当程序没有发生异常时，通过添加一个else子句做一些事情（比如输出一些信息）很有用，可以帮助我们更好地判断程序的执行情况。

自定义异常

尽管内建异常类包括大部分异常，而且可满足很多要求，但有时还是要创建自己的异常类。比如需要精确知道问题的根源，就需要使用自定义异常精确定位问题。可以通过创建一个新exception类拥有自己的异常。异常应该继承自Exception类，可以直接继承，也可以间接继承。

因为错误就是类，捕获一个错误就是捕获该类的一个实例，因此错误并不是凭空产生的，而是由一些不合理的部分导致的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。如果要抛出错误，那么可以根据需要定义一个错误的类，选择好继承关系，然后用raise语句抛出一个错误的实例。

例如（my_error.py）：

class MyError(Exception):
    def __init__(self):
        pass

    def __str__(self):
        return 'this is self define error'


def my_error_test():
    try:
        raise MyError()
    except MyError as e:
        print('exception info: ', e)


my_error_test()

执行结果如下：

exception info:  this is self define error

由程序和执行结果看到，程序正确执行了自定义的异常，并且需要继承Exception类。

这只是一个简单的示例，还有不少细节需要琢磨，此处不做深入探讨，有兴趣的同学可以查阅相关资料进行实践。

提示：异常最好以Error结尾，一方面贴近标准异常的命名，另一方面便于见名知意。

finally 子句

Python中的finally子句需要和try子句一起使用，组成try / finally的语句形式，try / finally语句无论发生异常与否都将执行最后的代码。

例如(use_finally.py)：

def use_finally(x, y):
    try:
        a = x / y
    finally:
        print('No matter what happened, I will show in front of you')


use_finally(2, 0)

执行结果为：

Traceback (most recent call last):
  File "/Users/poppies/Desktop/python_projects/基础部分/use_finally.py", line 8, in <module>
    use_finally(2, 0)
  File "/Users/poppies/Desktop/python_projects/基础部分/use_finally.py", line 3, in use_finally
    a = x / y
ZeroDivisionError: division by zero
No matter what happened, I will show in front of you

由执行结果看到，finally子句被执行了，无论try子句中是否发生异常，finally都会被执行。

这里我们有一个疑问，虽然执行了finally子句，但是最后还是抛出异常了，是否可以使用except截获异常呢？

可以使用except截获异常。try、except、else和finally可以组合使用，但要记得else在except之后，finally在except和else之后。

对于上面的示例，可以更改如下（use_finally_1.py）：

def use_finally(x, y):
    try:
        a = x / y
    except ZeroDivisionError:
        print('Some bad thing happened: division by zero')
    finally:
        print('No matter what happened, I will show in front of you')


use_finally(2, 0)

执行结果如下：

Some bad thing happened: division by zero
No matter what happened, I will show in front of you

由执行结果看到，先执行了except子句的输出语句，后面跟着执行了finally子句的输出语句。如果再添加else子句，当程序正常运行时会先执行else子句，然后执行finally子句。在有finally的异常处理程序中，finally中的子句一定是最后执行的。finally子句在关闭文件或数据库连接时非常有用（文件操作和数据库操作后面会具体讲解）。

提示：在Python 2.5之前的版本中，finally需要独立使用，不能与try语句配合。在Python 2.5之后才支持这些语句的组合使用。

文件操作

打开文件

在Python中，打开文件使用的是open函数。open函数的基本语法如下：

open(file_name [, access_mode][, buffering])

参数解析：

• file_name变量：是一个包含要访问的文件名称的字符串值。

• access_mode变量：指打开文件的模式，对应有只读、写入、追加等。access_mode变量值不是必需的（不带access_mode变量时，要求file_name存在，否则报异常），默认的文件访问模式为只读(r)。

• buffering：如果buffering的值被设为0，就不会有寄存；如果buffering的值取1，访问文件时就会寄存行；如果将buffering的值设为大于1的整数，表示这就是寄存区的缓冲大小；如果取负值，寄存区的缓冲大小就是系统默认的值。

open函数返回一个File（文件）对象。File对象代表计算机中的一个文件，是Python中另一种类型的值，就像我们熟悉的列表和字典。

例如（file_open_1.py）：

path = 'd:/test.txt'
f_name = open(path)
print(f_name.name)

执行结果如下：

d:/test.txt

执行结果告诉我们打开的是d盘下的test.txt文件（执行该程序前，已经创建了一个名为test.txt的文件）。

这里有几个概念要先弄清楚：

• 文件路径：在该程序中，我们先定义了一个path变量，变量值是一个文件的路径。文件的路径是指文件在计算机上的位置，如该程序中的d:/test.txt是指文件在d盘、文件名为test.txt。文件路径又分为绝对路径和相对路径。

  • 绝对路径：总是从根文件夹开始。比如在Windows环境下，一般从c盘、d盘等开始，c盘、d盘被称为根文件夹，在该盘中的文件都得从根文件夹开始往下一级一级查找。在Linux环境下，一般从usr、home等根文件开始。比如在上面的示例程序中，path变量值就是一个绝对路径，在文件搜索框中输入绝对路径可以直接找到该文件。

  • 相对路径：相对于程序当前工作目录的路径。比如当前工作文件存放的绝对路径是d:\python\workspace，如果使用相对路径，就可以不写这个路径，用一个“.”号代替这个路径值。

例如（file_open_2.py）：

path = './test.txt'
f_name = open(path, 'w')
print(f_name.name)

执行结果如下：

./test.txt

除了单个点(.)，还可以使用两个点(..)表示父文件夹（或上一级文件夹）。此处不具体讨论，有兴趣可以自己尝试。

文件模式

我们在前面讲到，使用open函数时可以选择是否传入mode参数。在前面的示例中，mode传入了一个值为w的参数，这个参数是什么意思呢？mode可以传入哪些值呢？

mode常用的模式：

• r：表示文件只能读取
• w：表示文件只能写入
• a：表示打开文件，在原有内容的基础上追加内容，在末尾写入
• w+:表示可以对文件进行读写双重操作

mode二进制常用模式：

• rb：以二进制格式打开一个文件，用于只读
• wb：以二进制格式打开一个文件，用于只写
• ab：以二进制格式打开一个文件，用于追加
• wb+:以二进制格式打开一个文件，用于读写

使用open函数时，明确指定读模式和什么模式都不指定的效果是一样的，我们在前面的示例中已经验证。

使用写模式可以向文件写入内容。+参数可以用到其他任何模式中，指明读和写都是允许的。比如w+可以在打开一个文件时用于文件的读写。

当参数带上字母b时，表示可以用来读取一个二进制文件。Python在一般情况下处理的都是文本文件，有时也不能避免处理其他格式的文件。

基本文件方法

读和写

open函数返回的是一个File对象，有了File对象，就可以开始读取内容。如果希望将整个文件的内容读取为一个字符串值，可以使用File对象的read()方法。

read()方法从一个打开的文件中读取字符串。需要注意，Python字符串可以是二进制数据，而不仅仅是文字。

语法如下：

fileObject.read([count])

fileObject是open函数返回的File对象，count参数是从已打开的文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，就会尝试尽可能多地读取内容，很可能一直读取到文件末尾。

比如我们在test.txt文件中写入Hello world!Welcome!，执行如下代码（file_read.py）：

path = './test.txt'
f_name = open(path, 'r')
print(f'read result: {f_name.read(12)}')

执行结果如下：

read result: Hello World!

将 print('read result:', f_name.read(12)) 更改为 print('read result:',f_name.read())，得到的执行结果如下：

read result: Hello world!Welcome!

由执行结果看到，没有指定读取字节数时，read方法会读取打开文件中的所有字节。

除了读取数据外，我们还可以向文件中写入数据。在Python中，将内容写入文件的方式与print函数将字符串输出到屏幕上类似。

如果打开文件时使用读模式，就不能写入文件，即不能用下面这种形式操作文件：

open(path, 'rw')

在Python中，用write()方法向一个文件写入数据。write()方法可将任何字符串写入一个打开的文件。需要注意，Python字符串可以是二进制数据，而不仅仅是文字。

write()方法不会在字符串结尾添加换行符（'\n'），语法如下：

fileObject.write(string)

fileObject为open函数返回的File对象，string参数是需要写入文件中的内容。

该方法返回写入文件的字符串的长度。

例如（file_write.py）：

f_name = open(path, 'w')
print(f"write length: {f_name.write('Hello World!')}")

执行结果如下：

write length: 12

由执行结果看到，我们向test.txt文件中写入了12个字符。下面验证一下写入的是否是我们指定的字符，在上面的程序中追加两行代码并执行：

f_name = open(path, 'r')
print('read result: ', f_name.read())

执行结果如下：

read result: Hello World!

由执行结果看到，写入文件的是我们指定的内容。不过这里有一个疑问，我们在这里执行了两次写入操作，得到的结果怎么只写入了一次？

写文件write方法的处理方式是：将覆写原有文件，从头开始，每次写入都会覆盖前面所有内容，就像用一个新值覆盖一个变量的值。若需要在当前文件的字符串后追加字符，该怎么办呢？

可以将第二个参数w更换为a，即以追加模式打开文件，例如（file_add.py）：

path = './test.txt'
f_name = open(path, 'w')
print(f"write length: {f_name.write('Hello World!')}")
f_name = open(path, 'r')
print(f'read result: {f_name.read()}')

# 内容追加写入
f_name = open(path, 'a')
print(f"add length: {f_name.write('welcome!')}")
f_name = open(path, 'r')
print(f'read result: {f_name.read()}')

执行结果如下：

write length: 12
read result: Hello World!
add length: 8
read result: Hello World!welcome!

由执行结果看到，输出结果在文件末尾成功添加了对应字符串。

提示：如果传递给open函数的文件名不存在，写模式w和追加模式a就会创建一个新的空文件，然后执行写入或追加。

如果想追加的字符串在下一行，该怎么办呢？

在Python中，用\n表示换行。对于上面的示例，若需要追加的内容在下一行，可以如下操作（file_change_line.py）：

path = './test.txt'
f_name = open(path, 'w')
print(f"write length: {f_name.write('Hello World!')}")
f_name = open(path, 'r')
print(f'read result: {f_name.read()}')

f_name = open(path, 'a')
print('add length: ', f_name.write('\nwelcome!'))
f_name = open(path, 'r')
print(f'read result: {f_name.read()}')

执行结果如下：

write length: 12
read result: Hello World!
add length:  9
read result: Hello World!
welcome!

由执行结果看到，后面追加的内容在下一行了。

提示：若需要读或写特定编码方式的文本，则需要给open函数传入encoding参数；若需要读取GBK编码的文件，则前面的示例可以改写为f_name=open(path, 'r',encoding='gbk')，这样读取到的文件就是GBK编码方式的文件了。

读写行

我们目前对文件的读操作是按字节读或整个读取，而写操作是全部覆写或追加，这样的操作在实际应用中很不实用。

Python为我们提供了readline()、readlines()和writelines()等方法用于行操作，例如（file_read_write.py）：

path = './test.txt'
f_name = open(path, 'w')
f_name.write('Hello World!\n')
f_name = open(path, 'a')
f_name.write('welcome!')
f_name = open(path, 'r')
print(f'readline result: {f_name.readline()}')

执行结果为：

readline result: Hello World!

由执行结果得知，readline方法会从文件中读取单独一行，换行符为\n。readline方法如果返回一个空字符串，说明已经读取到最后一行了。

readline方法也可以像read方法一样传入数值读取对应的字符数，传入小于0的数值表示整行都输出。

如果将上面示例的最后一行：

print(f'readline result: {f_name.readline()}')

更改为：

# 当前读取方式为: readlines
print(f'readlines result: {f_name.readlines()}')

得到的输出结果为：

readlines result: ['Hello World!\n', 'welcome!']

输出结果为一个字符串的列表。列表中的每个字符串就是文本中的每一行，并且换行符也会被输出。

readlines方法可以传入数值参数，当传入的数值小于等于列表中一个字符串的长度值时，该字符串会被读取；当传入小于等于0的数值时，所有字符都会被读取。

例如（file_read_lines.py）：

path = './test.txt'
f_name = open(path, 'w')
str_list = ['Hello World!\n', 'welcome!\n', 'welcome!\n']
# 当前代码使用writelines进行数据写入
f_name.writelines(str_list)
f_name = open(path, 'r')
print(f'read result: {f_name.read()}')
f_name = open(path, 'r')
print(f'readline result: {f_name.readline()}')

执行结果如下：

read result: Hello World!
welcome!
welcome!

readline result: Hello World!

由执行结果看到，writelines方法和readlines方法相反，传给它一个字符串列表（任何序列或可迭代对象），它会把所有字符串写入文件。如果没有writeline方法，那么可以使用write方法代替这个方法的功能。

关闭文件

我们前面介绍了很多读取和写入文件的内容，都没有提到在读或写文件的过程中出现异常时该怎么处理。在读或写文件的过程中，出现异常的概率还是挺高的，特别对于大文件的读取和写入，出现异常更是家常便饭。在读或写文件的过程中，出现异常该怎么处理呢？

这就需要用到前面介绍的异常的知识了，用try语句捕获可能出现的异常。在捕获异常前有一个动作要执行，就是使用close方法关闭文件。

一般情况下，一个文件对象在退出程序后会自动关闭，但是为了安全起见，还是要显式地写一个close方法关闭文件。

一般显式关闭文件读或写的操作如下（file_close.py）：

path = './test.txt'
f_name = open(path, 'w')
print(f"write length: {f_name.write('Hello World!')}")
f.name.close()

这段代码和没有加close方法的执行结果一样。这样处理后的函数比没有加close方法时更安全，可以避免在某些操作系统或设置中进行无用的修改，也可以避免用完系统中所打开文件的配额。

对内容更改过的文件一定要记得关闭，因为写入的数据可能被缓存，如果程序或系统因为某些原因而崩溃，被缓存部分的数据就不会写入文件了。为了安全起见，在使用完文件后一定要记得关闭。

当使用try语句出现异常时，即使使用了close方法，也可能不被执行，这时该怎么办呢？

还记得finally子句吗？可以将close方法放在finally子句中执行，从而保证无论程序是否正常执行都会调用close方法。

上面的示例可以更改成更安全的形式（file_safe_close.py）：

f_name = None
path = './test.txt'
try:
    f_name = open(path, 'w')
    print(f"write length: {f_name.write('Hello World!')}")
except Exception as e:
    print(f'程序异常: {e}')
finally:
    if f_name:
        print(f_name.name)
        f_name.close()

如果每次都要这么写，就会很烦琐，是否有更简便的方式处理呢？

Python中引入了with语句自动帮我们调用close方法。可以使用with语句将上面的程序更改为（file_safer_close.py）：

path = './test.txt'
with open(path, 'w') as f:
    print(f"write length: {f.write('Hello World!')}")


with open(path, 'r') as f:
    print(f'文件内容: {f.read()}')

这段代码和上面使用try/finally的效果一样，并且会自动调用close方法，不用显式地写该方法。可以发现，代码比前面简洁多了，后面可以多用这种方式编写。