Hello，大家好，牛年快乐呀~
本书的前半部分，还剩最后两个章节：《文件与异常》和《测试代码》。在这两章中，一边巩固过去学的一些知识，一边学习新内容。
话不多说，我们开始吧。
10.1 从文件中读取数据
文本文件可存储的数据量多得难以置信：天气数据、交通数据、文学作品等。每当需要分析或修改存储在文件中的信息时，读取文件都很有用，对数据分析应用程序来说尤其如此。例如，可以编写一个这样的程序：读取一个文本文件的内容，重新设置谢谢数据的格式并将其写入文件，让浏览器能够显示这些内容。
要使用文本文件中的信息，首先需要将信息读取到内存中。为此，你可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取10.1.1 读取整个文件
要读取文件，需要一个包含几行文本的文件。下面首先创建一个文件，它包含精确到小数点后30位的圆周率值，且在小数点后每10位处换行：
3.1415926535
8979323846
2643383279
要动手尝试后续示例，可在编辑器中输入这些数据行，再将文件保存为pi.txt，也可从本书主页(ituring.cn/book/2784)下载该文件。请将该文件保存到本章程序所在的目录：
下面的程序打开并读取这个文件，再将其内容显示到屏幕上：
with open('pi.txt') as file_object:
contents = file_object.read()
print(contents)
在这个程序中，第一行代码做了大量的工作。我们先来看看函数open()。要以任何方式使用文件，哪怕仅仅是打印其对象，都得先打开文件，才能访问它。函数open()接受一个参数：要打开的文件的名称。Python在file_reader.py所在的目录中查找pi.txt。函数open()返回一个表示文件的对象。在这里，open('pi.txt')返回一个表示文件pi.txt的对象，Python将该对象赋给file_object供以后使用。
关键字with在不需要访问文件后将其关闭。在这个程序中，注意我们调用了open()，但没有调用close()。也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug导致方法close()未执行，文件将不会关闭。这看似微不足道，但未妥善关闭文件可能导致数据丢失或受损。如果在程序中过早调用close()，你会发现需要使用文件时，它已关闭（无法访问），这回导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。附：
close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作， 否则会触发 ValueError 错误。 close() 方法允许调用多次。
当 file 对象，被引用到操作另外一个文件时，Python 会自动关闭之前的 file 对象。 使用 close() 方法关闭文件是一个好的习惯。
whit()提供了一种机制，可以在进入和退出（无论正常退出，还是异常退出）某个语句块时，自动执行自定义的代码。
对这个机制的封装，叫做上下文管理器。with 是对上下文管理器的调用。
with 通常用来处理访问资源后，对资源的释放工作。
有了表示pi.txt的文件对象后，使用方法read()读取这个文件的全部内容，并将其作为一个长长的字符串赋给变量contents的值，就可将这个文本文件的全部内容显示出来：
3.1415926535
8979323846
2643383279
相比于原始文件，该输出唯一不同的地方是末尾多了一个空行。为何会多出这个空行呢？因为read()到达文件末尾时返回一个空字符串，而降这个而空字符串显示出来时就是一个空行。要删除多出来的空行，可在函数调用print()中使用rstrip():
with open('pi.txt') as file_object:
contents = file_object.read()
print(contents.rstrip())
本书前面说过，Python方法rstrip()删除字符串末尾的空白。现在，输出与原始文件的内容完全相同：
3.1415926535
8979323846
264338327910.1.2
将类似于pi.txt的简单文件名传递给函数open()时，Python将在当前执行的文件（即.py程序文件）所在的目录中查找。
根据你组织文件的方式，有时可能要打开不再程序文件所在目录中的文件。例如，你可能将程序文件存储在了文件夹python_work中，而该文件夹中有一个名为text_files的文件夹用于存储程序文件操作的文本文件。虽然文件夹text_files包含在python_work中，但仅向open()传递位于前者中的文件名称也不可行，因为Python只在文件夹Python_work中查找，而不会在其子文件夹text_files中查找。要让Python打开不与程序文件位于同一个目录中的文件，需要提供文件路径，让Python到系统的特定位置去找。
由于文件夹text_files位于文件夹python_work中，可以使用相对文件路径来打开其中的文件。相对文件路径让python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。例如，可以这样编写代码：
with open('text_files/filename.txt') as file_object:
这行代码让Python到文件夹Python_work下的文件夹text_files中取查找指定的txt文件。
注意：显示文件路径时，Windows系统使用反斜杠（\）而不是斜杠（/），但在代码中依然可以使用斜杠。
还可以将文件在计算机中的准确位置告诉Python，这样就不用关心当前运行的程序存储在什么地方了。这称之为绝对文件路径。在相对路径行不通时，可使用绝对路径。例如，如果text_files并不在文件夹python_work中，而在文件夹other_files中，则向open()传递路径'text_files/filename.txt'行不通，因为Python只在文件夹Python_work中查找该位置。为明确指出希望Python到哪里查找，需要提供完整的路径。
绝对路径通常比相对路径长，因此将其赋给一个变量，再将变量传输给open()会有所帮助：
path = '/Users/gregory_mac/PycharmProjects/pythonProject/pi.txt'
with open(path) as file_object:
contents = file_object.read()
print(contents.rstrip())
通过使用绝对路径，可读取系统中任何地方的文件。就目前而言，最简单的做法是：要么将数据文件存储在程序文件所在的目录，要么将其存储在程序文件所在目录下的一个文件夹（如text_files）中。
注意：如果在文件路径中直接使用反斜杠，将引发错误，因为反斜杠用于对字符串中的字符进行转义。例如，对于途径“C:\path\to\pi.txt”，其中的\t将被解读为制表符。如果一定要使用反斜杠，可对路径中的每个反斜杠都进行转义。
C:\\path\\to\\pi.txt10.1.3 逐行读取
读取文件时，常常需要检查其中的每一行：可能要在文件中查找特定的信息，或者要以某种方式修改文件中的文本。例如，你可能要遍历一个包含天气数据的文件，并使用天气描述中包含sunny字样的行。在新闻报道中，你可能会查找包含标签<headline>的行，并按特定的格式设置它。
要以每次一行的方式检查文件，可对文件对象使用for循环：
①path = 'pi.txt'
②with open(path) as file_object:
③ for line in file_object:
print(line)
在①处，将要读取的文件名赋给变量filename。这是使用文件时的一种常见做法。变量filename表示的并非实际文件——它只是一个让python知道到哪里去查找文件的字符串，因此可以轻松地将'pi.txt'替换为要使用的另一个文件的名称。调用open()后，将一个表示文件及其内部的对象赋给了变量file_object（见②）。这里也是用了关键字with没让Python负责妥善地打开和关闭文件。为查看文件的内容，通过对文件对象执行循环来遍历文件中的每一行（见③）。
打印每一行时，发现空白行更多了：
3.1415926535
8979323846
2643383279
为何会出现这些空白行呢？因为在这个文件中，每行的末尾都有一个看不见的换行符，而函数调用print()也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自函数调用print()。要消除这些多余的空白行，可在函数调用print()中使用rstrip():
path = 'pi.txt'
with open(path) as file_object:
for line in file_object:
print(line.rstrip())
现在，输出又与文件内容完全相同了：
3.1415926535
8979323846
264338327910.1.4 创建一个包含文件各行内容的列表
使用关键字with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容，可在with代码块内将文件的各行存储在一个列表中。并在with代码块外使用该列表：可以立即处理文件的各个部分，也可以推迟到程序后面再处理。
下面的示例在with代码块中将文件pi.txt的各行存储在一个列表中，再在with代码块外打印：
path = 'pi.txt'
with open(path) as file_object:
① lines = file_object.readlines()
②for line in lines:
print(line.rstrip())
①处的方法readlines()从文件中读取每一行，并将其存储在一个列表中。接下来，该列表被赋给变量lines。在with代码块外，依然可使用这个变量。在②处，使用一个简单的for循环来打印lines中的各行。因为列表lines的每个元素都对应于文件中的一行，所以输出与文件内容完全一致。10.1.5 使用文件的内容
将文件读取到内存中后，就能以任何方式使用这些数据了。下面以简单的方式使用圆周率的值。首先，创建一个字符串，它包含文件中存储的所有数字，且没有任何空格：
path = 'pi.txt'
with open(path) 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()：
for line in lines:
pi_string += line.strip()
这样就获得了一个字符串，其中包含准确到30位小数的圆周率值。这个字符串长32字符：因为它还包括了整数部分的3和小数点：
3.141592653589793238462643383279
32
注意：读取文本文件时，Python将其中的所有文本都解读为字符串。如果读取的是数，并要将其作为数值使用，就必须使用函数int()将其转换为整数或使用函数float()将其转换为浮点数。10.1.6 包含一百万位的大型文件
前面分析的都是一个只有三行的文本文件，但这些代码示例也可以处理大得多的文件。如果我们有一个文本文件，其中包含精确到小数点后1 000 000位而不是30位的圆周率值，也可创建一个包含所有这些数字的字符串。为此，无需对前面的程序做任何修改，只要将这个文件传递给它即可。在这里，只打印到小数点后50位，以免终端为显示全部1 000 000位而不断滚动：
path = 'pi.txt'
with open(path) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.strip()
print(f'{pi_string[:50]}...')
print(len(pi_string))
输出表明，创建的字符串确实包含精确到小数点50位的圆周率值：
3.141592653589793238462643383279502884197169399375...
52
对于可处理的数据量，Python没有任何限制。只要系统的内存足够多，你想处理多少数据都可以。
注意：要运行这个程序（以及后面的众多示例），需要从http://ituring.cn/book/2784 下载相关资源。10.1.7 圆周率值中包含你的生日吗
我一直想知道自己的生日是否包含在圆周率值中。下面来扩展刚才写的程序，以确定某个人的生日是否包含在圆周率值的前1 000 000位中。为此，可将生日表示为一个由数字组成的字符串，再检查这个字符串是否包含在pi_string中：
path = 'pi.txt'
with open(path) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.strip()
①birthday = input("输出你的生日，格式为年月日：")
②if birthday in pi_string:
print("你的生日在圆周率里！")
else:
print("你的生日不在圆周率里！")
在①处，提示用户输入生日。在②处，检查这个字符串是否包含在pi_string中。下面来运行一下这个程序：
输出你的生日，格式为年月日：19060207
你的生日不在圆周率里！
溥仪的生日没有出现在圆周率值中！读取文件的内容后，能以你能想到的任何方式对其进行分析。10.2 写入文件
保存数据的最简单方式之一就是将其写入文件中。通过将输出写入文件，即便关闭包含程序输出的终端窗口，这些输出也依然存在：可以在程序结束运行后查看这些输出，可以与别人分享输出文件，还可以编写程序来将这些输出读取到内存中并进行处理。
10.2.1 写入空文件
要将文本写入文件，你在调用open()时需要提供另一个实参，告诉Python你要写入打开的文件。为明白其中的工作原理，我们来将一条简单的消息存储到文件中，而不是将其打印到屏幕上：
path = 'programming.txt'
①with open(path,'w') as file_object:
② file_object.write("I love programming")
在本例中，调用open()时提供了两个实参（见①）。第一个实参也是要打开的文件的名称。第二个实参('w')告诉Python，要以写入模式打开这个文件。打开文件时，可指定读入模式('r')、写入模式('w')、附加模式('a')或读写模式('r+')。如果省略了模式实参，Python将以默认的只读模式打开文件。
如果要写入的文件不存在，函数open()将自动创建它。然而，以写入模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该对象的内容。
在②处，使用文件对象的方法write()将一个字符串写入文件。这个程序没有终端输出，但如果打开文件programming.txt，将看到其中包含如下一行代码：
I love programming
相比于计算机中的其他文件，这个文件没有什么不同。你可以打开它、在其中输入新文本、复制其内容、将内容粘贴到其中，等等。
注意：Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先试用函数str()将其转换为字符串格式。10.2.2 写入空行
函数write()不会在写入的文本末尾添加换行符，因此如果写入多行时没有指定换行符，文件看起来可能不是你希望的那样：
path = 'programming.txt'
with open(path,'w') as file_object:
file_object.write("我爱刘亦菲！")
file_object.write("我爱新垣结衣！")
如果你打开programming.txt，将发现两行内容挤在一起：
我爱刘亦菲！我爱新垣结衣！
要让每个字符串都单独占一行，需要在方法调用write()中包含换行符：
file_object.write("我爱刘亦菲！\n")
file_object.write("我爱新垣结衣！\n")
现在，输出出现在不同的行中：
我爱刘亦菲！
我爱新垣结衣！
像显示到终端的输出一样，还可以使用空格、制表符和空行来设置这些输出的格式。10.2.3 附加到文件
如果要给文件添加内容，而不是覆盖原有的内容，可以以附加模式打开文件。以附加模式打开文件时，Python不会在返回文件对象前清空文件的内容，而是将写入文件的行添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。
下面来修改刚才的.py文件，在既有文件prigramming.txt中添加一些内容：
path = 'programming.txt'
①with open(path,'a') as file_object:
② file_object.write("我爱朴智妍！\n")
file_object.write("我爱朴孝敏！\n")
在①处，打开文件时指定了实参'a'，以便将内容附加到文件末尾，而不是覆盖文件原来的内容。在②处，又写入了两行，它们被添加到文件programming.txt末尾：
我爱刘亦菲！
我爱新垣结衣！
我爱朴智妍！
我爱朴孝敏！
最终的结果是，文件原来的内容还在，后面则是刚添加的内容。因书中没有“r+”的内容，我自己试了试，首先确实可以读。写的话是以’a’的方式写入，也就是在末尾处增加，而非像’w’那样直接覆盖。
10.3 异常
Python使用称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行，如果未对异常进行处理，程序将停止并显示traceback，其中包含有关异常的报告。
异常是使用try-except代码块处理的。try-except代码块让Python执行制定的操作，同时告诉Python发生异常时该怎么办。使用try-except代码块时，即便出现异常，程序也将继续运行，显示你编写的友好的错误信息，而不是令用户疑惑的traceback
10.3.1 处理ZeroDivisionError异常
下面来看一种导致Python引发异常的简单错误。你可能知道，不能用数除以0，但还是让Python这样做：
>>> 5/0
显然，Python无法这么做，因此你将看到一个traceback：
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
①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("你滋不滋道不能输入0？嗯？")
将导致错误的代码行print(5/0)放入一个try代码块中。如果try代码块中的代码运行起来没有问题，Python将跳过except代码块；如果try代码块中的代码导致了错误，Python将查找与之匹配的except代码块并运行其中的代码。
在本例中，try代码块中的代码引发了ZeroDivisionError异常，因此Python查找指出了该怎么办的except代码块，并运行其中的代码。这样，用户看到的是一条友好的错误消息，而不是traceback：
你滋不滋道不能输入0？嗯？
如果try-except代码块后面还有其他代码，程序将接着运行，因为已经告诉了Python如何处理这种错误。下面来看一个捕获错误后程序继续运行的示例.10.3.3 使用异常避免崩溃
发生错误时，如果程序还有工作尚未完成，妥善地处理错误就尤其重要。这种情况下经常会出现要求用户提供输入的程序中；如果程序能够妥善地处理无效输入，就能再提示用户提供有效输入，而不至于崩溃。
下面来创建一个只执行除法运算的简单计算器：
print("输入两个数字，然后得出两个数字的相除后的结果")
print("输入'q'后，将退出本程序")
while True:
① a = input("第一个数：")
if a == 'q':
break
② b = input("第二个数：")
if b == 'q':
break
③ c = int(a) / int(b)
print(c)
在①处，程序提示用户输入一个数，并将其赋给变量a。如果用户输入的不是表示退出的q，就再提示用户输入一个数，并将其赋给变量b（见②）。接下来，计算这两个数的商（见③）。该程序没有采取任何处理错误的措施，因此在执行除数为0的除法运算时，它会崩溃：
输入两个数字，然后得出两个数字的相除后的结果
输入'q'后，将退出本程序
第一个数：5
第二个数：0
Traceback (most recent call last):
File "/Users/gregory_mac/PycharmProjects/pythonProject/new_k_girl.py", line 12, in <module>
c = int(a) / int(b)
ZeroDivisionError: division by zero
程序崩溃可不好，但让用户看到traceback也不是个好主意。不懂技术的用户会被搞糊涂。怀有恶意的用户还会通过traceback获悉你不想他知道的信息。例如，他将知道你程序文本的名称，还将看到部分不能正确运行的代码。有时候，训练和又俗的攻击者可根据这些信息判断出可对你的代码发起什么样的攻击。10.3.4
else代码块，通过将可能引发错误的代码放在try-except代码块中，可提高程序抵御错误的能力。错误是执行除法运算的代码行导致的，因此需要将它放到try-except代码块中。这个示例还包含一个else代码块。依赖try代码块成功执行的代码都应放到else代码块中：
print("输入两个数字，然后得出两个数字的相除后的结果")
print("输入'q'后，将退出本程序")
while True:
a = input("第一个数：")
if a == 'q':
break
b = input("第二个数：")
if b == 'q':
break
① try:
c = int(a) / int(b)
② except ZeroDivisionError:
print("你滋不滋道不能输入0？嗯？")
③ else:
print(c)
让Python尝试执行try代码块中的除法运算（见①），这个代码块只包含可能导致错误的代码。依赖try代码块成功执行的代码都放在else代码块中。在本例中，如果除法运算成功，就使用else代码块来打印结果（见③）。
except代码块告诉Python，出现ZeroDivisionError异常时该如何办（见②）。如果try代码块因除0错误而失败，就打印一条友好的消息，告诉用户该如何避免这种错误。程序继续运行，用户根本看不到traceback：
输入两个数字，然后得出两个数字的相除后的结果
输入'q'后，将退出本程序
第一个数：5
第二个数：0
你滋不滋道不能输入0？嗯？
输入两个数字，然后得出两个数字的相除后的结果
输入'q'后，将退出本程序
第一个数：5
第二个数：0
你滋不滋道不能输入0？嗯？
第一个数：10
第二个数：2
5.0
第一个数：q
进程已结束,退出代码0
try-except-else代码块的工作原理大致如下。Python尝试执行try代码块中的代码，只有可能引发异常的代码才需要放在try语句中。有时候，有一些仅在try代码块成功执行时才需要运行的代码，这些代码应放在else代码块中。except代码块告诉Python，如果尝试运行try代码块的代码时引发了指定的异常该怎么办。
通过预测可能发生错误的代码，可编写健壮的程序。它们即便面临无效数据或缺少资源，也能继续运行，从而低于无意的用户错误和恶意的攻击。10.3.5 处理FileNotFoundError异常
使用文件时，一种常见的问题是找不到文件：查找的文件可能在其他地方，文件名可能不正确，或者这个文件根本就不存在。对于所有这些情形，都可使用try-except代码块以直官的方式处理。
我们来尝试读取一个不存在的文件。下面的程序尝试读取文件pi.txt的内容。但该文件没有存储在pi.py所在目录中：
name = 'pi.txt'
with open(name,encoding='utf-8') as f:
contents = f.read()
相比于本章前面的文件打开方式，这里有两个不同之处。一是使用变量f来标识文件对象，这是一种常见的做法。二是给参数encoding指定了值，在系统的默认编码与要读取文件使用的编码不一致时，必须这样做。
Python无法读取不存在的文件，因此它引发一个异常：
Traceback (most recent call last):
File "/Users/gregory_mac/PycharmProjects/pythonProject/wife.py", line 2, in <module>
with open(name,encoding='utf-8') as f:
FileNotFoundError: [Errno 2] No such file or directory: 'pi.txt'
上述traceback的最后一行报告了FileNotFoundError 异常，这是Python找不到要打开的文件时创建的异常。在本例中，这个错误是函数open()导致的。因此，要处理这个错误，必须将try语句放在包含open()的代码行之前：
name = 'pi.txt'
try:
with open(name,encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
print("喂！没有该文件啊，马鹿野郎！")
在本例中，try代码块引发了FileNotFoundError异常，因此Python找到与该错误匹配的except代码块，并运行其中的代码。最终的结果是显示一条友好的错误消息，而不是traceback：
喂！没有该文件啊，马鹿野郎！
如果文件不存在，这个程序就什么都做不了了，错误处理代码也意义不大。下面来扩展这个示例，看看在你使用多个文件时，异常处理可提供什么样的帮助。10.3.6 分析文本
你可以分析包含整本书的文本文件。很多经典文学作品都是简单以文本文件的形式提供的，因为它们不受版权限制。本节使用的文本来自于古登堡计划，该计划提供了一系列不受版权限制的文学作品。如果你要在变成项目中使用文学文本，这是一个不错的资源。
（胭惜雨：原文使用的是《爱丽丝漫游仙境》，我此处选用的是我国经典名著《红楼梦》）
下面来提取《红楼梦》的文本，并尝试计算它包含多个字。我们将使用方法split()，它能根据一个字符串创建一个单词列表。下面是对只包含“红楼梦”的字符串调用方法split的结果：
>>> title = "红 楼 梦"
>>> title.split()
['红', '楼', '梦']
方法split()以宫格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中，结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。
为计算《红楼梦》包含多少个字，我们将对整篇小说调用split()，再计算得到的列表包含多少个元素，从而确定整篇文章大致包含多少个字：
（因为方法split()不适用于中文语境，所以此处代码略有调整，使用本章前方圆周率的思路，统计技术）
name = '红楼梦.txt'
try:
with open(name,encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
print("喂！没有该文件啊，马鹿野郎！")
else:
① word = contents.rstrip()
② num_word = len(word)
③ print(f"{name}这本书一共有{num_word}字！")
我们将文件红楼梦.txt移到了正确的目录中，让try代码块能够成功执行。在①处，对变量contents调用方法rstrip，以删除结尾处的空格。使用len()确定这个内容的长度时，就能知道原始字符串大致包含多少个字了（见②）。在③处，打印一条消息，指出文件包含了多少个字，这个代码都放在else代码块中，因为仅当try代码块成功执行时才执行它们。输出指出了文件红楼梦.txt有多少个字
红楼梦.txt这本书一共有845570字！10.3.7 使用多个文件
下面多分析几本书。这次之前，先将这个程序的大部分代码转移到一个叫words()的函数中。这样，对多本书进行分析时将更容易：
def words(name):
try:
with open(name,encoding='utf-8') as f:
contents = f.read()
def word(name):
"""计算一个文件大致包含多少个字"""
try:
with open(name,encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
print("喂！没有该文件啊，马鹿野郎！")
else:
word = contents.strip()
num_word = len(word)
print(f"{name}这本书一共有{num_word}字！")
name = '红楼梦.txt'
words(name)
这些代码大多与原来一样，只是移到了函数words()中，并增加了缩进量。修改程序的同时更新注释是个不错的习惯。因此我们将注释改成文档字符串，并稍微调整了一下措辞。
现在可以编写一个简单的循环，计算要分析的任何文本包含多少个字了。为此，将要分析的文件的名称存储在一个列表中，然后对列表的每个文件调用words()。我们将尝试计算《红楼梦》、《西游记》分别包含多少个字，我故意没把《摩柯婆罗多》放到words.py所在的目录中，从而展示该程序在文件不存在时应对的有多出色：
def words(name):
"""计算一个文件大致包含多少个字"""
try:
with open(name, encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
print(f"喂！没有{name}这本书啊，马鹿野郎！")
else:
word = contents.strip()
num_word = len(word)
print(f"{name}这本书一共有{num_word}字！")
name = '红楼梦.txt'
words(name)
mingzhu = ['西游记.txt','摩柯婆罗多.txt']
for abcd in mingzhu:
words(abcd)
文件摩柯婆罗多.txt不存在，但这丝毫不影响该程序处理其他文件：
红楼梦.txt这本书一共有845570字！
西游记.txt这本书一共有677594字！
喂！没有摩柯婆罗多.txt这本书啊，马鹿野郎！
在本例中，使用try-except代码块提供了两个重要的优点：避免用户看到traceback，以及让程序继续分析能够找到的其他文件。如果不捕获因找不到摩柯婆罗多.txt而引发的FileNotFoundError 异常，用户将看到完整的traceback，而程序将在尝试分析摩柯婆罗多.txt后停止运行。它根本不会分析《红楼梦》和《西游记》。10.3.8 静默失败
在前一个示例中，我们告诉用户有一个文件找不到。但并非每次捕获到异常都需要告诉用户，有时候你希望程序在发生异常时保持静默，就像上面都没发生一样继续运行。要让程序静默失败，可像通常那样编写try代码块，但在except代码中明确告诉Python上面都不要做。Python有一个pass语句，可用于让Python在代码块中什么都不要做：
try:
with open(name, encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
pass
else:
word = contents.strip()
num_word = len(word)
print(f"{name}这本书一共有{num_word}字！")
相比于前一个程序，这个程序唯一不同之处就是在于pass语句。现在，出现FileNotFoundError 异常时，将执行except代码块中的代码，但什么都不会发生。这种错误发生时，不会出现traceback，也没有任何输出。用户将看到存在的每个文件包含多少个字，但没有任何迹象表明有一个文件未找到：
红楼梦.txt这本书一共有845570字！
西游记.txt这本书一共有677594字！
pass语句还充当了占位符，提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可能决定将找不到的文件名称写入文件miss.txt中。用户看不到这个文件，但我们可以读取它，进而处理所有找不到文件的问题。
def words(name):
"""计算一个文件大致包含多少个字"""
try:
with open(name, encoding='utf-8') as f:
contents = f.read()
except FileNotFoundError:
with open(name,'w') as n:
n.write("你个渣渣！")
else:
word = contents.strip()
num_word = len(word)
print(f"{name}这本书一共有{num_word}字！")
name = '红楼梦.txt'
words(name)
mingzhu = ['西游记.txt','摩柯婆罗多.txt']
for abcd in mingzhu:
words(abcd)
(胭惜雨：当找不到该文件时，创建该文件，并写入“你个渣渣！”)10.3.9 决定报告哪些错误
编写得很好且经过详尽测试的代码不容易出现内部错误，如语法或逻辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文件、有网络连接，就有可能出现异常。凭借经验可判断该在程序的什么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信息。10.4 存储数据
很多程序都要求用户输入某种信息。不管关注点是什么，程序都把用户提供的希希存储在列表和字典等数据结构中。用户关闭程序时，几乎总是要保存他们提供的信息。一种简单的方式是使用模块json来存储信息。
模块json让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json在Python程序之间分享数据。更重要的是，json数据格式并非Pythonzhuany9ng的，这让你能够以json格式存储的数据与使用其他变成语言的人分享。这是一个轻便而有用的格式，也易于学习。
10.4.1 使用json.dump()和json.load()
我们来编写一个存储一组数的简单程序，再编写一个将这些数读取到内存中的程序。第一个程序将使用json.dump()来存储这组数，而第二个程序将使用json.load()。
函数json.dump()接受两个实参：要存储的数据，以及可用于存储数据的文件对象。下面演示了如何使用json.dump()来存储数字列表：
import json
num = [2,3,4,5,6,7,8,9]
①name = 'num.json'
②with open(name,'w') as f:
③ json.dump(num,f)
先导入模块json，再创建一个数字列表。在①处，指定了要将该数字列表存储到哪个文件中。通常使用文件扩展名.json来支出文件存储的数据为json格式。接下来，以写入模式打开这个文件，让json能够将数据写入其中（见②）。在③处，使用函数json.dump()将数字列表存储到文件num.json中。
这个程序没有输出，但可以打开文件num.json来看看内容。数据的存储格式与Python中一样：
[2, 3, 4, 5, 6, 7, 8, 9]
下面再编写一个程序，使用json.load将列表读取到内存中：
import json
①name = 'num.json'
②with open(name) as f:
③ num = json.load(f)
print(num)
在①处，确保读取的是前面写入的文件。这次以读取方式打开该文件，因为Python只需要读取它。在③处，使用函数json.load()加载存储在num.json中的信息，并将其赋给变量num中。最后，打印恢复的数字列表，看看是否与num.py创建的数字列表相同：
[2, 3, 4, 5, 6, 7, 8, 9]
这是一种在程序之间共享数据的简单方式。10.4.2 保存和读取用户生成的数据
使用json保存用户生成的数据大有裨益，因为如果不以某种方式存储，用户的信息会在程序停止运行时丢失。下面来看这样的例子：提示用户首次运行程序时输入自己的名字，并在再次运行程序时记住他。
先来存储用户的名字：
import json
①username =input("请输入你的名字：")
file = 'username.json'
with open(file,'w') as f:
② json.dump(username,f)
③ print(f"已存储您的用户名，{username}!")
在①处，提示输入用户名并将其赋给一个变量。接下来，调用json.dump()，并将用户名和一个文件对象传递给它，从而将用户名存储到文件中（见②）。然后，打印一条消息，指出存储了用户输入的消息。
请输入你的名字：全孝盛
已存储您的用户名，全孝盛!
现在再编写一个程序，向已存储了名字用户发出问候：
import json
filename = 'username.json'
with open(filename) as f:
① name = json.load(f)
② print(f"欢迎回来{name}！")
在①处，使用json.load()将存储在username.json中的信息读取到变量filename中。恢复用户名后，就可以欢迎用户回来了：
欢迎回来全孝盛！
需要将这两个程序合并到一个程序中。这个程序运行时，将尝试从文件username.json中获取用户名。因此，首先编写一个尝试恢复用户名的try代码块。如果这个文件不存在，就在except中提示用户输入用户名，并将其存储到username.json中，以便程序再次运行时能获取：
import json
# 如果以前存储了用户名，就加载它
#否则，提示用户输入用户名并存储它。
filename = 'username.json'
try:
① with open(filename) as f:
② username = json.load(f)
③except FileNotFoundError:
④ usename = input("请输入你的用户名：")
⑤ with open(filename,'w')as f:
json.dump(username,f)
print(f"已记录您的用户名！")
else:
print(f"欢迎回来{username}!")
这里没有任何新代码，只是将前两个示例的代码合并到了一个程序中。在①处，尝试打开文件username.json。如果该文件存在，就将其中的用户名读取到内存中（见②），再执行else代码块，打印一条欢迎用户回来的消息。用户首次运行该程序时，文件username.json不存在，将引发filenotfounderror异常（见③）。因此Python将执行except代码块，提示用户输入用户名（见④），再使用json.dump()存储该用户名并打印一条问候语（见⑤）。
无论执行的是except还是else代码块，都将显示用户名和合适的问候语：
欢迎回来全孝盛!
这是程序之前至少运行了一次时的输出。10.4.3 重构
你经常会遇到这样的情况：代码能够正常的运行，但通过将其划分为一系列完成具体工作的函数，还可以改进。这样的过程称之为重构，重构让代码更清晰、更易于理解、更容易扩展。
要重构上节的代码，可将大部分逻辑放到一个或多个函数中。该段代码的重点是问候用户，因此将其所有代码都放到一个user()的函数中：
import json
def user():
"""问候用户"""
filename = 'username.json'
try:
with open(filename) as f:
username = json.load(f)
except FileNotFoundError:
usename = input("请输入你的用户名：")
with open(filename,'w')as f:
json.dump(username,f)
print(f"已记录您的用户名！")
else:
print(f"欢迎回来{username}!")
user()
考虑到现在使用了一个函数，我们删除原注释，转而使用一个文档字符串来指出程序的作用。这个程序更加清晰，但函数user()所做的不仅仅是问候用户，还在存储了用户名时获取它、在没有存储用户名时提示用户输入。
下面来重构user()，减少其任务。为此，首先将获取已存储用户名的代码移到领一个函数中：
import json
def cunchu():
① """如果存储了用户名，就获取它"""
filename = 'username.json'
try:
with open(filename) as f:
username = json.load(f)
except FileNotFoundError:
return None
else:
② return username
def user():
"""问候用户"""
username = cunchu()
③ if username:
print(f"欢迎回来{username}!")
else:
username = input("请输入你的用户名：")
filename = 'username.json'
with open(filename,'w') as f:
json.dump(username,f)
print(f"已记录您的用户名，{username}")
user()
新增的函数cunchu()目标明确， ①处的文档字符串指出了这一点。如果存储了用户名，该函数的就获取并返回它；如果文件username.json不存在，该函数就返回None（见②）。这是一种不错的做法：函数要么返回预期的值，要么返回None。这让我们能够使用函数的返回值做简单的测试。在③处，如果成功地获取了用户名就打印一条欢迎用户回来的消息，否则提示用户输入用户名。
还需要重构user()中的另一个代码块，将没有存储用户名时提示用户输入的代码放在一个独立的函数中：
import json
def cunchu():
"""如果存储了用户名，就获取它"""
filename = 'username.json'
try:
with open(filename) as f:
username = json.load(f)
except FileNotFoundError:
return None
else:
return username
def new():
"""提示用户输入用户名。"""
username = input("请输入你的用户名：")
filename = 'username.json'
with open(filename, 'w') as f:
json.dump(username, f)
return username
def user():
"""问候用户"""
username = cunchu()
if username:
print(f"欢迎回来{username}!")
else:
username = cunchu()
print(f"已记录您的用户名，{username}")
user()
在本节代码的这个最终版本中，每个函数都执行单一而清晰的人物。我们调用user()，它打印一条合适的消息L要么欢迎老用户回来，要么问候新用户。为此，它首先调用cunchu()，该函数只负责获取已存储的用户名（如果存储了的话）。最后在必要时调用new()，该函数只负责获取并存储新用户的用户名。要编写出清晰而易于维护和扩展的代码，这种划分必不可少。本来刚跨过两座大山，刚想休息下，没想到本章的内容依旧很高。到重构部分的时候，我已经放弃治疗，安安心心的抄写内容了。要不是开篇大神就说过，建议前半部分花时间通读一遍，不求甚解，等实践课再回顾即可。我都想重新再学一遍前半部分了。
明天是理论课的最后一节：测试代码，你猜会不会更难呢？
胭惜雨
2021年02月13日