序列化 json 模块

什么是序列化？

序列化是将数据结构或对象转换为一种可存储或传输的格式的过程，以便在需要时能够重新还原原始数据结构或对象。序列化通常将数据转换为字节流、文本或其他格式，以便将其保存到文件、数据库、网络传输或内存中。
这种过程可以帮助数据持久化、数据传输以及跨不同编程语言和平台之间的数据交换。

 

我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

将python中的列表，字典，元组，集合转换成字符串的过程就叫做序列化，反之叫做反序列化。

我们把变量从内存中变成可存储或传输的过程称之为序列化，序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

序列化的原因

1、对象或数据结构可以存储

2、对象或数据结构跨平台传输方便

3、使程序更具维护性。

Json模块

所有的语言都通用,默认序列化的数据是有限的：列表、字典、元组（元组被转化为字符串的列表的形式）,布尔值,数字,None

 +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

 

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

 

查看json库所有的方法

import json

print(json.__all__)

结果:

['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder']

 

例子:

import json
dic3=('e','g')
str2=json.dumps(dic3)
print(type(str2),str2)

结果:

<class 'str'> ["e", "g"]

loads和dumps主要转化类型

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

关于json.dumps补充知识点一

json.dumps函数参数解析

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

 

obj：待序列化的Python对象，可以是dict、list、tuple等容器类型的数据；
skipkeys：如果可选参数skipkeys为True（默认为False），则跳过那些不能被JSON序列化的键值对（比如Python的None、NaN、Infinity等）；
ensure_ascii：如果可选参数ensure_ascii为True（默认为True），则在输出中所有非ASCII字符都将转义为\x的形式，如果ensure_ascii为False，则输出为原始Unicode字符；
check_circular：如果可选参数check_circular为True（默认为True），则检查将要序列化的对象是否有循环引用的情况，如果有，则报错；
allow_nan：如果可选参数allow_nan为True（默认为True），则浮点数值NaN、Infinity、-Infinity将被表示为字符串“NaN”、“Infinity”、“-Infinity”，默认值为True；
cls：如果可选参数cls指定了一个class函数或者callable函数，则dumps采用其返回的对像进行序列化输出。比如，传入编码器 XXXEncoder 的如下：cls=XXXEncoder；
indent：如果可选参数indent为非负整数，则使用该数值作为缩进级别，对输出进行格式化；
separators：如果指定了可选参数separators，则它应该是一个包含两个字符串的元组，表示迭代器中键/值之间的分隔符和键值对之间的分隔符。默认的(separators=(',', ':'))将产生输出类似于'{"foo":1,"bar":2}'这样紧凑的字符串。为了产生更加可读性好的输出，可以指定(separators=(',', ': '))，从而产生类似'{"foo": 1, "bar": 2}'的输出；
default：表示用于序列化未序列化对象的一个函数；
sort_keys：如果可选参数sort_keys为True（默认为False），则按照字典序（按照ASCII的值）排序输出JSON对象的键值对，否则按照输入顺序输出。

 

default 和 cls 是 JSON 模块中用于自定义序列化过程的两个参数，它们的作用不同？

default 参数：

default 是一个函数，用于处理在序列化过程中遇到的不可序列化的对象。如果 JSON 模块在序列化过程中遇到无法直接序列化的对象，它将调用 default 函数来处理该对象，将其转换为可序列化的对象。
默认情况下，default 参数为 None，这意味着如果遇到不可序列化的对象，将引发 TypeError 异常。
通常，default 函数返回可以被 JSON 直接序列化的对象，例如字符串、数字、列表、字典等。这使得我们可以将不支持的数据类型转换为 JSON 支持的数据类型。
cls 参数：

cls 是一个 JSON 编码器类，用于自定义编码过程。它通常用于创建自定义的 JSON 编码器，以便更灵活地控制序列化过程。
通过指定 cls 参数，您可以为不同的数据类型选择不同的序列化方法。您可以创建一个自定义编码器类，覆盖编码方法，以满足特定的序列化需求。
总结而言，default 参数用于处理不可序列化的对象，通常返回可序列化的替代对象。而 cls 参数用于创建自定义的 JSON 编码器，以实现更复杂的序列化逻辑。通常情况下，如果只需处理不可序列化的对象，
使用 default 参数即可，而如果需要更灵活地控制序列化过程，可以考虑使用 cls 参数创建自定义编码器。

 

 

json.dumps(s,ensure_ascii=True),默认的编码方式ascii,如果你输入的是中文,它会默认输出的是unicode编码结果,如果你想要得到正确的值,ensure_ascii=Flase

import json
s='中国'
print(json.dumps(s))
print(json.dumps(s,ensure_ascii=False))

结果:

"\u4e2d\u56fd"#unicode的编码结果
"中国"

 

 

 补充json.loads

1、ValueError: Invalid control character at: line 1 column 8363 (char 8362)
使用json.loads(json_data)时，出现：

ValueError: Invalid control character at: line 1 column 8363 (char 8362)
出现错误的原因是字符串中包含了回车符（\r）或者换行符（\n）
解决方法：
(1)对这些字符转义：

json_data = json_data.replace('\r', '\\r').replace('\n', '\\n')
(2)使用关键字strict:

json.loads(json_data, strict=False)
strict默认是True,它将严格控制内部字符串，将其设置为False,便可以允许你\n \r。

 

 

 

 

load和dump主要与写入文件有关系

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

 序列化不支持的数据类型

json想要序列化不支持的数据类型需要重写json.JSONEncoder 中的defaul方法

在JSONEncoder不知道怎么去把这个数据转换成json字符串的时候，它就会去调用default()函数,所以都是重写这个函数来处理它本身不支持的数据类型，default()函数默认是直接抛异常的。

def default(self, o):
        """Implement this method in a subclass such that it returns
        a serializable object for ``o``, or calls the base implementation
        (to raise a ``TypeError``).

        For example, to support arbitrary iterators, you could
        implement default like this::

            def default(self, o):
                try:
                    iterable = iter(o)
                except TypeError:
                    pass
                else:
                    return list(iterable)
                # Let the base class default method raise the TypeError
                return JSONEncoder.default(self, o)

        """
        raise TypeError("Object of type '%s' is not JSON serializable" %
                        o.__class__.__name__)

 

方法1 ：使用default参数来解决

我们知道对象是不能被序列化的,我们可以编写方法来序列化对象

比如

import json


class Boy:

    def __init__(self, name, age):
        self.name = name
        self.age = age

obj = Boy('Will', 20)
# # 我们知道json是不能序列化对象的，我们可以编写方法来序列化对象
def json_boy(obj):
    if isinstance(obj, Boy):
        return {'name': obj.name, 'age': obj.age}
    return obj

json_data = json.dumps(obj, default=json_boy)

print(json_data)

 

结果为：

{"name": "Will", "age": 20}

方法2 使用cls参数来解决

我们知道json是不能序列迭代器的

i=[1,2,3,4]

b=iter(i)#生成迭代器

class JsonTex(json.JSONEncoder):
    def default(self, o):
        try:
            pass
        except TypeError as e:
            pass
        else:
            return list(o)
tt=json.dumps(b,cls=JsonTex)
print(tt,type(tt))

 

结果:

[1, 2, 3, 4] <class 'str'>

序列datetime类型

 datetime json并不支持这种类型,如果我们要序列化,就要重写JSONEncode中的default方法

import datetime
time=datetime.datetime.today()
class JsonTex(json.JSONEncoder):
    def default(self, o):
        if isinstance(o,datetime.datetime):
            return o.strftime('%Y-%m-%d %H:%M:%S')
        else:
            raise TypeError("Object of type '%s' is not JSON serializable" %
                            o.__class__.__name__)

t=json.dumps(time,cls=JsonTex)

print(t,type(t))

结果:

"2018-07-19 13:27:19" <class 'str'>

 

pickle模块

pickle模块 可以序列化python中任何类型，python专有的不能和其他语言混用，序列化的结果是bytes类型。

列子:

import pickle
dic={'k1':'k2'}
str_dic=pickle.dumps(dic)
print(str_dic)

结果:

b'\x80\x03}q\x00X\x02\x00\x00\x00k1q\x01X\x02\x00\x00\x00k2q\x02s.'

用pickle序列化的数据，反序列化的时候也要用pickle。

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)       dump把数据类型序列化到文档中，以bytes类型
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

shelve模块

shelve模块也是python提供给我们的序列化工具，比pickle用起来更简单一些。
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

shelve

这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存。

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

设置writeback

writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。