python3教程：json、pickle和sqlite3持久化存储字典对象

在各种python的项目中，我们时常要持久化的在系统中存储各式各样的python的数据结构，常用的比如字典等。尤其是在云服务类型中的python项目中，要持久化或者临时的在缓存中储存一些用户认证信息和日志信息等，最典型的比如在数据库中存储用户的token信息。在本文中我们将针对三种类型的python持久化存储方案进行介绍，分别是json、pickle和python自带的数据库sqlite3。
使用json存储字典对象

json格式的数据存储也是云服务项目中常用的类型，具备十分轻量级和易使用的特性，这里我们展示一个案例：如何使用json格式存储一个用python产生的斐波那契数列。斐波那契数列中的每一个元素，都等于前一个数和前前一个数的和，即：
，而最常见的斐波那契数列的前两位数都是1。如下是一个产生斐波那契数列的python代码：

1. import json
2. number = {1:1, 2:1}
3. for i in range(3, 11):
4.     number[i] = number[i - 1] + number[i - 2]
5. print (number)

复制代码

代码的执行结果如下：

1. [dechin@dechin-manjaro store_class]$ python3 json_dic.py
2. {1: 1, 2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55}

复制代码

我们可以从结果中看到，第10个斐波那契数是55。接下来我们来看看这样的一个字典，如何持久化的存储到json格式的文件中，以下是一个使用的示例：

1. import json
2. number = {1:1, 2:1}
3. for i in range(3, 11):
4.     number[i] = number[i - 1] + number[i - 2]
6. with open('number.json', 'w') as file:
7.     json.dump(number, file)
9. with open('number.json', 'r') as file:
10.     data = json.load(file)
12. print (data)

复制代码

执行这个python文件，我们可以获得如下所示的输出：

1. [dechin@dechin-manjaro store_class]$ python3 json_dic.py
2. {'1': 1, '2': 1, '3': 2, '4': 3, '5': 5, '6': 8, '7': 13, '8': 21, '9': 34, '10': 55}

复制代码

这里我们发现在当前目录下产生了一个json的文件：

1. [dechin@dechin-manjaro store_class]$ ll
2. 总用量 8
3. -rw-r--r-- 1 dechin dechin 265  3月 20 12:32 json_dic.py
4. -rw-r--r-- 1 dechin dechin  85  3月 20 12:32 number.json

复制代码

我们可以看一下这个json文件中存储了什么样的数据：

1. [dechin@dechin-manjaro store_class]$ cat number.json
2. {"1": 1, "2": 1, "3": 2, "4": 3, "5": 5, "6": 8, "7": 13, "8": 21, "9": 34, "10": 55}

复制代码

在验证了相关的数据已经被持久化存储了之后，同时我们也注意到一个问题，我们产生斐波那契数列的时候，索引1,2,3...
使用的是整型变量，但是存储到json格式之后，变成了字符串格式。我们可以使用如下的案例来说明这其中的区别：

1. import json
2. number = {1:1, 2:1}
3. for i in range(3, 11):
4.     number[i] = number[i - 1] + number[i - 2]
6. with open('number.json', 'w') as file:
7.     json.dump(number, file)
9. with open('number.json', 'r') as file:
10.     data = json.load(file)
12. print (data)print (number[10])print (data['10'])print (data[10])

复制代码

执行的输出如下：

1. [dechin@dechin-manjaro store_class]$ python3 json_dic.py
2. {'1': 1, '2': 1, '3': 2, '4': 3, '5': 5, '6': 8, '7': 13, '8': 21, '9': 34, '10': 55}5555Traceback (most recent call last):  File "json_dic.py", line 16, in     print (data[10])KeyError: 10

复制代码

这里的输出就有一个报错信息，这是因为我们使用了整型索引变量来寻找json存储的字典对象中对应的值，但是因为前面存储的时候这些整型的索引已经被转换成了字符串的索引，因此实际上在存储的对象中已经不存在整型的键值，所以执行结果会报错，而如果输入的是字符串类型的键值，则成功的找到了第10个斐波那契数。
使用pickle存储字典对象

关于斐波那契数列的信息，在上一章节中已经介绍，这里我们直接进入pickle的使用案例：

1. import pickle
2. number = {1:1, 2:1}
3. for i in range(3, 11):
4.     number[i] = number[i - 1] + number[i - 2]
6. with open('number.pickle', 'wb') as file:
7.     pickle.dump(number, file)
9. with open('number.pickle', 'rb') as file:
10.     data = pickle.load(file)
12. print (data)

复制代码

这里注意一个细节，在json格式的存储中我们使用的文件打开格式是w，而在pickle这里我们使用的存储文件打开格式是wb，pickle的读取也是用的rb的二进制的读取格式。上述代码的执行输出结果如下：

1. [dechin@dechin-manjaro store_class]$ python3 pickle_dic.py
2. {1: 1, 2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55}

复制代码

这里我们可以发现，由pickle所存储的字典格式中的整型的索引也被成功的存储起来，在当前目录下产生了一个名为number.pickle的文件就是持久化存储的对象。

1. [dechin@dechin-manjaro store_class]$ ll
2. 总用量 12
3. -rw-r--r-- 1 dechin dechin 320  3月 20 12:45 json_dic.py
4. -rw-r--r-- 1 dechin dechin  85  3月 20 12:46 number.json
5. -rw-r--r-- 1 dechin dechin  56  3月 20 12:44 number.pickle
6. -rw-r--r-- 1 dechin dechin 279  3月 20 12:44 pickle_dic.py

复制代码

类似于json格式中的持久化读取验证，我们也可以简单修改一个类似的pickle的案例：

1. import pickle
2. number = {1:1, 2:1}
3. for i in range(3, 11):
4.     number[i] = number[i - 1] + number[i - 2]
6. with open('number.pickle', 'wb') as file:
7.     pickle.dump(number, file)
9. with open('number.pickle', 'rb') as file:
10.     data = pickle.load(file)
12. print (data)print (number[10])print (data[10])

复制代码

执行结果如下所示：

1. {1: 1, 2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55}
2. 55
3. 55

复制代码

从结果中我们发现存储后的对象用一样的读取格式被成功读取。
使用sqlite3存储字典对象

在常用的Linux操作系统中都会自带sqlite3数据库，如果是windows和Mac的操作系统，可以按照这个教程中给的方案进行安装。
SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库，这意味着与其他数据库不一样，您不需要在系统中配置。
就像其他数据库，SQLite引擎不是一个独立的进程，可以按应用程序需求进行静态或动态连接。SQLite直接访问其存储文件。

同时在python3的库中一般也自带了sqlite3，不需要自己安装，下面我们用ipython演示一下如何在python中使用sqlite3数据库：

1. [dechin@dechin-manjaro store_class]$ ipython
2. Python 3.8.5 (default, Sep  4 2020, 07:30:14)
3. Type 'copyright', 'credits' or 'license' for more information
4. IPython 7.19.0 -- An enhanced Interactive Python. Type '?' for help.
6. In [1]: import sqlite3
8. In [2]: conn = sqlite3.connect('test_sqlite3.db') # 如果有db文件就读取，没有就创建
10. In [3]: cur = conn.cursor()
12. In [8]: sql_test_1 = '''CREATE TABLE number
13.    ...:         (i NUMBER,
14.    ...:          n NUMBER);''' # 创建一个名为number的表，有两列数据i和n作为键值对
16. In [9]: cur.execute(sql_test_1) # 执行字符串指令
17. Out[9]: <sqlite3.Cursor at 0x7f6fb14acc70>
19. In [10]: sql_test_2 = "INSERT INTO number VALUES(1,1)" # 插入新的数据
21. In [11]: cur.execute(sql_test_2)
22. Out[11]: <sqlite3.Cursor at 0x7f6fb14acc70>
24. In [12]: sql_test_2 = "INSERT INTO number VALUES(2,1)"
26. In [13]: sql_test_3 = "INSERT INTO number VALUES(2,1)"
28. In [14]: cur.execute(sql_test_3)
29. Out[14]: <sqlite3.Cursor at 0x7f6fb14acc70>
31. In [15]: sql_test_4 = "SELECT * FROM number WHERE i=1" # 检索数据
33. In [16]: cur.execute(sql_test_4)
34. Out[16]: <sqlite3.Cursor at 0x7f6fb14acc70>
36. In [17]: cur.fetchall()
37. Out[17]: [(1, 1)]
39. In [18]: sql_test_5 = "SELECT * FROM number WHERE i>=1"
41. In [19]: cur.execute(sql_test_5)
42. Out[19]: <sqlite3.Cursor at 0x7f6fb14acc70>
44. In [20]: cur.fetchall() # 读取检索返回值
45. Out[20]: [(1, 1), (2, 1)]
47. In [21]: for i in range(3, 11):
48.     ...:     sql_test_6 = "SELECT * FROM number WHERE i={}".format(i-1)
49.     ...:     cur.execute(sql_test_6)
50.     ...:     select_result1 = cur.fetchall()[0][1]
51.     ...:     sql_test_7 = "SELECT * FROM number WHERE i={}".format(i-2)
52.     ...:     cur.execute(sql_test_7)
53.     ...:     select_result2 = cur.fetchall()[0][1]
54.     ...:     cur.execute("INSERT INTO number VALUES({},{})".format(i, select_result1+select_res
55.     ...: ult2))
56.     ...:
58. In [22]: sql_test_8 = "SELECT * FROM number WHERE i>=1"
60. In [23]: cur.execute(sql_test_8)
61. Out[23]: <sqlite3.Cursor at 0x7f6fb14acc70>
63. In [24]: cur.fetchall()
64. Out[24]:
65. [(1, 1),
66. (2, 1),
67. (3, 2),
68. (4, 3),
69. (5, 5),
70. (6, 8),
71. (7, 13),
72. (8, 21),
73. (9, 34),
74. (10, 55)]
76. In [25]: exit() # 退出ipython

复制代码

在上述示例中我们演示了如何使用sqlite3创建数据库和表，以及对表的内容的一些常用操作。在执行完上述示例后，会在当前目录下产生一个新的db文件：

1. [dechin@dechin-manjaro store_class]$ ll
2. 总用量 24
3. -rw-r--r-- 1 dechin dechin  320  3月 20 12:45 json_dic.py
4. -rw-r--r-- 1 dechin dechin   85  3月 20 12:46 number.json
5. -rw-r--r-- 1 dechin dechin   56  3月 20 12:47 number.pickle
6. -rw-r--r-- 1 dechin dechin  315  3月 20 12:47 pickle_dic.py
7. -rw-r--r-- 1 dechin dechin 8192  3月 20 13:05 test_sqlite3.db

复制代码

如果在运行过程中出现如下所示的报错，就代表有其他的进程正在占用这个db文件，因此会有进程将这个数据库进行锁定：

1. Traceback (most recent call last):
2.   File "sqlite3_dic.py", line 15, in <module>
3.     cur.execute("INSERT INTO number VALUES(1,1)")
4. sqlite3.OperationalError: database is locked

复制代码

解决的办法是，首先用fuser查看这个db文件被哪个用户所占用：

1. [dechin@dechin-manjaro store_class]$ fuser test_sqlite3.db
2. /home/dechin/projects/2021-python/store_class/test_sqlite3.db:  5120

复制代码

我们查看到是5120这个进程占用了数据库文件，也是这个进程将数据库锁定了。通常这种情况出现的原因是，在python中执行的数据库操作指令未成功完成，导致数据库的进程没有结束，而我们也无法再通过这个进程向数据库中输入新的指令。因此我们只能通过将该进程杀死的方案来解决这个问题：

1. [dechin@dechin-manjaro store_class]$ kill -9 5120

复制代码

还有一个需要注意的点是，上面所用到的数据库操作实际上并未真正的被保存到数据库文件中，需要经过commit之后才会被保存到数据库文件中。接下来我们还是用斐波那契数列的例子来演示数据库操作的使用：

1. import sqlite3
2. from tqdm import trange
4. conn = sqlite3.connect('test_sqlite3.db')
5. cur = conn.cursor()
6. try:
7.     sql_test_1 = '''CREATE TABLE number
8.                     (i NUMBER,
9.                      n NUMBER);'''
10.     cur.execute(sql_test_1)
11. except:
12.     pass
13. cur.execute("INSERT INTO number VALUES(1,1)")
14. cur.execute("INSERT INTO number VALUES(2,1)")
15. for i in trange(3, 11):
16.     sql_test_6 = "SELECT * FROM number WHERE i={}".format(i - 1)
17.     cur.execute(sql_test_6)
18.     select_result1 = cur.fetchall()[0][1]
19.     sql_test_7 = "SELECT * FROM number WHERE i={}".format(i - 2)
20.     cur.execute(sql_test_7)
21.     select_result2 = cur.fetchall()[0][1]
22.     cur.execute("INSERT INTO number VALUES({},{})".format(i, select_result1 + select_result2))
24. cur.execute("SELECT * FROM number WHERE i=10")
25. print (cur.fetchall())
26. conn.commit()
27. cur.close()
28. conn.close()

复制代码

在上述用例中我们补充了commit操作和close操作，一方面持久化的保存了数据，另一方面也避免因为程序中其他地方的问题而导致了前面所提到的数据库被锁定的问题。我们看一下这个用例的执行输出情况：
[code][dechin@dechin-manjaro store_class]$ python3 sqlite3_dic.py 100%|█████████████████████████████████████████████████████████| 8/8 [00:00