《Python从入门到实践》第十章：文件和异常

文件和异常

在本章中，将会学习处理文件，让程序能够快速地分析大量的数据；将学习错误处理，避免程序在面对意外情形时崩溃；将学习异常，它们是python创建的特殊对象，用于管理程序运行时出现的错误；还将学习模块json，它能够保存用户数据，以免在程序停止运行后丢失。

一、从文件中读取数据

要使用文本文件中的信息，首先需要将信息读取到内存中。为此，可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取。

读取整个文件

要读取文件，需要一个包含几行文本的文件。
下面首先来创建一个文件，它包含精确到小数点后30位的圆周率值，且在小数点后每10位处都换行：
pi_digits.txt

3.1415926535 
  8979323846 
  2643383279

file_reader.py

with open("pi_digits.txt") as file_object:
    contents = file_object.read()
    print(contents)
#这里的文件路径为绝对路径和相对路径都可以

输出：

3.1415926535 
  8979323846 
  2643383279

open()接受一个参数：要打开的文件的名称。
关键字with在不再需要访问文件后将其关闭。
打开文件时open()，三个模式：读取模式’r’ 写入模式’w’ 附加模式’a’，附加模式处理文件不会删除覆盖原有内容，而是再文件末尾添加你写入文件的行。

文件路径

当将类似pi_digits.txt这样的简单文件名传递给函数open()时，Python将在当前执行的文件（即.py程序文件）所在的目录中查找文件。

with open("pi_digits.txt") as file_object:

根据组织文件的方式，有时候可能要打开不在程序文件所属目录中的文件。例如，你可能将程序文件存储在了文件夹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:

在Windows系统中，在文件路径中使用反斜杠（\）而不是斜杠（/）：

with open('text_files\filename.txt') as file_object:

即为这种存储方式：

文件路径为相对文件路径：

with open("day9：文件和异常/pi_digits.txt") as file_object:
    contents = file_object.read()
    print(contents)

还可以将文件在计算机中的准确位置告诉Python，这样就不用关心当前运行的程序存储在什么地方了。这称为绝对文件路径。在相对路径行不通时，就可使用绝对路径。
绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该变量传递给open()会有所帮助。

file_path = '/Users/apple/Desktop/python/python编程：从入门到实践/day9：文件和异常/pi_digits.txt'
with open(file_path) as file_object:
    contents = file_object.read()
    print(contents)

逐行读取

读取文件时，常常需要检查其中的每一行：可能要在文件中查找特定的信息，或者要以某种方式修改文件中的文本。
要以每次一行的方式检查文本，可对文件对象使用for循环：
file_reader.py

filename = 'day9：文件和异常/pi_digits.txt'
with open(filename) as file_object:
    for line in file_object:
        print(line)

输出：

3.1415926535 

  8979323846 

  2643383279

因为在这个文件中，每行的末尾都有一个看不见的换行符，而print语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自print语句。要消除这些多余的空白行，可在print语句中使用rstrip()：

filename = 'day9：文件和异常/pi_digits.txt'
with open(filename) as file_object:
    for line in file_object:
        print(line.rstrip())

输出：

3.1415926535
  8979323846
  2643383279

创建一个包含文件各行内容的列表

使用关键字with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容，可在with代码块内将文件的各行存储在一个列表中，并在with代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。
下面的示例在with代码块中将文件pi_digits.txt的各行存储在一个列表中，再在with代码块外打印它们：

filename = 'day9：文件和异常/pi_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()
for line in lines:
    print(line.rstrip())

输出：

3.1415926535
  8979323846
  2643383279

使用文件的内容

将文件读取到内存中后，就可以以任何方式使用这些数据了。
下面以简单的方式使用圆周率的值。

filename = 'day9：文件和异常/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))

输出：

3.1415926535  8979323846  2643383279
36

在变量pi_srting存储的字符串中，包含原来位于每行左边的空格，为删除这些空格，可使用strip()而不是rstrip()：

filename = 'day9：文件和异常/pi_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))

输出：

3.141592653589793238462643383279
32

包含一百万位的大型文件

（由于百万数据太多了，所以只找到了前500位）

filename = 'pi_500_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))

输出：

3.14159265358979323846264338327950288419716939937510...
502

圆周率值中包含你的生日吗

同样地，我们选择了圆周率小数点后前500位：

filename = 'pi_500_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()
birthday = input('Please input you birth day:')
pi_string = ''
for line in lines:
    pi_string += line.strip()
if birthday in pi_string:
    print("Your birthday appears in the first 500 digits of pi!")
else:
    print("Your birthday does not appear in the first 500 digits of pi!")

输出：

Please input you birth day:051185
Your birthday appears in the first 500 digits of pi!

Please input you birth day:061973
Your birthday does not appear in the first 500 digits of pi!

二、写入文件

保存数据的最简单的方式之一是将其写入到文件中。通过将输出写入文件，即便关闭包含程序输出的终端窗口，这些输出也依然存在：你可以在程序结束运行后查看这些输出，可与别人分享输出文件，还可编写程序来将这些输出读取到内存中并进行处理。

写入空文件

要将文本写入文件，在调用open()时需要提供另一个实参，告诉Python要写入打开的文件。为明白其中的工作原理，我们来将一条简单的消息存储到文件中，而不是将其打印到屏幕上：
message_message.txt

filename = 'programming.txt'
with open(filename,'w') as file_object:
    file_object.write('I love programming!')

打开文件programming.txt：

I love programming.

注意：
1、在这个实例中，调用open()时提供了两个实参。第一个实参也是要打开的文件的名称；第二个实参（ ’ w ’ ）告诉Python，我们要以写入模式打开这个文件。
2、打开文件时，可指定读取模式（ ’ r ’ ）、写入模式（ ’ w ’ ）、附加模式（ ’ a ’ ）或让你能够读取和写入的模式（ ’ r+ ’ ）。如果你省略了模式实参，Python将以默认的只读模式打开文件。
3、如果要写入的文件不存在，函数open()将自动创建它。以写入（‘w’）模式打开文件时，如果指定的文件已经存在，Python将在返回文件对象前清空该文件。
4、Python只能将字符串写入文本文件。要将数值数据存储在文本文件中，必须先使用函数str()将其转换为字符串格式。

写入多行

filename = 'day9：文件和异常/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()不会在写入的文本末尾添加换行符，所以两行内容挤在一起
如果要让每个字符串都单独占一行，需要在write()语句中包含换行符：

filename = 'day9：文件和异常/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")

打开文件programming.txt：

I love programming!
I love creating new games.

附加到文件

如果要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。当以附加模式打开文件时，Python不会在返回文件对象前清空文件，而写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将会创建一个空文件。

filename = 'day9：文件和异常/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")

打开文件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.

三、异常

Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果编写了处理该异常的代码，程序将继续执行；如果未对异常进行处理。程序将停止，并显示一个traceback，其中包含有关异常的报告。
异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即使出现异常，程序也将继续运行；显示编写的友好的错误消息，而不是令用户迷惑的traceback。

处理ZeroDivisionError异常

举例一个导致Python引发异常的简单错误：

print(5/0)

运行后看到一个traceback：

Traceback (most recent call last):
  File "division.py", line 1, in <module>
    print(5/0) 
ZeroDivisionError: division by zero

使用try-except代码块

当认为可能发生了错误时，可编写一个try-except代码块来处理可能引发的异常。
处理ZeroDivisionError异常的try-except代码块类似于下面这样：

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

输出：

You can't divide by zero!

如果try代码块中的代码运行起来没有问题，Python将跳过except代码块；如果try代码块中的代码导致了错误，Python将查找这样的except代码块，并运行其中的代码，即其中指定的错误与引发的错误相同。
如果try-except代码块后面还有其他代码，程序将接着运行，因为已经告诉了Python如何处理这种错误。

使用异常避免崩溃

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

print("Please give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
    first_number = input("First number:")
    if first_number == 'q':
        print("Program quit.")
        break
    second_number = input("Second number:")
    if second_number == 'q':
        print("Program quit.")
        break
    answer = int(first_number)/int(second_number)
    print(str(answer) + "\n" )

运行后：

Please 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

这个程序没有采取任何处理错误的措施，因此让它执行除数为0的除法运算时，它将崩溃。

else代码块

通过将可能引发错误的代码放在try-except代码块中，可提高这个程序抵御错误的能力。错误是执行除法运算的代码行导致的，因此我们需要将它放到try-except代码块中。
这个实例还包含一个else代码块；依赖于try代码块成功执行的代码都应放到else代码块中：

print("Please give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
    first_number = input("First number:")
    if first_number == 'q':
        print("Program quit.")
        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(str(answer) + "\n")

运行后：

Please give me two numbers, and I'll divide them.
Enter 'q' to quit.
First number:1
Second number:0
You can't divide by 0!
First number:1
Second number:1
1.0

First number:q
Program quit.

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

处理FileNotFoundError异常

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

分析文本

方法spilt()：
以空格为分隔符将字符串分拆成多个部分，并将这个部分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。

title = "Alice in wonderland"
print(title.split())

输出：

['Alice', 'in', 'wonderland']

统计“ Alice in wonderland ”这篇童话包含多少个单词：

filename = "alice.txt"
try:
    with open(filename) as file_object:
        contents = file_object.read()
except FileNotFoundError:
    print("Sorry, the file " + filename + " doesn't exist.")
else:
    count = contents.split()
    print("The file " + filename + " has about " + str(len(count)) + " words.")

输出：

The file alice.txt has about 29465 words.

使用多个文件

将代码移到一个名为count_words()的函数中，这样对多本书进行分析时更容易：

def count_words(filename):
    try:
        with open(filename) as file_object:
            contents = file_object.read()
    except FileNotFoundError:
        print("Sorry, the file " + filename + " doesn't exist.")
    else:
        count = contents.split()
        print("The file " + filename + " has about " + str(len(count)) + " words.")

filename = "alice.txt"
count_words(filename)
filename = "siddhartha.txt" #这本书不存在
count_words(filename)
filename = "Moby Dick.txt"
count_words(filename)
filename = "Little Women.txt"
count_words(filename)

或者：

def count_words(filename):
    --snip--
filenames = ['alice.txt', 'siddhartha.txt', 'Moby Dick.txt', 'Little Women.txt']
for filename in filenames:
    count_words(filename)

输出：

The file alice.txt has about 29465 words.
Sorry, the file siddhartha.txt doesn't exist.
The file Moby Dick.txt has about 56556 words.
The file Little Women.txt has about 105039 words.

失败时一声不吭

在前一个实例中，我们告诉用户有一个文件找不到。但并非每次捕获到异常时都需要告诉用户。要让程序在发生异常时一声不吭，可像通常那样编写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)

输出：

The file alice.txt has about 29465 words.
The file Moby Dick.txt has about 56556 words.
The file Little Women.txt has about 105039 words.

决定报告哪些错误

在什么情况下该向用户报告错误?在什么情况下又应该在失败时一声不吭呢?如果用户知道要分析哪些文件，他们可能希望在有文件没有分析时出现一条消息，将其中的原因告诉他们。 如果用户只想看到结果，而并不知道要分析哪些文件，可能就无需在有些文件不存在时告知他们。 向用户显示他不想看到的信息可能会降低程序的可用性。Python的错误处理结构让你能够细致地控制与用户分享错误信息的程度，要分享多少信息由你决定。
编写得很好且经过详尽测试的代码不容易出现内部错误，如语法或逻辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文件、有网络链接，就有可能出现异常。凭借经验可判断该在程序的什么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信息。

四、存储数据

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

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

模块json让你能够将简单的Python数据转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json在Python程序之间分享数据。

使用json.dump()和json.load()

我们来编写一个存储一组数字的简短程序，再编写一个将这些数字读取到内存中的程序。第一个程序将使用json.dump()来存储这组数字，而第二个程序将使用json.load()。
函数json.load()接受两个实参：要存储的数据以及可用于存储数据的文件对象。下面演示了如何使用json.dump()来存储数字列表：

import json

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

打开文件numbers.json：

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

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

import json

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

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

对于用户生成的数据，使用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 + "!")

输出：

What is your name? awesome
We'll remember you when you come back, awesome!

再编写一个程序，向其名字被存储的用户发出问候：
greet_user.py

import json

filename = 'username.json'
with open(filename) as f_obj:
    username = json.load(f_obj)
    print("Welcome back, " + username + "!")

输出：

Welcome back, awesome!

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

import json

filename = 'day9：文件和异常/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 + "!")

如果这个程序是首次运行，输出将如下：

What is your name? awesome
We'll remember you when you come back, awesome!

否则，输出将如下：

Welcome back, awesome!

重构

代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构。重构让代码更清晰、更易于理解、更容易扩展。

首先将获取存储的用户名的代码移到另一个函数中：

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():
    """如果存储了用户名，就获取它"""
    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, 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()

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