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
同样
- 将原始对象转成pb格式的对象
- 使用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算是一种事实标准了