11.python内置模块之json模块

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

import json

json.dumps([])    # dumps可以格式化所有的基本数据类型为字符串
# '[]'

json.dumps(1)     # 数字
# '1'

json.dumps('1')   # 字符串
# '"1"'

dict = {"name":"Tom", "age":23}  
json.dumps(dict)  # 字典
# '{"name": "Tom", "age": 23}'

json.dump()：写入 JSON 数据

a = {"name":"Tom", "age":23}
with open("test.json", "w", encoding='utf-8') as f:
    json.dump(a,f,indent=4)  # 和f.write(json.dumps(a, indent=4))效果一样；indent格式化保存字典，默认为None，小于0为零个空格

json.loads()：将 JSON 对象转换为 Python 字典

json.loads('{"name":"Tom", "age":23}')
# {'age': 23, 'name': 'Tom'}

json.load()：读取数据

with open('data.json', 'r') as f:
    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模块演示对象序列化和反序列操作：

import pickle

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __str__(self):
        return 'name：%s，age：%s，sex：%s' %(self.name,self.age,self.sex)

#实例化Person对象
p = Person('貂蝉',18,'女',162.0,84,'靓丽')

fw = open(r'person.txt','wb')   #创建一个文件person.txt，打开方式wb
#对象序列化操作：将程序中的对象p序列化到person.txt文件中保存起来
pickle.dump(p,fw)
fw.close()

fr = open(r'person.txt','rb')   #打开文件person.txt
#对象反序列化操作：将person.txt中的二进制数据反序列化到程序中，还原成为一个Person对象
p1 = pickle.load(fr)
print(p1,type(p1))
fr.close()

演示容器对象的序列化和反序列化操作：

# 有4个Person对象，我们可以先将它们存入到list中，然后将此list对象序列化到某一个文件中，之后再将其反序列化到程序，还原得到一个list对象
per1 = Person('貂蝉',18,'女',162.0,84,'靓丽')
per2 = Person('西施',16,'女',160.0,80,'柔弱')
per3 = Person('昭君',19,'女',165.0,88,'清纯')
per4 = Person('环环',23,'女',170.0,130,'肥美')
lt = []
lt.append(per1)
lt.append(per2)
lt.append(per3)
lt.append(per4)

# 将lt对象序列化到文件persons.txt中
fw = open(r'persons.txt','wb')
pickle.dump(lt,fw)
fw.close()

# 将persons.txt中的二进制数据反序列化到程序中
fr = open(r'persons.txt','rb')
lt1 = pickle.load(fr)
fr.close()

print(lt1)     # 因为放进去的是对象，所以只能看到四个对象，看不到内容
# 循环遍历lt1，即可查看
for i in lt1:
    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种格式（了解一下）：

import pandas as pd

df = pd.DataFrame([['a', 'b'], ['c', 'd']],index=['row 1', 'row 2'],columns=['col 1', 'col 2'])

df.to_json(orient='split')
# '{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}'

df.to_json(orient='records')
# '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'

df.to_json(orient='index')
# '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'

df.to_json(orient='columns')
# '{"col 1":{"row 1":"a","row 2":"c"},"col 2":{"row 1":"b","row 2":"d"}}'

df.to_json(orient='values')
# '[["a","b"],["c","d"]]'

df.to_json(orient='table')
# '{"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形式。