第 10 章 文件和异常

至此，你掌握了编写组织有序而易于使用的程序所需的基本技
能，该考虑让程序目标更明确、用途更大了。在本章中，你将学
习处理文件，让程序能够快速地分析大量的数据；你将学习错误
处理，避免程序在面对意外情形时崩溃；你将学习异常，它们是
Python创建的特殊对象，用于管理程序运行时出现的错误；你还
将学习模块json，它让你能够保存用户数据，以免在程序停止运
行后丢失。
学习处理文件和保存数据可让你的程序使用起来更容易：用户将
能够选择输入什么样的数据，以及在什么时候输入；用户使用你
的程序做一些工作后，可将程序关闭，以后再接着往下做。学习
处理异常可帮助你应对文件不存在的情形，以及处理其他可能导
致程序崩溃的问题。这让你的程序在面对错误的数据时更健壮
——不管这些错误数据源自无意的错误，还是源自破坏程序的恶
意企图。你在本章学习的技能可提高程序的适用性、可用性和稳
定性。
10.1　从文件中读取数据
文本文件可存储的数据量多得难以置信：天气数据、交通数据、社会
经济数据、文学作品等。每当需要分析或修改存储在文件中的信息
时，读取文件都很有用，对数据分析应用程序来说尤其如此。例如，
你可以编写一个这样的程序：读取一个文本文件的内容，重新设置这
些数据的格式并将其写入文件，让浏览器能够显示这些内容。
要使用文本文件中的信息，首先需要将信息读取到内存中。为此，你
可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读
取。
10.1.1　读取整个文件
要读取文件，需要一个包含几行文本的文件。下面首先来创建一个文
件，它包含精确到小数点后30位的圆周率值，且在小数点后每10位处
都换行：
pi_digits.txt
3.1415926535
8979323846
2643383279
要动手尝试后续示例，可在编辑器中输入这些数据行，再将文件保存
为pi_digits.txt，也可从本书的主页
（http://www.ituring.com.cn/book/1861）下载该文件。然后，将该
文件保存到本章程序所在的目录中。
下面的程序打开并读取这个文件，再将其内容显示到屏幕上：
file_reader.py
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)
在这个程序中，第1行代码做了大量的工作。我们先来看看函数
open()。要以任何方式使用文件——哪怕仅仅是打印其内容，都得
先打开文件，这样才能访问它。函数open()接受一个参数：要打开
的文件的名称。Python在当前执行的文件所在的目录中查找指定的文
件。在这个示例中，当前运行的是file_reader.py，因此Python在
file_reader.py所在的目录中查找pi_digits.txt。函数open()返回
一个表示文件的对象。在这里，open('pi_digits.txt')返回一
个表示文件pi_digits.txt的对象；Python将这个对象存储在我们
将在后面使用的变量中。
关键字with在不再需要访问文件后将其关闭。在这个程序中，注意到
我们调用了open()，但没有调用close()；你也可以调用open()和
close()来打开和关闭文件，但这样做时，如果程序存在bug，导致
close()语句未执行，文件将不会关闭。这看似微不足道，但未妥善
地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用
close()，你会发现需要使用文件时它已关闭（无法访问），这会导
致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时
机，但通过使用前面所示的结构，可让Python去确定：你只管打开文
件，并在需要时使用它，Python自会在合适的时候自动将其关闭。
有了表示pi_digits.txt的文件对象后，我们使用方法read()（前述
程序的第2行）读取这个文件的全部内容，并将其作为一个长长的字符
串存储在变量contents中。这样，通过打印contents的值，就可
将这个文本文件的全部内容显示出来：
3.1415926535
8979323846
2643383279
为何会多出这个空行呢？因为read()到达文件末尾时返回一个空字
符串，而将这个空字符串显示出来时就是一个空行。要删除末尾的空
行，可在print语句中使用rstrip()：
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents.rstrip())
本书前面说过，Python方法rstrip()删除（剥除）字符串末尾的空
白。现在，输出与原始文件的内容完全相同：
3.1415926535
8979323846
2643383279
10.1.2　文件路径
当你将类似pi_digits.txt这样的简单文件名传递给函数open()时，
Python将在当前执行的文件（即.py程序文件）所在的目录中查找文
件。
根据你组织文件的方式，有时可能要打开不在程序文件所属目录中的
文件。例如，你可能将程序文件存储在了文件夹python_work中，而在
文件夹python_work中，有一个名为text_files的文件夹，用于存储程
序文件操作的文本文件。虽然文件夹text_files包含在文件夹
python_work中，但仅向open()传递位于该文件夹中的文件的名称也
不可行，因为Python只在文件夹python_work中查找，而不会在其子文
件夹text_files中查找。要让Python打开不与程序文件位于同一个目
录中的文件，需要提供文件路径，它让Python到系统的特定位置去查
找。
由于文件夹text_files位于文件夹python_work中，因此可使用相对
文件路径来打开该文件夹中的文件。相对文件路径让Python到指定的
位置去查找，而该位置是相对于当前运行的程序所在目录的。在Linux
和OS X中，你可以这样编写代码：
with open('text_files/filename.txt') as file_object:
这行代码让Python到文件夹python_work下的文件夹text_files中去查
找指定的.txt文件。在Windows系统中，在文件路径中使用反斜杠
（\）而不是斜杠（/）：
with open('text_files\filename.txt') as file_object:
你还可以将文件在计算机中的准确位置告诉Python，这样就不用关心
当前运行的程序存储在什么地方了。这称为绝对文件路径。在相对路
径行不通时，可使用绝对路径。例如，如果text_files并不在文件夹
python_work中，而在文件夹other_files中，则向open()传递路
径'text_files/ filename.txt'行不通，因为Python只在文件
夹python_work中查找该位置。为明确地指出你希望Python到哪里去查
找，你需要提供完整的路径。
绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该
变量传递给open()会有所帮助。在Linux和OS X中，绝对路径类似于
下面这样：
file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
with open(file_path) as file_object:
而在Windows系统中，它们类似于下面这样：
file_path =
'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:
通过使用绝对路径，可读取系统任何地方的文件。就目前而言，最简
单的做法是，要么将数据文件存储在程序文件所在的目录，要么将其
存储在程序文件所在目录下的一个文件夹（如text_files）中。
注意　Windows系统有时能够正确地解读文件路径中的斜杠。如
果你使用的是Windows系统，且结果不符合预期，请确保在文件路
径中使用的是反斜杠。另外，由于反斜杠在Python中被视为转义
标记，为在Windows中确保万无一失，应以原始字符串的方式指定
路径，即在开头的单引号前加上r。
10.1.3　逐行读取
读取文件时，常常需要检查其中的每一行：你可能要在文件中查找特
定的信息，或者要以某种方式修改文件中的文本。例如，你可能要遍
历一个包含天气数据的文件，并使用天气描述中包含字样sunny的行。
在新闻报道中，你可能会查找包含标签<headline>的行，并按特定
的格式设置它。
要以每次一行的方式检查文件，可对文件对象使用for循环：
file_reader.py
filename = 'pi_digits.txt' ❶
with open(filename) as file_object: ❷
for line in file_object: ❸
print(line)
在❶处，我们将要读取的文件的名称存储在变量filename中，这是
使用文件时一种常见的做法。由于变量filename表示的并非实际文
件——它只是一个让Python知道到哪里去查找文件的字符串，因此可
轻松地将'pi_digits.txt'替换为你要使用的另一个文件的名称。
调用open()后，将一个表示文件及其内容的对象存储到了变量
file_object中（见❷）。这里也使用了关键字with，让Python负
责妥善地打开和关闭文件。为查看文件的内容，我们通过对文件对象
执行循环来遍历文件中的每一行（见❸）。
我们打印每一行时，发现空白行更多了：
3.1415926535
8979323846
2643383279
为何会出现这些空白行呢？因为在这个文件中，每行的末尾都有一个
看不见的换行符，而print语句也会加上一个换行符，因此每行末尾
都有两个换行符：一个来自文件，另一个来自print语句。要消除这
些多余的空白行，可在print语句中使用rstrip()：
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line.rstrip())
现在，输出又与文件内容完全相同了：
3.1415926535
8979323846
2643383279
10.1.4　创建一个包含文件各行内容的列表
使用关键字with时，open()返回的文件对象只在with代码块内可
用。如果要在with代码块外访问文件的内容，可在with代码块内将
文件的各行存储在一个列表中，并在with代码块外使用该列表：你可
以立即处理文件的各个部分，也可推迟到程序后面再处理。
下面的示例在with代码块中将文件pi_digits.txt的各行存储在一个
列表中，再在with代码块外打印它们：
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines() ❶
for line in lines: ❷
print(line.rstrip())
❶处的方法readlines()从文件中读取每一行，并将其存储在一个列
表中；接下来，该列表被存储到变量lines中；在with代码块外，我
们依然可以使用这个变量。在❷处，我们使用一个简单的for循环来
打印lines中的各行。由于列表lines的每个元素都对应于文件中的
一行，因此输出与文件内容完全一致。
10.1.5　使用文件的内容
将文件读取到内存中后，就可以以任何方式使用这些数据了。下面以
简单的方式使用圆周率的值。首先，我们将创建一个字符串，它包含
文件中存储的所有数字，且没有任何空格：
pi_string.py
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = '' ❶
for line in lines: ❷
pi_string += line.rstrip()
print(pi_string) ❸
print(len(pi_string))
就像前一个示例一样，我们首先打开文件，并将其中的所有行都存储
在一个列表中。在❶处，我们创建了一个变量——pi_string，用于
存储圆周率的值。接下来，我们使用一个循环将各行都加入
pi_string，并删除每行末尾的换行符（见❷）。在❸处，我们打印
这个字符串及其长度：
3.1415926535 8979323846 2643383279
36
在变量pi_string存储的字符串中，包含原来位于每行左边的空格，
为删除这些空格，可使用strip()而不是rstrip()：
filename = 'pi_30_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.strip()
print(pi_string)
print(len(pi_string))
这样，我们就获得了一个这样的字符串：它包含精确到30位小数的圆
周率值。这个字符串长32字符，因为它还包含整数部分的3和小数点：
3.141592653589793238462643383279
32
注意　读取文本文件时，Python将其中的所有文本都解读为字符
串。如果你读取的是数字，并要将其作为数值使用，就必须使用
函数int()将其转换为整数，或使用函数float()将其转换为浮
点数。
10.1.6　包含一百万位的大型文件
前面我们分析的都是一个只有三行的文本文件，但这些代码示例也可
处理大得多的文件。如果我们有一个文本文件，其中包含精确到小数
点后1 000 000位而不是30位的圆周率值，也可创建一个包含所有这些
数字的字符串。为此，我们无需对前面的程序做任何修改，只需将这
个文件传递给它即可。在这里，我们只打印到小数点后50位，以免终
端为显示全部1 000 000位而不断地翻滚：
pi_string.py
filename = 'pi_million_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.strip()
print(pi_string[:52] + "...")
print(len(pi_string))
输出表明，我们创建的字符串确实包含精确到小数点后1 000 000位的
圆周率值：
3.14159265358979323846264338327950288419716939937510...
1000002
对于你可处理的数据量，Python没有任何限制；只要系统的内存足够
多，你想处理多少数据都可以。
注意　要运行这个程序（以及后面的众多示例），你需要从
http://www.ituring.com.cn/book/1861下载相关的资源。
10.1.7　圆周率值中包含你的生日吗
我一直想知道自己的生日是否包含在圆周率值中。下面来扩展刚才编
写的程序，以确定某个人的生日是否包含在圆周率值的前1 000 000位
中。为此，可将生日表示为一个由数字组成的字符串，再检查这个字
符串是否包含在pi_string中：
filename = 'pi_million_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.strip()
birthday = input("Enter your birthday, in the form mmddyy: ") ❶
if birthday in pi_string: ❷
print("Your birthday appears in the first million digits of
pi!")
else:
print("Your birthday does not appear in the first million
digits of pi.")
在❶处，我们提示用户输入其生日，在接下来的❷处，我们检查这个
字符串是否包含在pi_string中。运行一下这个程序：
Enter your birthdate, in the form mmddyy: 120372
Your birthday appears in the first million digits of pi!
我的生日确实出现在了圆周率值中！读取文件的内容后，就可以以你
能想到的任何方式对其进行分析。
动手试一试
10-1 Python学习笔记：在文本编辑器中新建一个文件，写几句
话来总结一下你至此学到的Python知识，其中每一行都以“In
Python you can”打头。将这个文件命名为
learning_python.txt，并将其存储到为完成本章练习而编写的程
序所在的目录中。编写一个程序，它读取这个文件，并将你所写
的内容打印三次：第一次打印时读取整个文件；第二次打印时遍
历文件对象；第三次打印时将各行存储在一个列表中，再在with
代码块外打印它们。
10-2 C语言学习笔记：可使用方法replace()将字符串中的特
定单词都替换为另一个单词。下面是一个简单的示例，演示了如
何将句子中的'dog'替换为'cat'：
>>> message = "I really like dogs."
>>> message.replace('dog', 'cat')
'I really like cats.'
读取你刚创建的文件learning_python.txt中的每一行，将其中的
Python都替换为另一门语言的名称，如C。将修改后的各行都打印
到屏幕上。
10.2　写入文件
保存数据的最简单的方式之一是将其写入到文件中。通过将输出写入
文件，即便关闭包含程序输出的终端窗口，这些输出也依然存在：你
可以在程序结束运行后查看这些输出，可与别人分享输出文件，还可
编写程序来将这些输出读取到内存中并进行处理。
10.2.1　写入空文件
要将文本写入文件，你在调用open()时需要提供另一个实参，告诉
Python你要写入打开的文件。为明白其中的工作原理，我们来将一条
简单的消息存储到文件中，而不是将其打印到屏幕上：
write_message.py
filename = 'programming.txt'
with open(filename, 'w') as file_object: ❶
file_object.write("I love programming.") ❷
在这个示例中，调用open()时提供了两个实参（见❶）。第一个实参
也是要打开的文件的名称；第二个实参（'w'）告诉Python，我们要
以写入模式打开这个文件。打开文件时，可指定读取模式（'r'）、
写入模式（'w'）、附加模式（'a'）或让你能够读取和写入文件的
模式（'r+'）。如果你省略了模式实参，Python将以默认的只读模式
打开文件。
如果你要写入的文件不存在，函数open()将自动创建它。然而，以
写入（'w'）模式打开文件时千万要小心，因为如果指定的文件已经
存在，Python将在返回文件对象前清空该文件。
在❷处，我们使用文件对象的方法write()将一个字符串写入文件。
这个程序没有终端输出，但如果你打开文件programming.txt，将看到
其中包含如下一行内容：
programming.txt
I love programming.
相比于你的计算机中的其他文件，这个文件没有什么不同。你可以打
开它、在其中输入新文本、复制其内容、将内容粘贴到其中等。
注意　Python只能将字符串写入文本文件。要将数值数据存储到
文本文件中，必须先使用函数str()将其转换为字符串格式。
10.2.2　写入多行
函数write()不会在你写入的文本末尾添加换行符，因此如果你写入
多行时没有指定换行符，文件看起来可能不是你希望的那样：
filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.")
file_object.write("I love creating new games.")
如果你打开programming.txt，将发现两行内容挤在一起：
I love programming.I love creating new games.
要让每个字符串都单独占一行，需要在write()语句中包含换行符：
filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.\n")
file_object.write("I love creating new games.\n")
现在，输出出现在不同行中：
I love programming.
I love creating new games.
像显示到终端的输出一样，还可以使用空格、制表符和空行来设置这
些输出的格式。
10.2.3　附加到文件
如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打
开文件。你以附加模式打开文件时，Python不会在返回文件对象前清
空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件
不存在，Python将为你创建一个空文件。
下面来修改write_message.py，在既有文件programming.txt中再添加
一些你酷爱编程的原因：
write_message.py
filename = 'programming.txt'
with open(filename, 'a') as file_object: ❶
file_object.write("I also love finding meaning in large
datasets.\n") ❷
file_object.write("I love creating apps that can run in a
browser.\n")
在❶处，我们打开文件时指定了实参'a'，以便将内容附加到文件末
尾，而不是覆盖文件原来的内容。在❷处，我们又写入了两行，它们
被添加到文件programming.txt末尾：
programming.txt
I love programming.
I love creating new games.
I also love finding meaning in large datasets.
I love creating apps that can run in a browser.
最终的结果是，文件原来的内容还在，它们后面是我们刚添加的内
容。
动手试一试
10-3 访客：编写一个程序，提示用户输入其名字；用户作出响
应后，将其名字写入到文件guest.txt中。
10-4 访客名单：编写一个while循环，提示用户输入其名字。
用户输入其名字后，在屏幕上打印一句问候语，并将一条访问记
录添加到文件guest_book.txt中。确保这个文件中的每条记录都
独占一行。
10-5 关于编程的调查：编写一个while循环，询问用户为何喜
欢编程。每当用户输入一个原因后，都将其添加到一个存储所有
原因的文件中。
10.3　异常
Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。
每当发生让Python不知所措的错误时，它都会创建一个异常对象。如
果你编写了处理该异常的代码，程序将继续运行；如果你未对异常进
行处理，程序将停止，并显示一个traceback，其中包含有关异常的报
告。
异常是使用try-except代码块处理的。try-except代码块让
Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了
try-except代码块时，即便出现异常，程序也将继续运行：显示你
编写的友好的错误消息，而不是令用户迷惑的traceback。
10.3.1　处理ZeroDivisionError异常
下面来看一种导致Python引发异常的简单错误。你可能知道不能将一
个数字除以0，但我们还是让Python这样做吧：
division.py
print(5/0)
显然，Python无法这样做，因此你将看到一个traceback：
Traceback (most recent call last):
File "division.py", line 1, in <module>
print(5/0)
ZeroDivisionError: division by zero ❶
在上述traceback中，❶处指出的错误ZeroDivisionError是一个异
常对象。Python无法按你的要求做时，就会创建这种对象。在这种情
况下，Python将停止运行程序，并指出引发了哪种异常，而我们可根
据这些信息对程序进行修改。下面我们将告诉Python，发生这种错误
时怎么办；这样，如果再次发生这样的错误，我们就有备无患了。
10.3.2　使用try-except代码块
当你认为可能发生了错误时，可编写一个try-except代码块来处理
可能引发的异常。你让Python尝试运行一些代码，并告诉它如果这些
代码引发了指定的异常，该怎么办。
处理ZeroDivisionError异常的try-except代码块类似于下面这
样：
try:
print(5/0)
except ZeroDivisionError:
print("You can't divide by zero!")
我们将导致错误的代码行print(5/0)放在了一个try代码块中。如
果try代码块中的代码运行起来没有问题，Python将跳过except代码
块；如果try代码块中的代码导致了错误，Python将查找这样的
except代码块，并运行其中的代码，即其中指定的错误与引发的错
误相同。
在这个示例中，try代码块中的代码引发了ZeroDivisionError异
常，因此Python指出了该如何解决问题的except代码块，并运行其
中的代码。这样，用户看到的是一条友好的错误消息，而不是
traceback：
You can't divide by zero!
如果try-except代码块后面还有其他代码，程序将接着运行，因为
已经告诉了Python如何处理这种错误。下面来看一个捕获错误后程序
将继续运行的示例。
10.3.3　使用异常避免崩溃
发生错误时，如果程序还有工作没有完成，妥善地处理错误就尤其重
要。这种情况经常会出现在要求用户提供输入的程序中；如果程序能
够妥善地处理无效输入，就能再提示用户提供有效输入，而不至于崩
溃。
下面来创建一个只执行除法运算的简单计算器：
division.py
print("Give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
first_number = input("\nFirst number: ") ❶
if first_number == 'q':
break
second_number = input("Second number: ") ❷
if second_number == 'q':
break
answer = int(first_number) / int(second_number) ❸
print(answer)
在❶处，这个程序提示用户输入一个数字，并将其存储到变量
first_number中；如果用户输入的不是表示退出的q，就再提示用
户输入一个数字，并将其存储到变量second_number中（见❷）。
接下来，我们计算这两个数字的商（即answer，见❸）。这个程序没
有采取任何处理错误的措施，因此让它执行除数为0的除法运算时，它
将崩溃：
Give me two numbers, and I'll divide them.
Enter 'q' to quit.
First number: 5
Second number: 0
Traceback (most recent call last):
File "division.py", line 9, in <module>
answer = int(first_number) / int(second_number)
ZeroDivisionError: division by zero
程序崩溃可不好，但让用户看到traceback也不是好主意。不懂技术的
用户会被它们搞糊涂，而且如果用户怀有恶意，他会通过traceback获
悉你不希望他知道的信息。例如，他将知道你的程序文件的名称，还
将看到部分不能正确运行的代码。有时候，训练有素的攻击者可根据
这些信息判断出可对你的代码发起什么样的攻击。
10.3.4　else代码块
通过将可能引发错误的代码放在try-except代码块中，可提高这个
程序抵御错误的能力。错误是执行除法运算的代码行导致的，因此我
们需要将它放到try-except代码块中。这个示例还包含一个else代
码块；依赖于try代码块成功执行的代码都应放到else代码块中：
print("Give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
first_number = input("\nFirst number: ")
if first_number == 'q':
break
second_number = input("Second number: ")
try: ❶
answer = int(first_number) / int(second_number)
except ZeroDivisionError: ❷
print("You can't divide by 0!")
else: ❸
print(answer)
我们让Python尝试执行try代码块中的除法运算（见❶），这个代码
块只包含可能导致错误的代码。依赖于try代码块成功执行的代码都
放在else代码块中；在这个示例中，如果除法运算成功，我们就使用
else代码块来打印结果（见❸）。
except代码块告诉Python，出现ZeroDivisionError异常时该怎
么办（见❷）。如果try代码块因除零错误而失败，我们就打印一条
友好的消息，告诉用户如何避免这种错误。程序将继续运行，用户根
本看不到traceback：
Give me two numbers, and I'll divide them.
Enter 'q' to quit.
First number: 5
Second number: 0
You can't divide by 0!
First number: 5
Second number: 2
2.5
First number: q
try-except-else代码块的工作原理大致如下：Python尝试执行
try代码块中的代码；只有可能引发异常的代码才需要放在try语句
中。有时候，有一些仅在try代码块成功执行时才需要运行的代码；
这些代码应放在else代码块中。except代码块告诉Python，如果它
尝试运行try代码块中的代码时引发了指定的异常，该怎么办。
通过预测可能发生错误的代码，可编写健壮的程序，它们即便面临无
效数据或缺少资源，也能继续运行，从而能够抵御无意的用户错误和
恶意的攻击。
10.3.5　处理FileNotFoundError异常
使用文件时，一种常见的问题是找不到文件：你要查找的文件可能在
其他地方、文件名可能不正确或者这个文件根本就不存在。对于所有
这些情形，都可使用try-except代码块以直观的方式进行处理。
我们来尝试读取一个不存在的文件。下面的程序尝试读取文件
alice.txt的内容，但我没有将这个文件存储在alice.py所在的目录
中：
alice.py
filename = 'alice.txt'
with open(filename) as f_obj:
contents = f_obj.read()
Python无法读取不存在的文件，因此它引发一个异常：
Traceback (most recent call last):
File "alice.py", line 3, in <module>
with open(filename) as f_obj:
FileNotFoundError: [Errno 2] No such file or directory:
'alice.txt'
在上述traceback中，最后一行报告了FileNotFoundError异常，
这是Python找不到要打开的文件时创建的异常。在这个示例中，这个
错误是函数open()导致的，因此要处理这个错误，必须将try语句放
在包含open()的代码行之前：
filename = 'alice.txt'
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = "Sorry, the file " + filename + " does not exist."
print(msg)
在这个示例中，try代码块引发FileNotFoundError异常，因此
Python找出与该错误匹配的except代码块，并运行其中的代码。最
终的结果是显示一条友好的错误消息，而不是traceback：
Sorry, the file alice.txt does not exist.
如果文件不存在，这个程序什么都不做，因此错误处理代码的意义不
大。下面来扩展这个示例，看看在你使用多个文件时，异常处理可提
供什么样的帮助。
10.3.6　分析文本
你可以分析包含整本书的文本文件。很多经典文学作品都是以简单文
本文件的方式提供的，因为它们不受版权限制。本节使用的文本来自
项目Gutenberg（http://gutenberg.org/），这个项目提供了一系列
不受版权限制的文学作品，如果你要在编程项目中使用文学文本，这
是一个很不错的资源。
下面来提取童话 Alice in Wonderland 的文本，并尝试计算它包含多
少个单词。我们将使用方法split()，它根据一个字符串创建一个单
词列表。下面是对只包含童话名"Alice in Wonderland"的字符
串调用方法split()的结果：
>>> title = "Alice in Wonderland"
>>> title.split()
['Alice', 'in', 'Wonderland']
方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部
分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，
虽然有些单词可能包含标点。为计算 Alice in Wonderland 包含多少
个单词，我们将对整篇小说调用split()，再计算得到的列表包含多
少个元素，从而确定整篇童话大致包含多少个单词：
filename = 'alice.txt'
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = "Sorry, the file " + filename + " does not exist."
print(msg)
else:
# 计算文件大致包含多少个单词
words = contents.split() ❶
num_words = len(words) ❷
print("The file " + filename + " has about " + str(num_words)
+ " words.") ❸
我们把文件alice.txt移到了正确的目录中，让try代码块能够成功地
执行。在❶处，我们对变量contents（它现在是一个长长的字符
串，包含童话 Alice in Wonderland 的全部文本）调用方法
split()，以生成一个列表，其中包含这部童话中的所有单词。当我
们使用len()来确定这个列表的长度时，就知道了原始字符串大致包
含多少个单词（见❷）。在❸处，我们打印一条消息，指出文件包含
多少个单词。这些代码都放在else代码块中，因为仅当try代码块成
功执行时才执行它们。输出指出了文件alice.txt包含多少个单词：
The file alice.txt has about 29461 words.
这个数字有点大，因为这里使用的文本文件包含出版商提供的额外信
息，但与童话 Alice in Wonderland 的长度相当一致。
10.3.7　使用多个文件
下面多分析几本书。这样做之前，我们先将这个程序的大部分代码移
到一个名为count_words()的函数中，这样对多本书进行分析时将
更容易：
word_count.py
def count_words(filename):
"""计算一个文件大致包含多少个单词""" ❶
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = "Sorry, the file " + filename + " does not exist."
print(msg)
else:
# 计算文件大致包含多少个单词
words = contents.split()
num_words = len(words)
print("The file " + filename + " has about " +
str(num_words) +
" words.")
filename = 'alice.txt'
count_words(filename)
这些代码大都与原来一样，我们只是将它们移到了函数
count_words()中，并增加了缩进量。修改程序的同时更新注释是
个不错的习惯，因此我们将注释改成了文档字符串，并稍微调整了一
下措辞（见❶）。
现在可以编写一个简单的循环，计算要分析的任何文本包含多少个单
词了。为此，我们将要分析的文件的名称存储在一个列表中，然后对
列表中的每个文件都调用count_words()。我们将尝试计算 Alice
in Wonderland、Siddhartha、Moby Dick 和 Little Women 分别包含
多少个单词，它们都不受版权限制。我故意没有将siddhartha.txt放
到word_count.py所在的目录中，让你能够看到这个程序在文件不存在
时处理得有多出色：
def count_words(filename):
--snip--
filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt',
'little_women.txt']
for filename in filenames:
count_words(filename)
文件siddhartha.txt不存在，但这丝毫不影响这个程序处理其他文
件：
The file alice.txt has about 29461 words.
Sorry, the file siddhartha.txt does not exist.
The file moby_dick.txt has about 215136 words.
The file little_women.txt has about 189079 words.
在这个示例中，使用try-except代码块提供了两个重要的优点：避
免让用户看到traceback；让程序能够继续分析能够找到的其他文件。
如果不捕获因找不到siddhartha.txt而引发的FileNotFoundError
异常，用户将看到完整的traceback，而程序将在尝试分析
Siddhartha 后停止运行——根本不分析 Moby Dick 和 Little
Women。
10.3.8　失败时一声不吭
在前一个示例中，我们告诉用户有一个文件找不到。但并非每次捕获
到异常时都需要告诉用户，有时候你希望程序在发生异常时一声不
吭，就像什么都没有发生一样继续运行。要让程序在失败时一声不
吭，可像通常那样编写try代码块，但在except代码块中明确地告诉
Python什么都不要做。Python有一个pass语句，可在代码块中使用它
来让Python什么都不要做：
def count_words(filename):
"""计算一个文件大致包含多少个单词"""
try:
--snip--
except FileNotFoundError:
pass ❶
else:
--snip--
filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt',
'little_women.txt']
for filename in filenames:
count_words(filename)
相比于前一个程序，这个程序唯一不同的地方是❶处的pass语句。现
在，出现FileNotFoundError异常时，将执行except代码块中的
代码，但什么都不会发生。这种错误发生时，不会出现traceback，也
没有任何输出。用户将看到存在的每个文件包含多少个单词，但没有
任何迹象表明有一个文件未找到：
The file alice.txt has about 29461 words.
The file moby_dick.txt has about 215136 words.
The file little_women.txt has about 189079 words.
pass语句还充当了占位符，它提醒你在程序的某个地方什么都没有
做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可
能决定将找不到的文件的名称写入到文件missing_files.txt中。用户
看不到这个文件，但我们可以读取这个文件，进而处理所有文件找不
到的问题。
10.3.9　决定报告哪些错误
在什么情况下该向用户报告错误？在什么情况下又应该在失败时一声
不吭呢？如果用户知道要分析哪些文件，他们可能希望在有文件没有
分析时出现一条消息，将其中的原因告诉他们。如果用户只想看到结
果，而并不知道要分析哪些文件，可能就无需在有些文件不存在时告
知他们。向用户显示他不想看到的信息可能会降低程序的可用性。
Python的错误处理结构让你能够细致地控制与用户分享错误信息的程
度，要分享多少信息由你决定。
编写得很好且经过详尽测试的代码不容易出现内部错误，如语法或逻
辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文
件、有网络链接，就有可能出现异常。凭借经验可判断该在程序的什
么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信
息。
动手试一试
10-6 加法运算：提示用户提供数值输入时，常出现的一个问题
是，用户提供的是文本而不是数字。在这种情况下，当你尝试将
输入转换为整数时，将引发ValueError异常。编写一个程序，
提示用户输入两个数字，再将它们相加并打印结果。在用户输入
的任何一个值不是数字时都捕获ValueError异常，并打印一条
友好的错误消息。对你编写的程序进行测试：先输入两个数字，
再输入一些文本而不是数字。
10-7 加法计算器：将你为完成练习10-6而编写的代码放在一个
while循环中，让用户犯错（输入的是文本而不是数字）后能够
继续输入数字。
10-8 猫和狗：创建两个文件cats.txt和dogs.txt，在第一个文
件中至少存储三只猫的名字，在第二个文件中至少存储三条狗的
名字。编写一个程序，尝试读取这些文件，并将其内容打印到屏
幕上。将这些代码放在一个try-except代码块中，以便在文件
不存在时捕获FileNotFound错误，并打印一条友好的消息。将
其中一个文件移到另一个地方，并确认except代码块中的代码
将正确地执行。
10-9 沉默的猫和狗：修改你在练习10-8中编写的except代码
块，让程序在文件不存在时一言不发。
10-10 常见单词：访问项目
Gutenberg（http://gutenberg.org/），并找一些你想分析的图
书。下载这些作品的文本文件或将浏览器中的原始文本复制到文
本文件中。
你可以使用方法count()来确定特定的单词或短语在字符串中出
现了多少次。例如，下面的代码计算'row'在一个字符串中出现
了多少次：
>> line = "Row, row, row your boat"
>> line.count('row')
2
>> line.lower().count('row')
3
请注意，通过使用lower()将字符串转换为小写，可捕捉要查找
的单词出现的所有次数，而不管其大小写格式如何。
编写一个程序，它读取你在项目Gutenberg中获取的文件，并计算
单词'the'在每个文件中分别出现了多少次。
10.4　存储数据
很多程序都要求用户输入某种信息，如让用户存储游戏首选项或提供
要可视化的数据。不管专注的是什么，程序都把用户提供的信息存储
在列表和字典等数据结构中。用户关闭程序时，你几乎总是要保存他
们提供的信息；一种简单的方式是使用模块json来存储数据。
模块json让你能够将简单的Python数据结构转储到文件中，并在程序
再次运行时加载该文件中的数据。你还可以使用json在Python程序之
间分享数据。更重要的是，JSON数据格式并非Python专用的，这让你
能够将以JSON格式存储的数据与使用其他编程语言的人分享。这是一
种轻便格式，很有用，也易于学习。
注意　JSON（JavaScript Object Notation）格式最初是为
JavaScript开发的，但随后成了一种常见格式，被包括Python在
内的众多语言采用。
10.4.1　使用json.dump()和json.load()
我们来编写一个存储一组数字的简短程序，再编写一个将这些数字读
取到内存中的程序。第一个程序将使用json.dump()来存储这组数
字，而第二个程序将使用json.load()。
函数json.dump()接受两个实参：要存储的数据以及可用于存储数
据的文件对象。下面演示了如何使用json.dump()来存储数字列
表：
number_writer.py
import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json' ❶
with open(filename, 'w') as f_obj: ❷
json.dump(numbers, f_obj) ❸
我们先导入模块json，再创建一个数字列表。在❶处，我们指定了要
将该数字列表存储到其中的文件的名称。通常使用文件扩展名.json来
指出文件存储的数据为JSON格式。接下来，我们以写入模式打开这个
文件，让json能够将数据写入其中（见❷）。在❸处，我们使用函数
json.dump()将数字列表存储到文件numbers.json中。
这个程序没有输出，但我们可以打开文件numbers.json，看看其内
容。数据的存储格式与Python中一样：
[2, 3, 5, 7, 11, 13]
下面再编写一个程序，使用json.load()将这个列表读取到内存
中：
number_reader.py
import json
filename = 'numbers.json' ❶
with open(filename) as f_obj: ❷
numbers = json.load(f_obj) ❸
print(numbers)
在❶处，我们确保读取的是前面写入的文件。这次我们以读取方式打
开这个文件，因为Python只需读取这个文件（见❷）。在❸处，我们
使用函数json.load()加载存储在numbers.json中的信息，并将其
存储到变量numbers中。最后，我们打印恢复的数字列表，看看它是
否与number_writer.py中创建的数字列表相同：
[2, 3, 5, 7, 11, 13]
这是一种在程序之间共享数据的简单方式。
10.4.2　保存和读取用户生成的数据
对于用户生成的数据，使用json保存它们大有裨益，因为如果不以某
种方式进行存储，等程序停止运行时用户的信息将丢失。下面来看一
个这样的例子：用户首次运行程序时被提示输入自己的名字，这样再
次运行程序时就记住他了。
我们先来存储用户的名字：
remember_me.py
import json
username = input("What is your name? ") ❶
filename = 'username.json'
with open(filename, 'w') as f_obj:
json.dump(username, f_obj) ❷
print("We'll remember you when you come back, " + username +
"!") ❸
在❶处，我们提示输入用户名，并将其存储在一个变量中。接下来，
我们调用json.dump()，并将用户名和一个文件对象传递给它，从
而将用户名存储到文件中（见❷）。然后，我们打印一条消息，指出
我们存储了他输入的信息（见❸）：
What is your name? Eric
We'll remember you when you come back, Eric!
现在再编写一个程序，向其名字被存储的用户发出问候：
greet_user.py
import json
filename = 'username.json'
with open(filename) as f_obj:
username = json.load(f_obj) ❶
print("Welcome back, " + username + "!") ❷
在❶处，我们使用json.load()将存储在username.json中的信息读
取到变量username中。恢复用户名后，我们就可以欢迎用户回来了
（见❷）：
Welcome back, Eric!
我们需要将这两个程序合并到一个程序（remember_me.py）中。这个
程序运行时，我们将尝试从文件username.json中获取用户名，因此我
们首先编写一个尝试恢复用户名的try代码块。如果这个文件不存
在，我们就在except代码块中提示用户输入用户名，并将其存储在
username.json中，以便程序再次运行时能够获取它：
remember_me.py
import json
# 如果以前存储了用户名，就加载它
# 否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
with open(filename) as f_obj: ❶
username = json.load(f_obj) ❷
except FileNotFoundError: ❸
username = input("What is your name? ") ❹
with open(filename, 'w') as f_obj: ❺
json.dump(username, f_obj)
print("We'll remember you when you come back, " + username
+ "!")
else:
print("Welcome back, " + username + "!")
这里没有任何新代码，只是将前两个示例的代码合并到了一个程序
中。在❶处，我们尝试打开文件username.json。如果这个文件存在，
就将其中的用户名读取到内存中（见❷），再执行else代码块，即打
印一条欢迎用户回来的消息。用户首次运行这个程序时，文件
username.json不存在，将引发FileNotFoundError异常（见❸），
因此Python将执行except代码块：提示用户输入其用户名（见❹），
再使用json.dump()存储该用户名，并打印一句问候语（见❺）。
无论执行的是except代码块还是else代码块，都将显示用户名和合
适的问候语。如果这个程序是首次运行，输出将如下：
What is your name? Eric
We'll remember you when you come back, Eric!
否则，输出将如下：
Welcome back, Eric!
这是程序之前至少运行了一次时的输出。
10.4.3　重构
你经常会遇到这样的情况：代码能够正确地运行，但可做进一步的改
进——将代码划分为一系列完成具体工作的函数。这样的过程被称为
重构。重构让代码更清晰、更易于理解、更容易扩展。
要重构remember_me.py，可将其大部分逻辑放到一个或多个函数中。
remember_me.py的重点是问候用户，因此我们将其所有代码都放到一
个名为greet_user()的函数中：
remember_me.py
import json
def greet_user():
"""问候用户，并指出其名字""" ❶
filename = 'username.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
username = input("What is your name? ")
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
print("We'll remember you when you come back, " +
username + "!")
else:
print("Welcome back, " + username + "!")
greet_user()
考虑到现在使用了一个函数，我们删除了注释，转而使用一个文档字
符串来指出程序是做什么的（见❶）。这个程序更清晰些，但函数
greet_user()所做的不仅仅是问候用户，还在存储了用户名时获取
它，而在没有存储用户名时提示用户输入一个。
下面来重构greet_user()，让它不执行这么多任务。为此，我们首
先将获取存储的用户名的代码移到另一个函数中：
import json
def get_stored_username():
"""如果存储了用户名，就获取它""" ❶
filename = 'username.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
return None ❷
else:
return username
def greet_user():
"""问候用户，并指出其名字"""
username = get_stored_username()
if username: ❸
print("Welcome back, " + username + "!")
else:
username = input("What is your name? ")
filename = 'username.json'
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
print("We'll remember you when you come back, " +
username + "!")
greet_user()
新增的函数get_stored_username()目标明确，❶处的文档字符串
指出了这一点。如果存储了用户名，这个函数就获取并返回它；如果
文件username.json不存在，这个函数就返回None（见❷）。这是一
种不错的做法：函数要么返回预期的值，要么返回None；这让我们能
够使用函数的返回值做简单测试。在❸处，如果成功地获取了用户
名，就打印一条欢迎用户回来的消息，否则就提示用户输入用户名。
我们还需将greet_user()中的另一个代码块提取出来：将没有存储
用户名时提示用户输入的代码放在一个独立的函数中：
import json
def get_stored_username():
"""如果存储了用户名，就获取它"""
--snip--
def get_new_username():
"""提示用户输入用户名"""
username = input("What is your name? ")
filename = 'username.json'
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
return username
def greet_user():
"""问候用户，并指出其名字"""
username = get_stored_username()
if username:
print("Welcome back, " + username + "!")
else:
username = get_new_username()
print("We'll remember you when you come back, " + username
+ "!")
greet_user()
在remember_me.py的这个最终版本中，每个函数都执行单一而清晰的
任务。我们调用greet_user()，它打印一条合适的消息：要么欢迎
老用户回来，要么问候新用户。为此，它首先调用
get_stored_username()，这个函数只负责获取存储的用户名
（如果存储了的话），再在必要时调用get_new_username()，这
个函数只负责获取并存储新用户的用户名。要编写出清晰而易于维护
和扩展的代码，这种划分工作必不可少。
动手试一试
10-11 喜欢的数字：编写一个程序，提示用户输入他喜欢的数
字，并使用json.dump()将这个数字存储到文件中。再编写一
个程序，从文件中读取这个值，并打印消息“I know your
favorite number! It's _____.”。
10-12 记住喜欢的数字：将练习10-11中的两个程序合而为一。
如果存储了用户喜欢的数字，就向用户显示它，否则提示用户输
入他喜欢的数字并将其存储到文件中。运行这个程序两次，看看
它是否像预期的那样工作。
10-13 验证用户：最后一个remember_me.py版本假设用户要么已
输入其用户名，要么是首次运行该程序。我们应修改这个程序，
以应对这样的情形：当前和最后一次运行该程序的用户并非同一
个人。
为此，在greet_user()中打印欢迎用户回来的消息前，先询问
他用户名是否是对的。如果不对，就调用
get_new_username()让用户输入正确的用户名。
10.5　小结
在本章中，你学习了：如何使用文件；如何一次性读取整个文件，以
及如何以每次一行的方式读取文件的内容；如何写入文件，以及如何
将文本附加到文件末尾；什么是异常以及如何处理程序可能引发的异
常；如何存储Python数据结构，以保存用户提供的信息，避免用户每
次运行程序时都需要重新提供。
在第11章中，你将学习高效的代码测试方式，这可帮助你确定代码正
确无误，以及发现扩展现有程序时可能引入的bug。