Python文件和异常（二）

三、异常

       Python 使用称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让 Python 不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行；如果未对异常进行处理，程序将停止并显示 traceback ，其中包含有关异常的报告。

       异常是使用 try-except 代码块处理的。try-except 代码块让 Python 执行指定的操作，同时告诉 Python 发生异常时怎么办。使用 try-except 代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的 traceback 。

（一）处理 ZeroDivisionError 异常

       下面来看一种导致 Python 引发异常的简单错误。你可能知道，不能用数除以0，但还是让 Python 这样做：

print(5/0)

        显然，Python 无法这样做，因此你将看到一个 traceback：

       在上述 traceback 中，指出的错误 ZeroDivisionError 是个异常对象。Python 无法按你的要求做时，就会创建这种对象。在这种情况下，Python 将停止运行程序，并指出引发了哪种异常，而我们可根据这些信息对程序进行修改。下面来告诉 Python ，发生这种错误时怎么办。这样，如果再次发生此类错误，我们就有备无患了。

（二）使用 try-except 代码块

       当你认为可能会发生错误时，可编写一个 try-except 代码块来处理可能引发的异常。你让 Python 尝试运行一些代码，并告诉它如果这些代码引发了指定的异常该怎么办。

 处理 ZeroDivisionError 异常的 try-except 代码块类似于下面这样：

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by 0!")

       将导致错误的代码行 print(5/0) 放在一个 try 代码块中。如果 try 代码块中的代码运行起来没有问题，Python 将跳过 except 代码块；如果 try 代码块中的代码导致了错误，Python 将查找与之匹配的 except 代码块并运行其中的代码。

       在本例中，try 代码块中的代码引发了 ZeroDivisionError 异常，因此 Python 查找指出了该怎么办的 except 代码块，并运行其中的代码。这样，用户看到的是一条友好的错误消息，而不是traceback ：

You can't divide by 0!

       如果 try-except 代码块后面还有其他代码，程序将接着运行，因为已经告诉了 Python 如何处理这种错误。下面来看一个捕获错误后程序继续运行的示例。

（三）使用异常避免崩溃

       发生错误时，如果程序还有工作尚未完成，妥善地处理错误就尤其重要。这种情况经常会出现在要求用户提供输入的程序中；如果程序能够妥善地处理无效输人，就能再提示用户提供有效输人，而不至于崩溃。

     下面来创建一个只执行除法运算的简单计算器：

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 。接下来，计算这两个数的商。该程序没有采取任何处理错误的措施，因此在执行除数为0的除法运算时，它将崩溃：

       程序崩溃可不好，但让用户看到 traceback 也不是个好主意。不懂技术的用户会被搞糊涂，怀有恶意的用户还会通过 traceback 获悉你不想他知道的信息。例如，他将知道你的程序文件的称，还将看到部分不能正确运行的代码。有时候，训练有素的攻击者可根据这些信息判断出可对你的代码发起什么样的攻击。

（四）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: ")
    if second_number == 'q':
        break
    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 ：

       try-except-else 代码块的工作原理大致如下。Python 尝试执行 try 代码块中的代码，只有可能引发异常的代码才需要放在 try 语句中。有时候，有一些仅在 try 代码块成功执行时才需要运行的代码、这些代码应放在 else 代码块中。except 代码块告诉 Python ，如果尝试运行 try 代码块中的代码时引发了指定的异常该怎么办。

       通过预测可能发生错误的代码，可编写健壮的程序。它们即便面临无效数据或缺少资源，也能继续运行，从而抵御无意的用户错误和恶意的攻击。

（五）处理 FileNotFoundError 异常

       使用文件时，一种常见的问题是找不到文件：查找的文件可能

       使用文件时，一种常见的问题是找不到文件：查找的文件可能在其他地方，文件名可能不正确，或者这个文件根本就不存在。对于所有这些情形，都可使用 try-except 代码块以直观的方式处理。

       我们来尝试读取一个不存在的文件。下面的程序尝试读取文件 alice.txt 的内容，但该文件没有存储在 alice.py 所在的目录中：

filename = 'alice.txt'
with open(filename, encoding='utf-8') as f:
    contents = f.read()

       相比于本章前面的文件打开方式，这里有两个不同之处。一是使用变量f来表示文件对象，这是一种常见的做法。二是给参数 encoding 指定了值，在系统的默认编码与要读取文件使用的编码不一致时，必须这样做。

       Python 无法读取不存在的文件，因此它引发一个异常：

    上述 traceback 的最后一行报告了 FileNotFoundExror 异常，这是 Python 找不到要打开的文件时创建的异常。在本例中，这个错误是函数 open() 导致的。因此，要处理这个错误，必须将 try 语句放在包含 open() 的代码行之前：

filename = 'alice.txt'
 
try:
    with open(filename, encoding='utf-8') as f:
        contents = f.read()
except FileNotFoundError:
    print(f"Sorry, the file {filename} does not exist.")

      在本例中，try 代码块引发了 FileNotFoundError 异常，因此 Python 找到与该错误匹配的 except 代码块，并运行其中的代码。最终的结果是显示一条友好的错误消息，而不是 traccback：

Sorry, the file alice.txt does not exist.

       如果文件不存在，这个程序就什么都做不了，错误处理代码也意义不大。下面来扩展这个示例，看看在你使用多个文件时，异常处理可提供什么样的帮助。

（六）分析文本

       你可以分析包含整本书的文本文件。很多经典文学作品都是简单以文本文件的形式提供的，因为它们不受版权限制。

       下面来提取童话《爱丽丝漫游奇境记》(Alice in Wonderland) 的文本，并尝试计算它包含多少个单词。我们将使用方法 split() ，它能根据一个字符串创建一个单词列表。下面是对只包含童话名 "Alice in Wonderland" 的字符串调用方法 split() 的结果：

>>> title = "Alice in Wonderland" 
>>> title.split()
['Alice', 'in', 'Wonderland']

       方法 split() 以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。为计算《爱丽丝漫游奇境记》包含多少个单词，我们将对整篇小说调用 split() ，再计算得到的列表包含多少个元素，从而确定整篇童话大致包含多少个单词：

filename = 'alice.txt'
 
try:
    with open(filename, encoding='utf-8') as f:
        contents = f.read()
except FileNotFoundError:
    print(f"Sorry, the file {filename} does not exist.")
else:
    # 计算该文件大致包含多少个单词。
    words = contents.split()
    num_words = len(words)
    print(f"The file {filename} has about {num_words} words.")

       我们将文件 alice.txt 移到了正确的目录中，让 try 代码块能够成功执行。对变量 contents（它现在是一个长长的字符串，包含童话《爱丽丝漫游奇境记》的全部文本）调用方法 split() ，以生成一个列表，其中包含这部童话中的所有单词。使用 len() 来确定这个列表的长度时，就能知道原始字符串大致包含多少个单词了。打印一条消息，指出文件包含多少个单词。这些代码都放在 else 代码块中，因为仅当 try 代码块成功执行时才执行它们。输出指出了文件 alice.txt 包含多少个单词：

The file alice.txt has about 29465 words.

       这个数稍大一点，因为使用的文本文件包含出版商提供的额外信息，但还是成功估算出了童话《爱丽丝漫游奇境记》的篇幅。

（七）使用多个文件

       下面多分析几本书。这此之前，先将这个程序的大部分代码移到一个名为 count_words() 的函数中。这样，对多本书进行分析时将更容易：

def count_words(filename):
    """计算一个文件大致包含多少个单词。"""
    try:
        with open(filename, encoding='utf-8') as f:
            contents = f.read()
    except FileNotFoundError:
        print(f"Sorry, the file {filename} does not exist.")
    else:
        words = contents.split()
        num_words = len(words)
        print(f"The file {filename} has about {num_words} words.")
 
filenames = 'alice.txt'
count_words(filename)

       这些代码大多与原来一样，只是移到了函数 count_words() 中，并增加了缩进量。修改程序的同时更新注释是个不错的习惯，因此我们将注释改成文档字符串，并稍微调整了一下措辞。

       现在可以编写一个简单的循环，计算要分析的任何文本包含多少个单词了。为此，将要分析的文件的名称存储在一个列表中，然后对列表中的每个文件调用 count_words() 。我们将尝试计算《爱丽丝漫游奇境记》《悉达多》(Siddhartha) 、《白鲸》(Moby Dick) 和《小妇人》(Litle Women) 分别包含多少个单词，它们都不受版权限制。我故意没有将 siddhartha.txt 放到word_count.py 所在的目录中，从而展示该程序在文件不存在时应对得有多出色：

def count_words(filename):
    """计算一个文件大致包含多少个单词。"""
    try:
        with open(filename, encoding='utf-8') as f:
            contents = f.read()
    except FileNotFoundError:
        print(f"Sorry, the file {filename} does not exist.")
    else:
        words = contents.split()
        num_words = len(words)
        print(f"The file {filename} has about {num_words} words.")
 
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 29465 words.
Sorry, the file siddhartha.txt does not exist.
The file moby_dick.txt has about 215830 words.
The file little_women.txt has about 189079 words.

       在本例中，使用 try-except 代码块提供了两个重要的优点：避免用户看到 traceback ，以及让程序继续分析能够找到的其他文件。如果不捕获因找不到 siddhartha.txt 而引发的 FileNotFoundError 异常，用户将看到完整的 traceback ，而程序将在尝试分析《悉达多》后停止运行。它根本不会分析《白鲸》和《小妇人》。

（八）静默失败

       在前一个示例中，我们告诉用户有一个文件找不到。但并非每次捕获到异常都需要告诉用户，有时候你希望程序在发生异常时保持静默，就像什么都没有发生一样继续运行。要让程序静默失败，可像通常那样编写 try 代码块，但在 except 代码块中明确地告诉 Python 什么都不要做。 Python 有一个 pass 语句，可用于让 Python 在代码块中什么都不要做：

def count_words(filename):
    """Count the approximate number of words in a file."""
    try:
        with open(filename, encoding='utf-8') as f:
            contents = f.read()
    except FileNotFoundError:
        pass
    else:
        words = contents.split()
        num_words = len(words)
        print(f"The file {filename} has about {num_words} words.")
 
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 29465 words.
The file moby_dick.txt has about 215830 words.
The file little_women.txt has about 189079 words.

       pass 语句还充当了占位符，提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可能决定将找不到的文件的名称写人文件 missing_files.txt 中。用户看不到这个文件，但我们可以读取它，进而处理所有找不到文件的问题。

四、存储数据

       很多程序都要求用户输入某种信息，如让用户存储游戏首选项或提供要可视化的数据。不管关注点是什么，程序都把用户提供的信息存储在列表和字典等数据结构中。用户关闭程序时，几乎总是要保存他们提供的信息。一种简单的方式是使用模块 json 来存储数据。

       模块 json 让你能够将简单的 Python 数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用 json 在 Python 程序之间分享数据。更重要的是，JSON 数据格式并非 Python 专用的，这让你能够将以 JSON 格式存储的数据与使用其他编程语言的人分享。这是一种轻便而有用的格式，也易于学习。

注意：JSON（JavaScript Object Notation）格式最初是为 JavaScript 开发的，但随后成了一种常见格式，被包括 Python 在内的众多语言采用。

（一）使用 json.dump() 和 json.load()

       我们来编写一个存储一组数的简短程序，再编写一个将这些数读取到内存中的程序。第一个程序将使用 json.dump() 来存储这组数，而第二个程序将使用 json.load() 。

       函数 json.dump() 接受两个实参：要存储的数据，以及可用于存储数据的文件对象。下面演示了如何使用 json.dump() 来存储数字列表：

import json
 
numbers = [2, 3, 5, 7, 11, 13]
 
filename = 'numbers.json'
with open(filename, 'w') as f:
    json.dump(numbers, f)

      先导入模块 json ，再创建一个数字列表。指定了要将该数字列表存储到哪个文件中。通常使用文件扩展名 json 来指出文件存储的数据为 JSON 格式。接下来，以写入模式打开这个文件、让 json 能够将数据写人其中。在处，使用函数 json.dump() 将数字列表存储到文件 numbers.json 中。

       这个程序没有输出，但可以打开文件 numbers.json 来看看内容。数据的存储格式与 Python 中一样：

[2, 3, 5, 7, 11, 13]

       下面再编写一个程序，使用 json.load() 将列表读取到内存中：

import json
 
filename = 'numbers.json'
with open(filename) as f:
    numbers = json.load(f)
    
print(numbers)

       确保读取的是前面写人的文件。这次以读取方式打开该文件，因为 Python 只需要读取它。使用函数 json.load() 加载存储在 numbers.json 中的信息，并将其赋给变量 numbers 。最后，打印恢复的数字列表，看看是否与 number_writer.py 中创建的数字列表相同：

[2, 3, 5, 7, 11, 13]

       这是一种在程序之间共享数据的简单方式。

（二）保存和读取用户生成的数据

       使用 json 保存用户生成的数据大有裨益，因为如果不以某种方式存储，用户的信息会在程序停止运行时丢失。下面来看一个这样的例子：提示用户首次运行程序时输人自己的名字，并在再次运行程序时记住他。

       先来存储用户的名字：

import json
 
username = input("What is your name? ")
 
filename = 'username.json'
with open(filename, 'w') as f:
    json.dump(username, f)
    print(f"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!

    现在再编写一个程序，向已存储了名字的用户发出问候：

import json
 
filename = 'username.json'
 
with open(filename) as f:
    username = json.load(f)
    print(f"Welcome back, {username}!")

       使用 json.load() 将存储在 usermame.json 中的信息读取到变量 username 中。恢复用户名后，就可以欢迎用户回来了：

Welcome back, Eric!

       需要将这两个程序合并到一个程序（remember_me.py）中。这个程序运行时，将尝试从文件 usermame.json 中获取用户名。因此，首先编写一个尝试恢复用户名的 try 代码块。如果这个文件不存在，就在 except 代码块中提示用户输入用户名，并将其存储到 username.json 中，以便程序再次运行时能够获取：

import json
 
#如果以前存储了用户名，就加载它。
#否则，提示用户输入用户名并存储它。
filename = 'username.json'
try:
    with open(filename) as f:
        username = json.load(f)
except FileNotFoundError:
    username = input("What is your name? ")
    with open(filename, 'w') as f:
        json.dump(username, f)
        print(f"We'll remember you when you come back, {username}!")
else:
    print(f"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!

       这是程序之前至少运行了一次时的输出。

（三）重构

       你经常会遇到这样的情况：代码能够正确地运行，但通过将其划分为一系列完成具体工作的函数，还可以改进。这样的过程称为重构。重构让代码更清晰、更易于理解、更容易扩展。

       要重构 remember_me.py ，可将其大部分逻辑放到一个或多个函数中。 remember_me.py 的重点是问候用户，因此将其所有代码都放到一个名为 greet_user() 的函数中：

import json
 
def greet_user():
    """问候用户，并指出其名字。"""
    filename = 'username.json'
    try:
        with open(filename) as f:
            username = json.load(f)
    except FileNotFoundError:
        username = input("What is your name? ")
        with open(filename, 'w') as f:
            json.dump(username, f)
            print(f"We'll remember you when you come back, {username}!")
    else:
        print(f"Welcome back, {username}!")
 
greet_user()

       考虑到现在使用了一个函数，我们删除原注释，转而使用一个文档字符串来指出程序的作用。这个程序更加清晰，但函数 greet_user() 所做的不仅仅是问候用户，还在存储了用户名时获取它、在没有存储用户名时提示用户输人。

       下面来重构 greet_user() ，减少其任务。为此，首先将获取已存储用户名的代码移到另一个函数中：

import json
 
def get_stored_username():
    """如果存储了用户名、就获取它。"""
    filename = 'username.json'
    try:
        with open(filename) as f:
            username = json.load(f)
    except FileNotFoundError:
        return None
    else:
        return username
 
def greet_user():
    """问候用户，并指出其名字。"""
    username = get_stored_username()
    if username:
        print(f"Welcome back, {username}!")
    else:
        username = get_new_username()
        with open(filename, 'w') as f:
            json.dump(username, f)
            print(f"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():
    """如果存储了用户名、就获取它。"""
    filename = 'username.json'
    try:
        with open(filename) as f:
            username = json.load(f)
    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:
        json.dump(username, f)
    return username
 
def greet_user():
    """问候用户，并指出其名字。"""
    username = get_stored_username()
    if username:
        print(f"Welcome back, {username}!")
    else:
        username = get_new_username()
        print(f"We'll remember you when you come back, {username}!")
 
greet_user()

       在 remember_me.py 的这个最终版本中，每个函数都执行单一而清晰的任务。我们调用 greet_user() ，它打印一条合适的消息：要么欢迎老用户回来，要么问候新用户。为此，它首先调用 get_stored_username() ，该函数只负责获取已存储的用户名（如果存储了的话）。最后在必要时调用 get_new_username() ，该函数只负责获取并存储新用户的用户名。要编写出清晰而易于维护和扩展的代码，这种划分必不可少。

附：上述文章可能用到的数据文件：

链接：https://pan.quark.cn/s/0c4a1f5cbcc3

提取码：q7eK