JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。JSON的数据格式其实就是python里面的字典格式,里面可以包含方括号括起来的数组,也就是python里面的列表。在python中,有专门处理json格式的模块—— json 和 picle模块。Json 模块提供了四个方法: dumps、dump、loads、load。pickle 模块也提供了四个功能:dumps、dump、loads、load。
json模块:
json.dumps():对数据进行编码;只完成了序列化为str。
json.loads():对数据进行解码;只完成了反序列化。
json.dump():对数据进行编码;必须传文件描述符,将序列化的str保存到文件中。(处理的是文件而不是字符串)
json.load():对数据进行解码;只接收文件描述符,完成了读取文件和反序列化。(处理的是文件而不是字符串)
查看源码区别:
# dumps源码
def 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):
""" Serialize ``obj`` to a JSON formatted ``str``.
# 序列号 “obj” 数据类型 转换为 JSON格式的字符串"""
# dump源码
def 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).
# 有两个动作,一个动作是将”obj“转换为JSON格式的字符串,还有一个动作是将字符串写入到文件中,也就是说文件描述符fp是必须要的参数 """
# loads源码
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
"""Deserialize ``s`` (a ``str`` instance containing a JSON document) to a Python object.
# 将包含str类型的JSON文档反序列化为一个python对象"""
# load源码
def load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
"""Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object.
# 将一个包含JSON格式数据的可读文件饭序列化为一个python对象"""
代码演示示例:
json.dumps():Python 数据类型转换为 JSON 对象
1 import json
2
3 json.dumps([]) # dumps可以格式化所有的基本数据类型为字符串
4 # '[]'
5
6 json.dumps(1) # 数字
7 # '1'
8
9 json.dumps('1') # 字符串
10 # '"1"'
11
12 dict = {"name":"Tom", "age":23}
13 json.dumps(dict) # 字典
14 # '{"name": "Tom", "age": 23}'
json.dump():写入 JSON 数据
1 a = {"name":"Tom", "age":23}
2 with open("test.json", "w", encoding='utf-8') as f:
3 json.dump(a,f,indent=4) # 和f.write(json.dumps(a, indent=4))效果一样;indent格式化保存字典,默认为None,小于0为零个空格
json.loads():将 JSON 对象转换为 Python 字典
1 json.loads('{"name":"Tom", "age":23}')
2 # {'age': 23, 'name': 'Tom'}
json.load():读取数据
1 with open('data.json', 'r') as f:
2 data = json.load(f) # 和 json.loads(f.read())效果相同
Python 编码为 JSON 类型转换对应表:
Python | JSON |
dict | object |
list, tuple | array |
str | string |
int, float, int- & float-derived Enums | number |
True | true |
False | false |
None | null |
JSON 解码为 Python 类型转换对应表:
JSON | Python |
object | dict |
array | list |
string | str |
number (int) | int |
number (real) | float |
true | True |
false | False |
null | None |
pickle 模块:
json模块和picle模块都有 dumps、dump、loads、load四种方法,而且用法一样。不用的是json模块序列化出来的是通用格式,其它编程语言都认识,就是普通的字符串,而picle模块序列化出来的只有python可以认识,其他编程语言不认识的,表现为乱码。不过picle可以序列化函数,但是其他文件想用该函数,在该文件中需要有该文件的定义(定义和参数必须相同,内容可以不同)。
对象序列化和反序列化(钝化和活化) 。序列化(钝化):内存中的对象如果想要被执行存储起来,可通过序列化机制(将对象碾碎,变为散装数据\二进制数据),持久存储到文件的某个位置;反序列化(活化):将文件中的散装对象,反序列化到程序中,还原成为一个对象实体
pickle模块的介绍:(就是用来序列化和反序列化的)
函数:
1).pickle.dump(obj, fr):将obj对象序列化到文件中(取决于fr中的path) # 没有返回值
2).pickle.load(fw):将fw(path中的数据)加载到程序,以对象返回 # 有返回值
【注意】:文件对象不要忘记关闭!!!
使用pickle模块演示对象序列化和反序列操作:
1 import pickle
2
3 class Person:
4 def __init__(self,name,age,sex):
5 self.name = name
6 self.age = age
7 self.sex = sex
8 def __str__(self):
9 return 'name:%s,age:%s,sex:%s' %(self.name,self.age,self.sex)
10
11 #实例化Person对象
12 p = Person('貂蝉',18,'女',162.0,84,'靓丽')
13
14 fw = open(r'person.txt','wb') #创建一个文件person.txt,打开方式wb
15 #对象序列化操作:将程序中的对象p序列化到person.txt文件中保存起来
16 pickle.dump(p,fw)
17 fw.close()
18
19 fr = open(r'person.txt','rb') #打开文件person.txt
20 #对象反序列化操作:将person.txt中的二进制数据反序列化到程序中,还原成为一个Person对象
21 p1 = pickle.load(fr)
22 print(p1,type(p1))
23 fr.close()
演示容器对象的序列化和反序列化操作:
1 # 有4个Person对象,我们可以先将它们存入到list中,然后将此list对象序列化到某一个文件中,之后再将其反序列化到程序,还原得到一个list对象
2 per1 = Person('貂蝉',18,'女',162.0,84,'靓丽')
3 per2 = Person('西施',16,'女',160.0,80,'柔弱')
4 per3 = Person('昭君',19,'女',165.0,88,'清纯')
5 per4 = Person('环环',23,'女',170.0,130,'肥美')
6 lt = []
7 lt.append(per1)
8 lt.append(per2)
9 lt.append(per3)
10 lt.append(per4)
11
12 # 将lt对象序列化到文件persons.txt中
13 fw = open(r'persons.txt','wb')
14 pickle.dump(lt,fw)
15 fw.close()
16
17 # 将persons.txt中的二进制数据反序列化到程序中
18 fr = open(r'persons.txt','rb')
19 lt1 = pickle.load(fr)
20 fr.close()
21
22 print(lt1) # 因为放进去的是对象,所以只能看到四个对象,看不到内容
23 # 循环遍历lt1,即可查看
24 for i in lt1:
25 print(i)
【总结】:
1. json序列化方法: dumps:无文件操作 dump:序列化+写入文件
2. json反序列化方法: loads:无文件操作 load: 读文件+反序列化
3. json模块序列化的数据更通用 pickle模块序列化的数据仅python可用,但功能强大,可以序列号函数
4. json模块可以序列化和反序列化的数据类型见python对象(obj) 与json对象的对应关系表
5. 格式化写入文件利用 indent = 4
【简单补充】:
对于python数据分析可能会使用到。将DataFrame类型数据转换成json数据。
函数:pandas.to_json(orient)
代码简单演示转换成的5种格式(了解一下):
1 import pandas as pd
2
3 df = pd.DataFrame([['a', 'b'], ['c', 'd']],index=['row 1', 'row 2'],columns=['col 1', 'col 2'])
4
5 df.to_json(orient='split')
6 # '{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}'
7
8 df.to_json(orient='records')
9 # '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
10
11 df.to_json(orient='index')
12 # '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'
13
14 df.to_json(orient='columns')
15 # '{"col 1":{"row 1":"a","row 2":"c"},"col 2":{"row 1":"b","row 2":"d"}}'
16
17 df.to_json(orient='values')
18 # '[["a","b"],["c","d"]]'
19
20 df.to_json(orient='table')
21 # '{"schema": {"primaryKey":["index"],"fields":[{"name":"index","type":"string"},{"name":"col 1","type":"string"},{"name":"col 2","type":"string"}],"pandas_version":"0.20.0"},"data": [{"index":"row 1","col 1":"a","col 2":"b"},{"index":"row 2","col 1":"c","col 2":"d"}]}'
orient的值:split 将索引总结到索引,列名到列名,数据到数据,将三部分都分开了了;records 以columns:values的形式输出;index 以index:{columns:values}...的形式输出;colums 以columns:{index:values}的形式输出;values 直接输出值;table形式。