序列化与反序列化的本质

1. 将对象存储到本地

假如有一个student类，我们定义了好几个对象，想要把这些对象存储下来，该怎么办呢

from typing import List
class Phone:
    def __init__(self, name: str, time: str):
        self.name = name
        self.time = time
class Student:
    def __init__(self, name: str, age: int, phones: List[Phone]):
        self.name = name
        self.age = age
        self.phones = phones
s1 = Student("xiaoming",10,[Phone("xiaomi","2012"),Phone("huawei","2024")])

一个极其简单的想法是把这个对象的字段和值变成str，然后转成字符串存储下来，读取这个字符串后按照我们的约定再反解析出来每个字段

from typing import List
import ast

class Phone:
    def __init__(self, name: str=None, time: str=None):
        self.name = name
        self.time = time
    
    def SerializeToString(self):
        to_dict = {'name':self.name, 'time':self.time}
        return str(to_dict)
    
    def ParseFromString(self, value):
        to_dict = ast.literal_eval(value)
        self.name = to_dict['name']
        self.time = to_dict['time']


class Student:
    def __init__(self, name: str=None, age: int=None, phones: List[Phone]=None):
        self.name = name
        self.age = age
        self.phones = phones
    
    def SerializeToString(self):
        phones_str = []
        for phone in self.phones:
            phones_str.append(phone.SerializeToString())

        to_dict = {'name':self.name, 'age':self.age, 'phones': '\x01'.join(phones_str)}
        return str(to_dict)
    
    def ParseFromString(self, value):
        to_dict = ast.literal_eval(value)
        self.name = to_dict['name']
        self.age = to_dict['age']
        phones_str = to_dict['phones']
        phones = []
        for phone_str in phones_str.split('\x01'):
            phone = Phone()
            phone.ParseFromString(phone_str)
            phones.append(phone)
        self.phones = phones

student = Student("xiaoming",10,[Phone("xiaomi","2012"),Phone("huawei","2024")])

with open('s.txt','w') as f:
    res = f.write(student.SerializeToString())

new_student = Student()

with open('s.txt','r') as f:
    new_student.ParseFromString(f.read())

print(new_student.name, new_student.age)

这样我们就又可以得到这个对象了。

存储数据的过程就是序列化，解析数据的过程就是反序列化

2. json序列化

回过头来，我们把对象转换成字符串存储到了本地，也可以根据存储的规则反推出原来的对象，这个过程称之为序列化和反序列化，用逗号分隔的格式一般称为csv。更多会使用json格式来进行序列化。

from typing import List
import json

class Phone:
    def __init__(self, name: str=None, time: str=None):
        self.name = name
        self.time = time

class Student:
    def __init__(self, name: str=None, age: int=None, phones: List[Phone]=None):
        self.name = name
        self.age = age
        self.phones = phones

student = Student("xiaoming",10,[Phone("xiaomi","2012"),Phone("huawei","2024")])

student_json = json.dumps(student, default=lambda obj: obj.__dict__)
print(student_json)

new_student = Student()
new_student.__dict__ = json.loads(student_json)
print(new_student.name, new_student.age)

3. proto序列化

protobuf本质就是一个【数据结构】，例如下面定义一个student的pb文件

syntax = "proto2";
package tutorial;

message Phone{
  optional string name = 1;
  optional string time = 2;	
}

message Student {
  optional string name = 1;
  optional int32 age = 2;
  repeated Phone phones = 3;
}

message可以认为就是class，repeated其实就是list
同样

1. 将原始对象转成pb格式的对象
2. 使用seriral序列化函数转换成字符串，并写入到本地

2. proto生成相应的类

proto文件最终通过proto会生产相应的类文件，如果是c++的话就是student.pb.cc和student.pb.h。

protoc --proto_path=. --cpp_out=. ./student.proto

如果是python则是student_pb2.py。

protoc --proto_path=. --python_out=. ./student.proto

proto_path是搜索proto的路径，而cpp_out是生产.cc和.h的路径，最后则是我们的proto路径。在这里的相对路径是相对于protoc执行的路径而言的，哪里执行命令，哪里就是工作路径。
例如proto文件存储在/a/b/test/addressbook.proto，执行protoc的路径是/c/d，此时proto_path和cpp_out使用的相对路径都是相对于/c/d而言的。

4. 字符串编码

我们把对象转换成字符串存到了本地文件中，并且可以打开这个文件看到我们的字符串。一切好像都很自然。其实中间存在了一个小gap，我们知道计算机只认识二进制，为啥存储的时候没有变成bytes，反而可以是字符串呢？我们把open函数补全一点儿

with open('s1.txt','w',encoding='utf-8') as f:
	f.write(res)

可以看到多了一个encoding的参数，就是使用utf-8的方式把这段字符串编码成二进制数据。

计算机只认识二进制，要想传输一个对象，必须将其转换成二进制格式。英文有26个字符，还有一些常用的符号，一个想当然的方法就是让每个字符对应一个数字，这就是ASCII码表，例如

二进制	十进制	十六进制	图形
0010 0000	32	20	（空格）(␠)
0010 0001	33	21	!
0100 0001	65	41	A
0110 0001	97	61	a

英文是解决了，中文呢？日文呢？俄文呢？为了把所有的文本统一，搞出了一个unicode码本，每个文本都对应了一个二进制。unicode使用4个字节表示一个字符，这对于英文来说就非常的浪费内存，英国人跟英国人交流基本都是英文，他们浏览网站看到的也基本是英文，同样对于中文来说也一样。所以就提出了utf-8的【编码方式】，utf-8是一种变长编码方式，对于英文来说只需要一个字节就可以了，中文只需要3个字节。

这里需要注意的是，utf-8是一种unicode的编码方式，打个比方，每个人的手机号都是11位的，但是如果你办了亲情网，只需要3位就可以标识自己的老公，老婆，父母了。11位的手机号相当于unicode，可以表示全国所有的人，而亲情网则可以认为是utf-8编码，得到的那3位就是utf-8编码后的号码。

• 通过unicode码本可以把字符映射成unicode二进制
• 通过utf-8编码，可以把unicode二进制转换成更短的二进制

我就想，为啥不直接使用utf-8作为码本呢

所以不要觉得是我们把字符串写到本地了，其实这个字符串通过utf-8编码已经变成二进制存储到本地了。
也不要觉得我们直接打开的是字符串，其实通过notepad打开的是二进制，只不过notepad给我们使用utf-8解码了。将这个二进制重新映射成了unicode，通过unicode找到对应的字符给我们显示了出来。

编码转换

使用统一的unicode编码后，每个人看到的就不会是乱码了，俄文日文都可以在我们的电脑上正确的展示出来了。utf-8需要3个字节表示一个中文，但其实只需要2个字节就可以了，utf-8对中文而言也是有点浪费了，所以提出了gbk编码，只需要2个字节来表示中文。引文只是对中文进行编码，如果想要显示俄文那么就会是乱码。
我们请求网页的时候都会告知这个网页的编码方式，一般都是utf-8的，这样兼容性很好，任意字符都可以显示，也有gbk编码的。

如果一个文本使用utf-8编码，使用gbk格式打开就会乱码，同样，如果使用gbk编码，使用utf-8就会乱码。我们可以先使用对应的编码方式打开，这样得到其实就是unicode码，然后再使用想要的编码方式去保存。

这么说来的话，unicode算是一种事实标准了