一文了解Python序列化

#!/usr/bin/env python3

#coding=utf-8

import os

import pickle

#创建一个字典对象和一个字符串对象

d=dict(one=1,two=2,three=3)

s="python"

print(d) #输出{'three': 3, 'two': 2, 'one': 1}

print(s) #输出

#将这两个对象序列化，nd和ns仅保存在内存中，可用于网络传输

nd=pickle.dumps(d)

ns=pickle.dumps(s)

print(nd) #输出字节码"b'\x80\x03}q\x00...."

print(ns) #输出字节码"b'\x80\x03X\x11...."

#将序列化后的对象重新还原成数据（假设接收端接收到这些数据后，就能够这样还原）

nd=pickle.loads(nd)

ns=pickle.loads(ns)

print(nd) #输出{'three': 3, 'two': 2, 'one': 1}

print(ns) #输出

#创建一个文件testfile，接收字节码(wb)，将d对象中的数据写入其中，

#用于本地不同应用程序之间数据交换(此时如果我们打开testfile文件，

#就会看到一些类似乱码一样的字符，实际上是d对象序列化后的数据)

with open("testfile","wb") as f1:

    pickle.dump(d,f1)

#从testfile文件中读取字节码，还原成数据

if os.path.isfile("testfile"):

    with open("testfile","rb") as f2:

        print(f2.read()) #输出"b'\x80\x03}q\x0...."

#因为上一步读取了数据，指针位置要重新设置成起始位置，

#这仅仅是为了演示给大家看，上面print和seek这两句可以不写

        f2.seek(0)

        d=pickle.load(f2) #读取f2中的数据还原

        print(d) #输出{'three': 3, 'two': 2, 'one': 1}

#!/usr/bin/env python3

#coding=utf-8

import pickle

########

class A:

    #--------

    def __init__(self,name="py",website="python"):

        self.name=name

        self.website=website

x=A()

x.name="晴刃"

#序列化类实例x，可用于网络传输

nx=pickle.dumps(x)

print(nx) #输出"b'\x80\x03c__main__...."

#还原数据

nx=pickle.loads(nx)

print(nx) #输出"<__main__.A object at 0x7f43c995c080>"

#将类对象序列化后保存到磁盘文件中，可用于程序间数据交换

with open("testfile","wb") as f1:

    pickle.dump(x,f1)

#读取文件中的数据还原

with open("testfile","rb") as f1:

    y=pickle.load(f1)

print(y.name) #输出"晴刃"

print(y.website) #输出

#!/usr/bin/env python3

#coding=utf-8

import json

#创建一个字典对象和一个浮点数对象

d=dict(one=1,two=2,three=3)

f=3.14

print(type(d)) #<class 'dict'>

print(type(f)) #<class 'float'>

#普通对象的序列化与pickle相同

nd=json.dumps(d)

nf=json.dumps(f)

#转换后所有对象都变成了字符串类型<class 'str'>

print(type(nd))

print(type(nf))

print(nd) #"{"three": 3, "two": 2, "one": 1}"

print(nf) #"3.14"

#还原数据

nd=json.loads(nd)

nf=json.loads(nf)

print(type(nd)) #<class 'dict'>

print(type(nf)) #<class 'float'>

#将d对象序列化后储存到testfile文件中

with open("testfile","w") as f1:

    json.dump(d,f1)

#从testfile文件中读取数据并还原

with open("testfile","r") as f1:

    y=json.load(f1)

    print(type(y)) #<class 'dict'>

#!/usr/bin/env python3

#coding=utf-8

import json

class A(object):

    def __init__(self,name="py",website="python"):

        self.name=name

        self.website=website

#初始化一个类实例

a=A()

#创建一个函数，将类A中的对象和数据转换成字典的形式返回

def  classA2dict(c):

    return {"name":c.name,"website":c.website}

#将a使用json序列化，参数default告诉python解释器，将前面的对象a传递给后面的classA2dict函数处理，

#classA2dict函数会返回一个字典类型，这个类型中包含了实例a中所有对象和数据的"键值对"，

#然后dumps函数将这个返回的字典类型序列化成字符串类型

x=json.dumps(a,default=classA2dict)

#如果想偷懒不写classA2dict函数，有一种简便方法，使用匿名函数，并且调用基类的__dict__函数，

#这个函数会完成和classA2dict函数相同的功能，即将一个类的所有属性转换成字典"键值对"的形式

#x=json.dumps(a,default=lambda obj:obj.__dict__)

print(type(x)) #<class 'str'>

print(x) #"{"website": "python", "name": "py"}"

#字典类型转换成类返回

def dict2classA(d):

    return A(d["name"],d["website"])

#将json序列后的数据还原成类，object_hook参数将x转换成字典类型，并传递给dict2classA函数处理，

#dict2classA函数会读取这个字典中的每个键，将值传入A类进行初始化，返回一个类对象

x=json.loads(x,object_hook=dict2classA)

print(type(x)) #<class '__main__.A'>

print(x.website)

#将序列化的类写入文件testfile中

with open("testfile","w") as f1:

    json.dump(a,f1,default=classA2dict)

#读取testfile中的数据还原

with open("testfile","r") as f2:

    y=json.load(f2,object_hook=dict2classA)

    print(y.name)