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

  1.   import json
  3.   numbers = [2, 3, 5, 7, 11, 13]
  5. ❶ filename = 'numbers.json'
  6. ❷ with open(filename, 'w') as f_obj:
  7. ❸     json.dump(numbers, f_obj)
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  

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

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

  1. [2, 3, 5, 7, 11, 13]
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  

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

number_reader.py

  1.   import json
  3. ❶ filename = 'numbers.json'
  4. ❷ with open(filename) as f_obj:
  5. ❸     numbers = json.load(f_obj)
  7.   print(numbers)
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  

在❶处，我们确保读取的是前面写入的文件。这次我们以读取方式打开这个文件，因为Python只需读取这个文件（见❷）。在❸处，我们使用函数json.load() 加载存储在numbers.json中的信息，并将其存储到变量numbers 中。最后，我们打印恢复的数字列表，看看它是否与number_writer.py中创建的数字列表相同：

  1. [2, 3, 5, 7, 11, 13]
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  

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

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

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

我们先来存储用户的名字：

remember_me.py

  1.   import json
  3. ❶ username = input("What is your name? ")
  5.   filename = 'username.json'
  6.   with open(filename, 'w') as f_obj:
  7. ❷     json.dump(username, f_obj)
  8. ❸     print("We'll remember you when you come back, " + username + "!")
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  

在❶处，我们提示输入用户名，并将其存储在一个变量中。接下来，我们调用json.dump() ，并将用户名和一个文件对象传递给它，从而将用户名存储到文件中（见❷）。然后，我们打印一条消息，指出我们存储了他输入的信息（见❸）：

  1. What is your name? Eric
  2. We'll remember you when you come back, Eric!
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  

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

greet_user.py

  1.   import json
  3.   filename = 'username.json'
  5.   with open(filename) as f_obj:
  6. ❶     username = json.load(f_obj)
  7. ❷     print("Welcome back, " + username + "!")
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  

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

  1. Welcome back, Eric!
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  

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

remember_me.py

  1.   import json
  3.   # 如果以前存储了用户名，就加载它
  4.   #  否则，就提示用户输入用户名并存储它
  5.   filename = 'username.json'
  6.   try:
  7. ❶     with open(filename) as f_obj:
  8. ❷         username = json.load(f_obj)
  9. ❸ except FileNotFoundError:
  10. ❹     username = input("What is your name? ")
  11. ❺     with open(filename, 'w') as f_obj:
  12.           json.dump(username, f_obj)
  13.           print("We'll remember you when you come back, " + username + "!")
  14.   else:
  15.       print("Welcome back, " + username + "!")
  17.  
  18.  
  19.  
  20.  
  21.  
  22.  
  23.  

这里没有任何新代码，只是将前两个示例的代码合并到了一个程序中。在❶处，我们尝试打开文件username.json。如果这个文件存在，就将其中的用户名读取到内存中（见❷），再执行else 代码块，即打印一条欢迎用户回来的消息。用户首次运行这个程序时，文件username.json不存在，将引发FileNotFoundError 异常（见❸），因此Python将执行except 代码块：提示用户输入其用户名（见❹），再使用json.dump() 存储该用户名，并打印一句问候语（见❺）。

无论执行的是except 代码块还是else 代码块，都将显示用户名和合适的问候语。如果这个程序是首次运行，输出将如下：

  1. What is your name? Eric
  2. We'll remember you when you come back, Eric!
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  

否则，输出将如下：

  1. Welcome back, Eric!
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  

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

10.4.3　重构

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

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

remember_me.py

  1.   import json
  3.   def greet_user():
  4. ❶     """问候用户，并指出其名字"""
  5.       filename = 'username.json'
  6.       try:
  7.           with open(filename) as f_obj:
  8.               username = json.load(f_obj)
  9.       except FileNotFoundError:
  10.           username = input("What is your name? ")
  11.           with open(filename, 'w') as f_obj:
  12.               json.dump(username, f_obj)
  13.               print("We'll remember you when you come back, " + username + "!")
  14.       else:
  15.           print("Welcome back, " + username + "!")
  17.   greet_user()
  19.  
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  

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

下面来重构greet_user() ，让它不执行这么多任务。为此，我们首先将获取存储的用户名的代码移到另一个函数中：

  1.   import json
  3.   def get_stored_username():
  4. ❶     """如果存储了用户名，就获取它"""
  5.       filename = 'username.json'
  6.       try:
  7.           with open(filename) as f_obj:
  8.               username = json.load(f_obj)
  9.       except FileNotFoundError:
  10. ❷         return None
  11.       else:
  12.           return username
  14.   def greet_user():
  15.       """问候用户，并指出其名字"""
  16.       username = get_stored_username()
  17. ❸     if username:
  18.           print("Welcome back, " + username + "!")
  19.       else:
  20.           username = input("What is your name? ")
  21.           filename = 'username.json'
  22.           with open(filename, 'w') as f_obj:
  23.               json.dump(username, f_obj)
  24.               print("We'll remember you when you come back, " + username + "!")
  26.   greet_user()
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  

新增的函数get_stored_username() 目标明确，❶处的文档字符串指出了这一点。如果存储了用户名，这个函数就获取并返回它；如果文件username.json不存在，这个函数就返回None （见❷）。这是一种不错的做法：函数要么返回预期的值，要么返回None ；这让我们能够使用函数的返回值做简单测试。在❸处，如果成功地获取了用户名，就打印一条欢迎用户回来的消息，否则就提示用户输入用户名。

我们还需将greet_user() 中的另一个代码块提取出来：将没有存储用户名时提示用户输入的代码放在一个独立的函数中：

  1. import json
  3. def get_stored_username():
  4.     """如果存储了用户名，就获取它"""
  5.     --snip--
  7. def get_new_username():
  8.     """提示用户输入用户名"""
  9.     username = input("What is your name? ")
  10.     filename = 'username.json'
  11.     with open(filename, 'w') as f_obj:
  12.         json.dump(username, f_obj)
  13.     return username
  15. def greet_user():
  16.     """问候用户，并指出其名字"""
  17.     username = get_stored_username()
  18.     if username:
  19.         print("Welcome back, " + username + "!")
  20.     else:
  21.         username = get_new_username()
  22.         print("We'll remember you when you come back, " + username + "!")
  24. greet_user()
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  

在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() 让用户输入正确的用户名。