python note 序列化

<tr>——单元格中的一行

<td>——一行中的一格

https://www.bootcdn.cn——含有html相关架构

元类

1. 元类就是创建类的类，元类是由“type”衍生而出，所以父类需要传入type.
2. 元类的操作都在__new__中完成，它的第一个参数是将创建的类，之后的参数即是

三大永恒命题：我是谁，我从哪里来，我将到哪里去。它返回的对象也是三大永恒命题

1. 通过元类创建的类，第一个参数是父类，第二个参数是metaclass

 

 

断言：assert

 

Redis,做到架构，写数据写队列里面，读数据也要从缓存里面读

 

https://www.oschina.net/——开源网址

StringIO

很多时候，数据读写不一定是文件，也可以在内存中读写

StringIO就是在内存中读写str

要把str写入StringIO，需要先创建一个StringIO，然后，像文件一样写入即可

getvalue()方法获得写入后的str

要读取StringIO,可以用一个str初始化StringIO,然后像读文件一样读取

 

# -*- coding: utf-8 -*-

from io import StringIO

f=StringIO(“hello world !\n”)#初始化只可以存字符串

 f.writelines([‘python\n’,’java\n’,’php\n’])#初始化传入参数会被后面写入的内容覆盖

   content=f.getvalue()

print(content)

StringIO操作的只能是str,如果要操作二进制数据，就需要使用BytesIO

BytesIO实现了在内存中读写bytes，创建一个BytesIO,然后写入一些bytes:

from io import BytesIO

  f = BytesIO()

   f.write(‘中文’.encode(‘utf-8’))

   写入的不是str,而是经过utf-8编码的bytes.

   和StringIO类似，可以用一个bytes初始化BytesIO,然后，像读文件一样读取：

 

 

# -*- coding: utf-8 -*-

from io import BytesIO

#实例化

f=BytesIO()

#存入数据

f.write("hello 大家好！".encode("utf-8"))

#取出数据

content=f.getvalue()

print(content)

#二进制转化为字符串

print(content.decode("utf-8"))

 

序列化与反序列化的概念

序列化是指将数据结构或对象转化成二进制串的过程：

反序列化是将序列化过程中生成的二进制串转化成数据结构或对象的过程

非文件形式

pickle.dumps将对象转化为bytes

pickle.loads将bytes转化为对象

文件形式

pickle.dump将对象转化为bytes写入文件中

  pickle.load从文件中读取bytes转化为对象

 

# -*- coding: utf-8 -*-

import pickle

 

# pickle，序列化模块，生成二进制编码

 

# 序列化：将python数据结构存储为二进制编码，serialize

# 反序列化：将二进制转化为python数据结构，unserialize

person = type(

    'person',

    (object,),

    dict(

        name="张三",

        sex="男",

        age=18,

        run=lambda self: "正在跑步！"

    )

)

 

 

class Pick:

    # 非文件模式

    # 非文件序列化，存储在内存中

    @staticmethod

    def serialize(data):

        # data，python数据结构

        return pickle.dumps(data)

 

    # 非文件反序列化

    @staticmethod

    def unserialize(data):

        # data，二进制串

        data_obj = pickle.loads(data)

        # print(data_obj, type(data_obj))

        return data_obj

 

 

if __name__ == "__main__":

    p = Pick()

    a, b, c, d, e = 1000, 3.14, "hello", [1, 2, 3, 4], dict(name="张三", age=18)

    ab = p.serialize(a)

    bb = p.serialize(b)

    cb = p.serialize(c)

    db = p.serialize(d)

    eb = p.serialize(e)

    personb = p.serialize(person)

 

    print(ab)

    print(bb)

    print(cb)

    print(db)

    print(eb)

    print(personb)

    print("---------------------------")

    print(p.unserialize(ab))

    print(p.unserialize(bb))

    print(p.unserialize(cb))

    print(p.unserialize(db))

    print(p.unserialize(eb))

    person_obj = p.unserialize(personb)

    pb = person_obj()

    print(pb.name, pb.sex, pb.age, pb.run())

 

 

# -*- coding: utf-8 -*-

import pickle

 

 

# 应用，进行持久性存储，可以用来共用

# 文件模式进行持久性存储

# 一次性存，一次性取

class Pick:

    def __init__(self, path):

        self.path = path

 

    # 序列化，存文件中去

    def serialize(self, *args):

        with open(self.path, "wb") as f:

            # 存单个变量

            # 存多个变量

            return pickle.dump(args, f)

            """

            if k == 0:

                return pickle.dump(data, f)

            elif k == -1:

                return pickle.dump(data, f, k)

            """

 

    # 反序列化，从文件中取出来

    def unserialize(self):

        f = open(self.path, "rb")

        data = pickle.load(f)

        f.close()

        return data

 

 

if __name__ == "__main__":

    path = "data.pkl"

    p = Pick(path)

    content = p.serialize([1, 2, 3, 4, 5], "hello", 123, {"name": "张三"})

    # content2 = p.serialize(['a', 'b', 'c', 'e'])  # 每次调用这个的时候进行重新覆盖

    # print(content2)

    print(content)

 

    print(p.unserialize())

 

 

# -*- coding: utf-8 -*-

import pickle

 

fw = open("2.pkl", "wb")

a, b, c = [1, 2, 3], "hello", dict(name="张三")

pickle.dump(a, fw)

pickle.dump(b, fw)

pickle.dump(c, fw)

fw.close()

 

fr = open("2.pkl", "rb")

# an, bn, cn = pickle.load(fr), pickle.load(fr), pickle.load(fr)

while True:

    try:

        print(pickle.load(fr))

    except Exception as e:

        # print(e)

        break

fr.close()

 

# print(an, bn, cn)