python json模块

目录

• 1.JSON简介
• 2.JSON语法规则
• 3.JSON数据类型
• 4.JSON对象
• 5.JSON数组
• 6.JSON中常用的方法
  • 6.1 json.dumps()
  • 6.2 json.loads()
  • 6.3 json.dump()
  • 6.4 json.load()
  • 6.5 更多实例
• 7.参数详解
• 8.JSON反序列化为对象
• 9.常见的错误
  • 9.1读取多行的JSON文件
  • 9.2控制台乱码
• 10.总结

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":"John", "lastname":"Harry"}

5.JSON数组

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

{
    "employees": [
        {"firstname" : "John" , "lastname" : "Harry"},
        {"firstname" : "John1" , "lastname" : "Harry1"},
        {"firstname" : "John2" , "lastname" : "Harry2"}
    ]
}

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' : 'John', 'age' : 18}
# 将python对象编码为json字符串
print(json.dumps(data))

结果:

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

注: 在这里我们可以看到，原先的单引号已经变成双引号了，即已经转换为json格式

6.2 json.loads()

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

结果：

{'name': 'John', '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_text.txt','w+') as f:
    json.dump(data, f)

json_text.txt文件的内容：

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

6.4 json.load()

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

import json
data = {
    'nanbei' : 'haha',
    'a' : [1,2,3,4],
    'b' : (1,2,3)
}

with open('json_text.txt','r+') as f:
    print(json.load(f))

结果：

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

6.5 更多实例

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

# python的列表转换为json的数组
>>> import json
>>> json.dumps([1,2,3])
'[1, 2, 3]'
>>>
# python字符串转化为json的字符串
>>> json.dumps('abc')
'"abc"'
# python的元组转换为json的数组
>>> json.dumps((1,2,3,'a'))
'[1, 2, 3, "a"]'
# python的字典转换为json的对象
>>> json.dumps({1:'a',2:'b'})
'{"1": "a", "2": "b"}'
# 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))
# 结果：[] <class 'str'>

# 数字
data2 = json.dumps(2)
print(data2,type(data2))
# 结果：2 <class 'str'>

# 字符串
data3 = json.dumps('3')
print(data3,type(data3))
# 结果："3" <class 'str'>

# 字典
dict1 = {"name": "zhang","age":20}
data4 = json.dumps(dict1)
print(data4,type(data4))
# 结果：{"name": "zhang", "age": 20} <class 'str'>

dict1 = {"name": "zhang","age":20}
with open("test.json","w",encoding="utf-8") as f:
    # indent格式化保存字典，默认为None，小于0为零个空格
    f.write(json.dumps(dict1,indent=4))

dict1 = {"name": "zhang","age":20}
with open("test.json","w",encoding="utf-8") as f:
    # 传入文件描述符，和dumps一样的结果，不过将结果写入文件中了。
    json.dump(dict1,f,indent=4)

# 结果：
test.json文件内容
{
    "name": "zhang",
    "age": 20
}

• load和loads：

import json
dict1 = '{"name": "zhang", "age": 23}'
data1 = json.loads(dict1)
print(data1,type(data1))
# 结果：{'name': 'zhang', 'age': 23} <class 'dict'>

with open("test.json", "r",encoding="utf8") as f:
    # load的传入参数为字符串类型
    data2 = json.loads(f.read())
    print(data2,type(data2))
    # 将文件游标移动到文件开头位置
    f.seek(0)
# 结果：{'name': 'zhang', 'age': 20} <class 'dict'>

with open("test.json", "r",encoding="utf8") as f:
    data3 = json.load(f)
    print(data3,type(data3))
# 结果：{'name': 'zhang', 'age': 20} <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',123456789)        

# 定义json转换为python示例函数
def jsonToClass(emp):
    return Employee(emp['name'],emp['age'],emp['sex'],emp['tel'])

# 定义1个json字符串(字典)
json_str = '{"name": "zhang","age":20,"sex": "male","tel":123456}'

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

# 结果：
<__main__.Employee object at 0x00000182BDDF7D68>
zhang

9.常见的错误

9.1读取多行的JSON文件

假设有个多行的json文件内容如下：

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

如果直接使用：

import json
json_path = 'test.txt'
with open(json_path,'rb') as f:
    json_data = json.load(f)

就会报错：
抛出异常

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

表示数据错误，数据太多，第2行第一列
因为json只能读取一个文档对象，有两个解决办法：

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

解决办法：
1.单行读取文件：

import json
json_path = 'test.txt'
with open(json_path,'rb') as f:
    for line in f.readlines():
        json_data = json.loads(line)
        print(json_data)

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

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

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

import json
json_path = 'test.txt'
with open(json_path,'rb') as f:
    for line in f.readlines():
        # 去除空行
        line = line.strip()
        if len(line) != 0:
            json_data = json.loads(line)
            print(json_data)

运行结果：

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

2.合并为一个对象：
将json文件处理成一个对象文件（序列化）

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

然后再用：

import json
json_path = 'test.txt'
with open(json_path,'rb') as f:
    json_data = json.loads(f.read())
    print(json_data)

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字典对象