Python操作JSON

Edited on In

操作JSON

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import json
data = {'name':'nanbei','age':18}
# 将Python对象编码成json字符串
print(json.dumps(data)) # {"name": "nanbei", "age": 18}
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}
  
data = (1,2,3,4)
data_json = [1,2,3,4]
#将Python对象编码成json字符串
print(json.dumps(data)) # [1, 2, 3, 4]
print(json.dumps(data_json))# [1, 2, 3, 4]
 
#将Python对象编码成json字符串
a = json.dumps(data)
b = json.dumps(data_json)
#将json字符串编码成Python对象
print(json.loads(a))# [1, 2, 3, 4]
print(json.loads(b))# [1, 2, 3, 4]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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))

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’>

  1. 参数详解

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

  1. 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)
结果展示：

在这里插入图片描述

  1. 常见的错误

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只能读取一个文档对象，有两个解决办法

单行读取文件,一次读取一行文件。
保存数据源的时候，格式写为一个对象（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)

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

dump：存入的实例对象object（序列化）
dumps：存入的JSON的字符串数据
load：读取的实例对象object（反序列化）
loads：读取的JSON的字符串数据，转化为Python字典对象

本文地址： https://github.com/maxzhao-it/blog/post/93daf94d/