第 10 章 文件和异常
至此，我们掌握了编写组织有序而易于使用的程序所需的基本技能，该考虑让程序目标更明确，用途更大了。在本章中，我们将学习处理文件，让程序能够快速地分析大量的数据；我们将学习错误处理，避免程序在面对意外情形时崩溃；我们将学习异常，它们是Python创建的特殊对象，用于管理程序运行时出现的错误；我们还将学习模块json，它让我们能够保存用户数据，以免在程序停止运行后丢失。
学习处理文件和保存数据可以让我们的程序使用起来更容易：用户将能够选择输入什么样的数据，以及在什么时候输入；用户使用我们的程序做一些工作后，可将程序关闭，以后在接着往下做。学习处理异常可帮助我们应对文件不存在的情形，以及处理其他可能导致程序崩溃的问题。这让我们的程序在面对错误的数据时更健壮——不管这些错误数据源自无意的错误，还是源自破坏程度的恶意企图。我们在本章学习的技能可提高程序的适用性、可用性和稳定性。
10.1 从文件中读取数据
文本文件可存储的数据量多的难以置信：天气数据、交通数据、社会经济数据、文学作品等。每当需要分析或修改存储在文件中的信息时，读取文件都很有用，对数据分析应用程序来说尤其如此。例如，我们可以编写一个这样的程序：读取一个文本文件的内容，重新设置这些数据的格式并将其写入文件，让浏览器能够显示这些内容。
要使用文本文件中的信息，首先需要将信息读取到内存中。为此，我们可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取。
10.1.1 读取整个文件
要读取文件，需要一个包含几行文本的文件。下面首先来创建一个文件，它包含精确到小数点后30位的圆周率值，且在小数点后每10处换行：
pi_digits.txt
3.1415926535
8979323846
2643383279
下面的程序打开并读取这个文件，再将其内容显示到屏幕上：
file_reader.py
with open('pi_digits') 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的文件对象后，我们使用方法read()读取这个文件的全部内容，并将其作为一个长长的字符串存储在变量contents中。这样，通过打印
contents的值，就可将这个文本文件的全部内容显示出来。
3.1415926535
8979323846
2643383279
为何会多出这个空行呢？因为read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除末尾的空行，可在print语句中使用rstrip()：
with open('pi.digits') 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，这样就不用关心当前运行的程序存储在什么地方了。这称为绝对文件路径。在相对文件行不通时，可使用绝对路径。例如，如果text_files并不在文件夹Python_work中，而在文件夹other_files中，则向open()传递路径'text_files/filename.txt'行不通，因为Python只在文件夹Python_work中查找该位置。为明确地指出我们希望Python到哪里去查找，我们需要提供完整的路径。
绝对路径通常比相对路径更长，因此将其存储在一个变量中，因此将其存储在一个变量中，再将该变量传递给open()会有所帮助。在Linux和OS X中，绝对路径类似于下面这样：
file_path = '/home/ehmattes/other_files/text_files/filename.txt'
with open(file_path) as file_object:
通过使用绝对路径，可读取系统任何地方的文件。就目前而言，最简单的做法是，要么将数据文件存储在程序文件所在的目录，要么将其存储在程序文件所在目录下的一个文件夹(如text_files)中。
注意： Windows系统有时候能够正确地解读文件路径中的斜杠。如果你使用的是Windows系统，且结果不符合预期，请确保在文件路径中使用的是反斜杠。另外，由于反斜杠在Python中被视为转义标记，为在Windows中确保万无一失，应以原始字符串的方式指定路径，即在开头的单引号前加上r.
绝对路径：
file_path = '/home/zhuzhu/title10/pi_digits'
with open(file_path) as file_object:
cotents = file_object.read()
print(cotents.rstrip())
10.1.3 逐行读取
读取文件时，常常需要检查其中的每一行：我们可能要在文件中查找特定的信息，或者要以某种方式修改文件中的文本。例如，我们可能要遍历一个包含天气数据的文件，并使用天气描述中包含字样sunny的行。在新闻报道中，我们可能会查找包含标签<headline>的行，并按特定的格式设置它。
要以每次一行的方式检查文件，可对文件对象使用for循环：
file_reader.py
filename = 'pi_digits' --(1）
with open(filename) as file_object: --(2)
for line in file_object: --(3)
print(line)
在(1)处，我们将要读取的文件的名称存储在变量filename中，这是使用文件时一种常见的做法。由于变量filename表示的并非实际文件——它只是一个让Python知道到哪里去查找文件的字符串，因此可轻松地将'pi_digits'替换为你要使用的另一个文件的名称。调用open()后，将一个表示文件及其内容的对象存储到了变量file_object中。这里也使用了关键字with，让Python负责妥善地打开和关闭文件。为查看文件的内容，我们通过对文件对象执行循环来遍历文件中的每一行。
我们打印每一行，发现空白行更多了：
3.1415926535
8979323846
2643383279
为何会出现这些空白行呢？因为在这个文件中，每行的末尾都有一个看不见的换行符，而print语句也会加上一个换行符，因此每行末尾都
有两个换行符：一个来自文件，另一个来自print语句。要消除这些换行符，可在print语句中使用方法rstrip()：
with open('pi_digits') 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的各行存储在一个列表中，再在with代码块外打印它们：
filename = 'pi_digits'
with open(filename) as file_object:
lines = file_object.readlines() --(1)
print(lines)
for line in lines: --(2)
print(line.rstrip())
(1)处的方法readlines()从文件中读取每一行，并将其存储在一个列表中；接下来，该列表被存储到变量lines中；在with代码块外，我们依然可以使用这个变量。在(2)处，我们使用一个简单的for循环来打印lines中的各行。由于列表lines的每个元素都对应于文件中的一行，因此输出与文件内容完全一致：
['3.1415926535\n', ' 8979323846\n', ' 2643383279\n']
3.1415926535
8979323846
2643383279
可以看出，当我们输出列表的时候，在每个元素的末尾都有一个'\n'，说明存在一个换行符，我们看不见，但是会存在，因此使用这个列表的时候也应该注意。
10.1.5 使用文件的内容
将文件读取到内存中后，就可以以任何方式使用这些数据了。下面以简单的方式使用圆周率的值。首先，我们创建一个字符串，它包含文件中存储的所有数字，且没有任何空格：
filename = 'pi_digits'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = "" --(1)
for line in lines: --(2)
pi_string += line.rstrip()
print(pi_string) --(3)
print(len(pi_string))
就像前一个实例一样，我们首先打开文件，并将其中的所有行都存储在一个列表中。在(1)处，我们创建了一个变量pi_string,用于存储圆周率。
接下来，我们使用一个循环将各行都加入pi_string,并删除每行末尾的换行符。在(3)处，我们打印这个字符串及其长度：
3.1415926535 8979323846 2643383279
36
在变量pi_string存储的字符串中，包含原来位于每行左边的空格，为删除这些空格，可使用strip()而不是rstrip():
filename = 'pi_digits'
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 包含一百万的大型文件
前面我们分析的都是一个只有三行的文本文件，但这些代码示例也可以处理大得多的文件。如果我们有一个文本文件，其中包含精确到小数点后1000000位而不是30位的圆周率值，也可创建一个包含这些数字的字符串。为此，我们无需对前面的程序做任何修改，只需将这个文件传递给它即可。
在这里，我们只打印到小数点后50位，以免终端会显示全部1000000位而不断地翻滚：
filename = 'pi_digits'
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))
输出表明，我们创建的字符串确实包含精确到小数点后1000000位的圆周率值：
3.14159265358979323846264338327944444444444444444444......
658
对于我们可处理的数据量，Python没有任何限制；只要系统的内存足够多，我们想处理多少数据都可以。
10.1.7 圆周率值中包含你的生日吗
我一想知道自己的生日是否包含在圆周率中。下面来扩展刚才编写的程序，以确定某个人的生日是否包含在圆周率值的前1000000位中。为此，可将生日表示为一个由数字组成的字符串，再检查这个字符串是否包含在pi_string中：
filename = 'pi_digits'
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: ") --(1)
if birthday in pi_string: --(2)
print("Your birthday appears in the first million digits of pi!")
else:
print("Your birthday does not appears in the first million digits of pi!")
在（1）处，我们提示用户输入其生日，在接下来的（2）处，我们检查这个字符串是否包含在pi_string中。运行一下这个程序：
Enter your birthday,in the form mmddyy: 122689
Your birthday appears in the first million digits of pi!
我的生日确实出现在了圆周率值中！读取文件的内容后，就可以以我们能想到的任何方式对其进行分析。
动手试一试
10-1 Python学习笔记：在文本编辑器中新建一个文件，写几句话来总结一下你至此学到的Python只是，其中每一行都以“In Python you can”打头。将这个文件命名为learning_python.txt,并将其存储到为完成本章练习而编写的程序所在的目录中。编写一个程序，它读取这个文件，并将我们所写的内容打印三次：第一次打印是读取整个文件；第二次打印时遍历文件对象；第三次及打印是将各行存储在一个列表中，再在with代码块外打印它们。
filename = 'lenrning_python'
with open(filename) as file_object:
contents = file_object.read()
print(contents)
with open(filename) as file_object:
for line in file_object:
print(line.strip())
print("\n")
with open(filename) as file_object:
lines = file_object.readlines()
for line in lines:
print(line.strip())
运行结果如下：
In Python you can lenrn how to develop game.
In python you can learn how to do peration and maintenance.
In python you can lenrn how to do data analysis.
In python you can learn a lot of things which you can think.
In Python you can lenrn how to develop game.
In python you can learn how to do peration and maintenance.
In python you can lenrn how to do data analysis.
In python you can learn a lot of things which you can think.
In Python you can lenrn how to develop game.
In python you can learn how to do peration and maintenance.
In python you can lenrn how to do data analysis.
In python you can learn a lot of things which you can think.
10-2 C语言学习笔记：可使用方法replace()将字符串中的特定单词都替换为另一个单词。下面是一个简单的示例，演示了如何将句子中的'dog'替换为'cat'：
>>> message = "I really like dogs"
>>> message.replace('dog','cat')
'I really like cats'
读取我们刚创建的文件lenrning_python.txt中的每一行，将其中的Python都替换为另一门语言的名称，如C。将修改后的各行都打印到屏幕上。
filename = 'lenrning_python'
lines = []
with open(filename) as file_object:
for line in file_object:
string = line.replace('python',"C")
lines.append(string)
for message in lines:
print(message.strip())
运行如果如下：
In C you can lenrn how to develop game.
In C you can learn how to do peration and maintenance.
In C you can lenrn how to do data analysis.
In C you can learn a lot of things which you can think.
10.2 写入文件
保存数据的最简单方式之一是将其写入到文件中。通过将输出写入文件，即便关闭包含程序输出的终端窗口，这些输出也依然存在：我们可以在程序结束
运行后查看这些输出，可与别人分享输出文件，还可以编写程序来将这些输出读取到内存中并进行处理。
10.2.1 写入空文件
要将文本写入文件，我们在调用open()时需要提供另一个实参，告诉Python我们要写入打开的文件。为明白其中的工作原理，我们来看一条简单的消息存
储到文件中，而不是将其打印到屏幕上：
write_message.py
filename = 'programming.txt'
with open(filename,'w') as file_object: --(1)
file_object.write("I love programming.") --(2)
在这个示例中，调用open()时提供了两个实参(见1).第一个实参也是要打开的文件的名称；第二个实参('w')告诉Python，我们要以写入模式打开这个文件
。打开文件时，可指定读取模式('r')、写入模式('w')、附加模式('a')、或者让我们能够读取和写人文件的模式读写模式('r+').如果我们省略了模式实参，
Python将以默认的只读模式打开文件。
如果我们要写人的文件不存在，函数open()将自动创建它。然而，以写入('w')模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在
返回文件对象前清空该文件。
在(2)处，我们使用文件对象的方法write()将一个字符串写入文件。这个程序没有终端输出，但如果我们打开文件programming.txt，将看到其中包含如
下一行内容：
programming.txt
I love programming.
相比于我们的计算机中的其他文件，这个文件没有什么不同。我们可以打开它、在其中输入新文本、复制其内容，将内容粘贴到其中等。
注意：Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。
10.2.2 写入多行
函数write()不会在你写入的文本末尾添加换行符，因此如果我们写入多行时没有指定换行符，文本看起来可能不是我们希望的那样：
write_message.py
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 = 'programing.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中再添加一些我们酷爱编程的原因:
filename = 'programming.txt'
with open(filename,'a') as file_object: --(1)
file_object.write("I also love finding meaning in large datasets.\n") --(2)
file_object.write("I love creating apps that can run in a browser.\n")
在(1)处，我们打开文件时指定了实参'a'，以便将内容附加到文件末尾，而不是覆盖文件原来的内容。在(2)处，我们有写入了两行，它们被添加到文件
programming.txt末尾：
programming.txt
I love programming.
I love creating new games.
I also love finding meaning in large datasets.
I love creating apps tan can run in a browser.
最终的结果是，文件原来的内容还在，它们后面是我们刚添加的内容。
动手试一试
10-3 访客：编写一个程序，提示用户输入其名字；用户做出响应后，将其名字写入到文件guest.txt中。
分析：由于是写入，因为我们不可能覆盖前面一个来访的人，这也是不被允许的，因为采用的追加模式。
filename = 'guest.txt'
with open(filename,'a') as file_object:
guest = input("Please input your name: ")
file_object.write(guest.title() + "\n")
10-4 访客名单：编写一个while循环，提示用户输入其名字，用户输入名字后，在屏幕上打印一条问候语，并将一条访问记录添加到文件
guest_book.txt中。确保这个文件中的每天记录都独占一行。
filename = 'guest_book.txt'
with open(filename,'a') as file_object:
while True:
print("Enter 'q' to quit the programmer: ")
guest = input("Please input your name: ")
if guest == 'q':
break
else:
print("Hello, " + guest)
file_object.write(guest.title() + "\n")
运行结果如下：
Enter 'q' to quit the programmer:
Please input your name: geng changxue
Hello, geng changxue
Enter 'q' to quit the programmer:
Please input your name: zeng mingzhu
Hello, zeng mingzhu
Enter 'q' to quit the programmer:
Please input your name: zhang dabiao
Hello, zhang dabiao
Enter 'q' to quit the programmer:
Please input your name: q
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 "/home/zhuzhu/title10/division.py", line 1, in <module>
print(5/0)
ZeroDivisionError: division by zero --(1)
在上述traceback中，(1)处指出的错误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("\nFrist number: ") --(1)
if first_number == 'q':
break
second_number = input("\nSecond number: ") --(2)
if second_number == 'q':
break
answer = int(first_number)/int(second_number) --(3)
print(answer)
在(1)处，这个程序提示用户输入一个数字，并将其存储到变量first_number中；如果用户输入的不是退出的'q'，就再提示用户输入一个数字，并将其
存储到变量second_number中；接下来，我们计算这两个数字的商(即answer).这个程序没有采取任何处理错误的措施，因此让它执行除数为0的除法运算时，
它将崩溃：
Give me two numers,and I'll divide them.
Enter 'q' to quit.
First number: 5
Second number: 0
Traceback (most recent call last):
File "/home/zhuzhu/title10/divide.py", line 11, in <module>
print(float(divisor)/float(dividend))
ZeroDivisionError: float 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("\nFrist number: ") --(1)
if first_number == 'q':
break
second_number = input("\nSecond number: ") --(2)
if second_number == 'q':
break
try:
answer = int(first_number)/int(second_number) --(3)
except ZeroDivisionError:
print("You can't divide by zero!")
else:
print(answer)
我们让Python尝试执行try代码块中的除法运算(见1)，这个代码块只包含可能导致错误的代码。依赖于成功执行的代码块都放在else代码块中；在这个
示例中，如果除法运算成功，我们就使用else代码块来打印结果。
except代码块告诉Python，出现ZeroDivisionError异常时该怎么办。如果try代码块因除零错误而失败，我们就打印一条友好的消息，告诉用户如何
避免这种错误。程序将继续运行，用户根本看不到traceback：
Give me two numbers,and I'll divide them.
Enter 'q' to quit.
Frist number: 5
Second number: 0
Yor can't divide by zero!
Frist number: 5
Second number: 2
2.5
Frist 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 "/home/zhuzhu/title10/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 分析文本
我们可以分析包含整本书的文本文件。很多经典文学作品都是以简单的文本文件的方式提供的，因为它们不受版权限制。
下面来提取童话Alice in Wonderland的文本，并尝试计算它包含多少个单词。我们将使用方法split(),它根据一个字符串创建一个单词列表。下面是对
只包含童话名"Alice in Wonderland"的字符串调用方法split()的结果：
>>> title = "Alice in Wonderland"
>>> title.split()
['Alice', 'in', 'Wonderland']
方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，虽然有些单词可
能包含标点。为计算机Alice in Wonderland包含多少个单词，我们将对整篇小说调用split()，在计算得到的列表中包含多少个元素，从而确定整篇童话大
致包含多少个单词：
filename = 'pi_digits'
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() --(1)
num_words = len(words) --(2)
print("The file " + filename + " has about " + str(num_words) + ' words.') --(3)
我们把文件alice.txt移到了正确的目录中，让try代码块能够成功地执行。在(1)处，我们对变量contents(它现在是一个长长的字符串，包含童话Alice
in Wonderland的全部文本）调用方法split()，以生成一个列表，其中包含这部童话中的所有单词。当我们使用len()来确定这个列表的长度时，就知道了
原始字符串大致包含了多少个单词(见(2))。在(3)处，我们打印一条消息，指出文件包含多少个单词。这些代码都放在else代码块中，因为仅当try代码块
成功执行时才执行它们。输出指出了文件alice.txt包含多少个单词：
The file pi_digits has about 11 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:
print("The " + filename + " is not exist.")
else:
words = contents.split()
#把一系列字符串拆分成一个个单词
num_words = len(words)
#统计单词个数
print("The " + filename + " has about " + str(num_words) + " words.")
这些代码大都与原来一样，我们只是将它们移到了函数count_words()中，并增加了缩进量。修改程序的同时更新注释是个不错的习惯，因此我们将注释
改成了文档字符串，并稍微调整了一下措辞。
现在可以编写一个简单的循环，计算要分析的任何文本包含多少个单词了。为此，我们将要分析的文件名称存放在一个列表中，然后对这个列表中的每个
文件都调用count_words()。我们将尝试Alice in Wonderland、Siddharha、Moby Dick和Little Women分别包含了多少个单词。
filenames = ['pi_digits',"gcx",'guest.txt','guest_book.txt']
for filename in filenames:
count_words(filename)
文件gcx不存在，但这丝毫不影响这个程序处理其他文件：
The pi_digits has about 11 words.
The gcx is not exist.
The guest.txt has about 4 words.
The guest_book.txt has about 6 words.
在这个实例中，使用try-except-else代码块提供了两个重要的优点：避免让用户看到traceback；让程序能够继续分析能够找到的其他文件。如果不捕
获因找不到gcx而引发的FileNotFoundError异常，用户将看到完整的traceback，而程序将在尝试分析gcx后停止运行——根本不分析guest.txt和guest_book
10.3.8 失败时一声不吭
在前一个示例中，我们告诉用户有一个文件找不到。但并非每次捕获到异常时都需要告诉用户，有时候我们希望程序在发生异常时一声不吭，就像什么都
没有发生一样继续运行。要让程序在失败时一声不吭，可像通常那样编写try代码块，但在except代码块中明确地告诉Python什么都不要做。Python有一个
pass语句，可在代码块中使用它来让Python什么都不要做：
def count_words(filename):
"""计算一个文件大致包含多少个单词"""
'''判断这个文件存在不存在，以免出现读取错误'''
try:
with open(filename) as f_obj:
'''读取文件，并将文件以字符串形式存放在一个变量中'''
contents = f_obj.read()
except FileNotFoundError:
pass --告诉Python什么都不做，直接跳过，执行下一个
else:
words = contents.split()
#把一系列字符串拆分成一个个单词
num_words = len(words)
#统计单词个数
print("The " + filename + " has about " + str(num_words) + " words.")
filenames = ['pi_digits',"gcx",'guest.txt','guest_book.txt']
for filename in filenames:
count_words(filename)
相比于前一个程序，这个程序唯一不同的地方是(1)处的pass语句。现在，出现FileNotFoundError异常时，将执行except代码块中的代码，但什么都不
会发生。这种错误发生时，不会出现traceback，也没有任何输出。用户将看到存在每个文件包含多少个单词，但没有任何迹象表明有一个文件未找到：
The pi_digits has about 11 words.
The guest.txt has about 4 words.
The guest_book.txt has about 6 words.
pass语句还充当了占位符，它提醒我们在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可能决定将找不到
的文件的名称写入到文件missing_file.txt中。用户看不到这个文件，但我们可以读取这个文件，进而处理所有文件找不到的问题。
def count_words(filename):
"""计算一个文件大致包含多少个单词"""
'''判断这个文件存在不存在，以免出现读取错误'''
try:
with open(filename) as f_obj:
'''读取文件，并将文件以字符串形式存放在一个变量中'''
contents = f_obj.read()
except FileNotFoundEr --在except中加入语句，将找不到的文件存储到一个专门的文件中，用于接下来的分析
with open('missing_files','a') as file_obj:
file_obj.write(filename + '\n')
else:
words = contents.split()
#把一系列字符串拆分成一个个单词
num_words = len(words)
#统计单词个数
print("The " + filename + " has about " + str(num_words) + " words.")
filenames = ['pi_digits',"gcx",'guest.txt','guest_book.txt']
for filename in filenames:
count_words(filename)
分析：在上面程序中，我们在except中加入了语句，我们希望如果这个文件不存在，将这个文件存储起来，以便我们在用户运行之后能够进行分析。这种情况
也是很常见的问题，在我们以后用到的时候会很常见
10.3.9 决定报告哪些错误
在什么情况下该向用户报告错误？在什么情况下又应该一声不吭呢(pass)?如果用户知道要分析哪些文件，它们可能希望在文件没有分析时出现一条消息，
将其中的原因告诉它们。如果用户只想看到结果，而并不知道要分析哪些文件，可能就无需在有些文件不存在时告诉它们。向用户显示他不想看到的信息可能
会降低程序的可用性。Python的错误处理结构让我们能够细致地控制与用户分享错误信息的程度，要分享多少信息由我们决定。
编写的很好且经过详细测试的代码不容易出现内部错误，如语法或逻辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文件、有网络链接，
就有可能出现异常。凭借经验可判断该在程序的什么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信息。
动手试一试
10-6 加法运算：提示用户提供数值输入时，常出现的一个问题是，用户提供的是文本而不是数字。在这种情况下，当我们尝试将输入转换为整数时，
将引发TypeError异常。编写一个程序，提示用户输入两个数字，再将它们相加并打印结果。在用户输入的任何一个值不是数字时都捕获TypeError异常，并
打印一条友好的错误消息。对我们编写的程序进行测试：先输入两个数字，再输入一些文本而不是数字。
10.4 存储数据
很多程序都要求用户输入某种信息，如让用户存储游戏首选项或提供要可视化的数据。不管专注的是什么，程序都把用户提供的信息存储在列表和字典
等数据结构中。用户关闭程序时，我们几乎总是要保存他们提供的信息：一种简单的方式是使用模块json来存储数据。
模块json让我们能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。我们还可以使用json在Python程序之间分
享数据。更重要的是，JSON数据格式并非Python专用的，这让我们能够将以JSON格式存储的数据与使用其他编程语言的人分享。这是一种轻便格式，很有用，
也易于学习。
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' (1)
with open(filename,'w') as f_obj: (2)
json.dump(numbers,f_obj) (3)
我们先导入模块json，再创建一个数字列表。在(1)处，我们指定了要将该数字列表存储到其中的文件的名称。通常使用文件扩展名json来指出文件存储的
数据为JSON格式。接下来，我们以写入模式打开这个文件，让JSON能够将数据写入其中。在(3)处，我们使用函数json.dump()将数字列表存储到文件numbers.
json中。
这个程序没有输出，但我们可以打开文件numbers.json，看看其内容。数据的存储格式与Python中一样：
[2, 3, 5, 7, 11, 13]
下面再编写一个程序,使用json.load()将这个列表读取到内存中：
number_reader.py
import json
filename = 'numbers.json' (1)
with open(filename) as f_obj: (2)
numbers = json.load(f_obj) (3)
print(numbers)
在(1)处，我们确保读取的是前面写入的文件。这次我们以读取方式打开这个文件，因为Python只需读取这个文件(见(2))。在(3)处，我们使用函数json.
load()加载存储在numbers.json中的信息，并将其存储到变量numbers中。最后，我们打印恢复的数字列表，看看它是否与number_write.py中创建的数字列表
相同。
[2, 3, 5, 7, 11, 13]
这是一种在程序之间共享数据的简单方式。
10.4.2 保存和读取用户生成的数据
对于用户生成的数据，使用json保存它们大有裨益，因为如果不以某种方式进行存储，等程序停止运行时用户的信息将丢失。下面来看一个这样的例子：
用户首次运行程序时被提示输入自己的名字，这样再次运行程序时就记住他了。
我们先来存储用户的名字：
remember_me.py
import json
username = input("What is your name? ") (1)
filename = 'username.json'
with open(filename,'w') as f_obj:
json.dump(username,f_obj) (2)
print("We'll remember you when you come back," + username + "!") (3)
在(1)处，我们提示输入用户名，并将其存储在一个变量中。接下来，我们调用json.dump()，并将用户名和一个文件对象传递给它，从而将用户名存储到
文件中。然后，我们打印一条消息，指出我们存储了他输入的信息：
What is your name? soria aoi
We'll remember you when you come back, Soria Aoi!
现在在编写一个程序，向其名字被存储的用户发出问候：
greet_user.py
import json
filename = 'username.json'
with open(filename) as f_obj:
username = json.load(f_obj) (1)
print("welcome back, " + username + "!") (2)
在(1)处，我们使用json.load()将存储在username.json中的信息读取到变量username中。恢复用户名后，我们就可以欢迎用户回来了。
Welcome back, soria aoi!
我们需要将这两个程序合并到一个程序(remember_me.py)中。这个程序运行时，我们尝试从文件username.json中获取用户名，因此我们首先编写一个尝
试恢复用户名的try代码块。如果这个文件不存在，我们就在except代码块中提示用户输入用户名，并将其存储在username.json中，以便程序再次运行时能
够获取它：
remember_me.py
import json
#如果以前存储了用户名，就加载它
#否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
#判断文件是否存在
with open(filename) as f_obj: (1)
username = json.load(f_obj) (2)
except FileNotFoundError: (3)
#文件找不到，创建一个文件，存储用户名
username = input("What is your name? ") (4)
with open(filename,"w") as f_obj: (5)
json.dump(username,f_obj)
print("We'll remember you when you come back, "+ username + "!")
else:
print("Welcome back, " + username +"!")
这里没有任何新代码，只是将前两个示例的代码合并到了一个程序中。在(1)处，我们尝试打开文件username.json。如果这个文件存在，就将其中的用户
名读取到内存中(见（2））,再执行else代码块，即打印一条欢迎用户回来的消息。用户首次运行这个程序时，文件username.json不存在，将引发FileNot
FondError异常(见(3))，因此Python将执行except代码块：提示用户输入其用户名(见(4))，再使用json.dump()存储该用户名，并打印一句问候语。
无论执行的是except代码块还是else代码块，都将显示用户名和合适的问候语。
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,filename)
print("We'll remember your 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:
filename = 'username.json'
username = input("What is your name? ")
with open(filename,'w') as f_obj:
json.dump(username,filename)
print("We'll remember you when you come bace, " + username + "!")
greet_user()
新增的函数get_stored_username()目标明确,(1)处的文档字符串指出了这一点.如果存储了用户名，这个函数就获取并返回它，如果文件username.json
不存在，这个函数就返回None。这是一种不错的做法：函数要么返回预期的值，要么返回None；这让我们能够使用函数的返回值做简单测试。在(3)处，如果成
功地获取了用户名，就打印一条欢迎回来的消息，否则就提示用户输入用户名。
我们还需将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 get_new_username():
'''提示用户输入用户名'''
username = input("What is your name? ")
filename = 'username.json'
with open(filename,'w') as f_obj:
json.dump(username,filename)
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 caome 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 ."
favorite_num.py
import json
filename = 'favorite.json'
with open(filename,'w') as f_obj:
favorite_num = input("Please input your favorite number: ")
json.dump(favorite_num,f_obj)
print("We,'ll remember your favorite number.")
favorite_read.py
import json
filename = 'favorite.json'
with open(filename) as f_obj:
favorite_num = json.load(f_obj)
print("I know your favorite number! It's " + str(favorite_num) + ".")
10-12 记住喜欢的数字：将练习10-11中的两个程序合二为一。如果存储了用户喜欢的数字，就向用户显示它，否则提示用户输入他喜欢的数字并将其
存储到文件中。运行这个程序两次，看是否向预期那样工作。
import json
'''导入模块json'''
def get_stored_favorite_num():
'''查看是否存在用户喜欢的数字'''
try:
filename = 'lucky_number.json'
with open(filename) as f_obj:
favorite_number = json.load(f_obj)
except FileNotFoundError:
return None
else:
return favorite_number
def get_favorite_number():
#如果文件不存在，则让用户重新输入并存储它
favorite_number = input("Please input your favorite number: ")
filename = "lucky_number.json"
with open(filename,'w') as f_obj:
json.dump(favorite_number,f_obj)
return favorite_number
def favorite_num():
#返回用户新欢的数字
favorite_number = get_stored_favorite_num()
if favorite_number:
print("I know your favorite number ! It's " + str(favorite_number) + " .")
else:
favorite_number = get_favorite_number()
print("I'll remember your favorite number: " + str(favorite_number))
favorite_num()
10-13 验证用户：最后一个remember_me.py版本假设用户要么已输入其用户名，要么是首次运行该程序。我们应修改这个程序，以应对这样的情形：
当前和最后一次运行该程序的用户并非同一个人。
为此，在greet_user()中打印欢迎回来的消息前，先询问他用户名是否是对的。如果不对，就调用get_new_username()让用户输入正确的用户名。
import json
def get_stored_username():
'''如果存储了用户名，就获取它'''
try:
filename = 'username.json'
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
return None
else:
while True:
#判断用户名是否相同，这里要求用户输入相同的名字我们才欢迎他，不然会一直让用户输入
yourname = input("Enter your username: ")
if username == yourname:
return username
break
else:
print("\nThe user name you entered is incorrect, please re-enter.")
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()
