【强烈推荐】Python中JSON的基本使用（超详细）

1. JSON简介

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，它是JavaScript的子集，易于人阅读和编写。

JSON用来存储和交换文本信息，比xml更小/更快/更易解析，易于读写，占用带宽小，网络传输速度快的特性，适用于数据量大，不要求保留原有类型的情况。。

前端和后端进行数据交互，其实就是JS和Python进行数据交互！

2. JSON语法规则

1. 名称必须用双引号（即：" "）来包括
2. 值可以是双引号包括的字符串、数字、true、false、null、JavaScript数组，或子对象
3. 数据在name/value中
4. 数据见用逗号分隔
5. 花括号保存对象
6. 方括号保存数组

3. JSON数据类型

一并列举出Python与JSON数据类型的映射关系：

Python	JSON
dict	object
list, tuple	array
str, unicode	string
int, long, float	number
True	true
False	false
None	null

4. JSON对象

在花括号中书写，对象可以包含多个名称/值对。

例：

{"firstname": "jonh", "lastname": "Doe"}

5. JSON数组

Employees是包含三个对象的数组。

每个对象代表一条关于某个人名的记录，在方括号中书写，数组可以包含多个对象：

{
	"employees": [
		{ “firstName”:“John” , “lastName”:“Doe” },
		{ “firstName”:“Anna” , “lastName”:“Smith” },
		{ “firstName”:“Peter” , “lastName”:“Jones” }
	]
}

6. JSON中常用的方法

python在使用json这个模块前，首先要导入json库：import json.

方法	描述
json.dumps()	将 Python 对象编码成 JSON 字符串
json.loads()	将已编码的 JSON 字符串解码为 Python 对象
json.dump()	将Python内置类型序列化为json对象后写入文件
json.load()	读取文件中json形式的字符串元素转化为Python类型

注意：不带s的是序列化到文件或者从文件反序列化，带s的都是内存操作不涉及持久化。

6.1 json.dumps()

import json
 
data = {'name':'nanbei','age':18}
# 将Python对象编码成json字符串
print(json.dumps(data))

结果:

{"name": "nanbei", "age": 18}

注： 在这里我们可以看到，原先的单引号已经变成双引号了

6.2 json.loads()

import json
 
data = {'name':'nanbei','age':18}
# 将Python对象编码成json字符串
# print(json.dumps(data))
# 将json字符串解码成Python对象
a = json.dumps(data)
print(json.loads(a))

结果:

{'name': 'nanbei', 'age': 18}

在这里举个元组和列表的例子：

import json
 
data = (1,2,3,4)
data_json = [1,2,3,4]
#将Python对象编码成json字符串
print(json.dumps(data))
print(json.dumps(data_json))

#将Python对象编码成json字符串
a = json.dumps(data)
b = json.dumps(data_json)
#将json字符串编码成Python对象
print(json.loads(a))
print(json.loads(b))

结果：

[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]

可以看到，元组和列表解析出来的均是数组。

由以上输出可以看出编码过程中，Python中的list和tuple都被转化成json的数组，而解码后，json的数组最终被转化成Python的list的，无论是原来是list还是tuple。

6.3 json.dump()

将Python内置类型序列化为json对象后写入文件：

import json
 
data = {
    'nanbei':'haha',
    'a':[1,2,3,4],
    'b':(1,2,3)
}
with open('json_test.txt','w+') as f:
    json.dump(data,f)

6.4 json.load()

读取文件中json形式的字符串元素转化为Python类型：

import json
 
data = {
    'nanbei':'haha',
    'a':[1,2,3,4],
    'b':(1,2,3)
}
with open('json_test.txt','w+') as f:
    json.dump(data,f)
 
with open('json_test.txt','r+') as f:
    print(json.load(f))

结果：

{'a': [1, 2, 3, 4], 'b': [1, 2, 3], 'nanbei': 'haha'}

6.5 更多实例

json.dumps()：将一个Python数据类型列表编码成json格式的字符串

#python的列表转换为json的数组
>>> import json
>>> json.dumps([1,2,3])
'[1, 2, 3]'
#python的字符串转换为json的字符串
>>> json.dumps('abdcs')
'"abdcs"'
#python的元祖转换为json的数组
>>> json.dumps((1,2,3,'a'))
'[1, 2, 3, "a"]'#注意此时显示的是方括号
#python的字典转换为json的对象
>>> json.dumps({1:'a',2:'b'})
'{"1": "a", "2": "b"}'#注意此时1和2转换后是加了引号的，因为json的名称是必须要加引号的
#python的整数转换为json的数字
>>> json.dumps(13)
'13'
#python的浮点数转换为json的数字
>>> json.dumps(3.1415)
'3.1415'
#python的unicode字符串转换为json的字符串
>>> json.dumps(u'a')
'"a"'
#python的True转换为json的数组true
>>> json.dumps(True)
'true'
#python的False转换为json的数组false
>>> json.dumps(False)
'false'
#python的None转换为json的null
>>> json.dumps(None)
'null'
#json本质上是一个字符串
>>> type(json.dumps('abc'))
<class 'str'>

dump和dumps：

import json

# dumps可以格式化所有的基本数据类型为字符串
data1 = json.dumps([])         # 列表
print(data1, type(data1))
data2 = json.dumps(2)          # 数字
print(data2, type(data2))
data3 = json.dumps('3')        # 字符串
print(data3, type(data3))
dict = {"name": "Tom", "age": 23}   # 字典
data4 = json.dumps(dict)
print(data4, type(data4))

with open("test.json", "w", encoding='utf-8') as f:
    # indent 超级好用，格式化保存字典，默认为None，小于0为零个空格
    f.write(json.dumps(dict, indent=4))
    json.dump(dict, f, indent=4)  # 传入文件描述符，和dumps一样的结果

得到的输出结果如下：格式化所有的数据类型为str类型:

[] <class 'str'>
2 <class 'str'>
"3" <class 'str'>
{"name": "Tom", "age": 23} <class 'str'>

test.json中的内容:

{
    "name": "Tom",
    "age": 23
}

load和loads

import json

dict = '{"name": "Tom", "age": 23}'   # 将字符串还原为dict
data1 = json.loads(dict)
print(data1, type(data1))

with open("test.json", "r", encoding='utf-8') as f:
    data2 = json.loads(f.read())    # load的传入参数为字符串类型
    print(data2, type(data2))
    f.seek(0)                       # 将文件游标移动到文件开头位置
    data3 = json.load(f)
    print(data3, type(data3))

运行结果如下：

{'name': 'Tom', 'age': 23} <class 'dict'>
{'name': 'Tom', 'age': 23} <class 'dict'>
{'name': 'Tom', 'age': 23} <class 'dict'>

7. 参数详解

dumps(obj,skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):

函数作用: 将Python对象转变成JSON对象，便于序列化内存/文件中。

参数：

• skipkeys: 如果为True的话，则只能是字典对象，否则会TypeError错误, 默认False
• ensure_ascii: 确定是否为ASCII编码
• check_circular: 循环类型检查，如果为True的话
• allow_nan: 确定是否为允许的值
• indent: 会以美观的方式来打印，呈现，实现缩进
• separators: 对象分隔符，默认为,
• encoding: 编码方式，默认为utf-8
• sort_keys: 如果是字典对象，选择True的话，会按照键的ASCII码来排序

对于dump来说，只是多了一个fp参数：

简单说就是dump需要一个类似文件指针的参数（并不是真正的指针，可以称之为文件对象），与文件操作相结合，即先将Python文件对象转化为json字符串再保存在文件中。

dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw)

Serialize ``obj`` as a JSON formatted stream to ``fp`` (a``.write()``-supporting file-like object).

类似Java中的class implements java.io.Serializable

Java提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

8. JSON反序列化为对象

JSON反序列化为类对象或者类的实例，使用的是loads()方法中的object_hook参数：

代码示例：

import json

# 定义一个员工类
class Employee(object):
      def __init__(self,name,age,sex,tel):
            self.name=name
            self.age=age
            self.sex=sex
            self.tel=tel
            
# 实例化一个对象     
emp = Employee('kongsh',18,'female',13123456789)

# 定义JSON转换Python实例的函数
def jsonToClass(emp):
      return Employee(emp['name'], emp['age'], emp['sex'], emp['tel'])
# 定义一个json字符串（字典）
json_str = '{"name": "kongsh", "age": 18, "sex": "female", "tel": 13123456789}'

emp = json.loads(json_str, object_hook=jsonToClass)
print (emp)
print(emp.name)

结果展示：

9. 常见的错误

9.1 读取多行的JSON文件

假如要读取一个多行的JSON文件：

{"坂": ["坂5742"]}
{"构": ["构6784"]}
{"共": ["共5171"]}
{"钩": ["钩94a9"]}
{"肮": ["肮80ae"]}
{"孤": ["孤5b64"]}

如果直接使用：

with open(json_path, 'r') as f:
    json_data = json.load(f)

就会报错：抛出异常JSONDecodeError

json.decoder.JSONDecodeError: Extra data: line 2 column 1 (char 17)

表示数据错误，数据太多，第2行第一列

因为json只能读取一个文档对象，有两个解决办法

1. 单行读取文件,一次读取一行文件。
2. 保存数据源的时候，格式写为一个对象（dump）。

1. 单行读取文件：

with open(json_path, 'r') as f:
    for line in f.readlines():
        json_data = json.loads(line)

但是这种做法还有个问题，如果JSON文件中包含空行，还是会抛出JSONDecodeError异常。

json.decoder.JSONDecodeError: Expecting value: line 2 column 1 (char 1)

可以先处理空行，再进行文件读取操作：

for line in f.readlines():
      line = line.strip()   # 使用strip函数去除空行
      if len(line) != 0:
          json_data = json.loads(line)

2. 合并为一个对象：

将json文件处理成一个对象文件（序列化）：

{"dict": [
{"坂": ["坂5742"]},
{"构": ["构6784"]},
{"共": ["共5171"]},
{"钩": ["钩94a9"]},
{"肮": ["肮80ae"]},
{"孤": ["孤5b64"]}
]}

然后再用：

with open(json_path, 'r') as f:
     json_data = json.loads(f.read())

9.2 控制台乱码

# ensure_ascii=False 表示在控制台能够显示中文
json_str = json.dumps(center_data_list, ensure_ascii=False)

10. 总结

• json.dumps 将 Python 对象编码成 JSON 字符串
• json.loads 将已编码的 JSON 字符串解码为 Python 对象
• json.dump和json.load，需要传入文件描述符，加上文件操作。
• json内部的格式要注意，一个好的格式能够方便读取，可以用indent格式化。

个人总结：

• dump：存入的实例对象object（序列化）

• dumps：存入的JSON的字符串数据

• load：读取的实例对象object（反序列化）

• loads：读取的JSON的字符串数据，转化为Python字典对象

已经好久没有跟男神说话了，前路慢慢，加油吧~

摘自大佬博客的内容，感觉很有意思，很逗呀！(*￣︶￣)

参考：Link Link Link

加油!

感谢!

努力!