一、序列化模块
序列化和反序列化的概念如下：
- 序列化
- 把不可传输的对象转换成可存储或可传输的过程
- 把对象信息转换成字符串或者字节串
- 反序列化
- 把磁盘等介质中的数据转换成对象
- 把字符串或者字节串返还为对象
Python中 number、str、list、tuple、dict 都可以进行序列化，其中字典是最常进行序列化的数据结构，注意集合 set 是不能进行序列化的。
json 和 pickle 模块
json模块中的序列化和反序列化的方法
| 方法 | 参数 | 描述 | 使用 | 返回值 |
|---|---|---|---|---|
| dumps() | obj | 对象序列化 | json.dumps([1,2]) | 字符串 |
| loads() | str | 反序列化 | json.loads('[1,2]') | 原始数据类型 |
pickle模块中的序列化和反序列化的方法
| 方法 | 参数 | 描述 | 使用 | 返回值 |
|---|---|---|---|---|
| dumps() | obj | 对象序列化 | json.dumps([1,2]) | byte |
| loads() | byte | 反序列化 | json.loads('[1,2]') | 原始数据类型 |
json 模块和 pickle 模块的序列化和反序列化的函数是一致的，不同的是序列化的返回值和反序列化的参数
import json
a = 1
b = 'stark'
c = ['stark', 'thor', 'banner']
d = (1, 3, 7, 11)
e = {'name': 'stark', 'address': 'NY'}
_a = json.dumps(a)
print(_a, type(_a))
print(json.loads(_a), type(json.loads(_a)))
_b = json.dumps(b)
print(_b, type(_b))
print(json.loads(_b), type(json.loads(_b)))
_c = json.dumps(c)
print(_c, type(_c))
print(json.loads(_c), type(json.loads(_c)))
_d = json.dumps(d)
print(_d, type(_d))
print(json.loads(_d), type(json.loads(_d)))
_e = json.dumps(e)
print(_e, type(_e))
print(json.loads(_e), type(json.loads(_e)))
# bool类型序列化和反序列化
print(json.dumps(True), type(json.dumps(True)))
print(json.loads(json.dumps(True)), type(json.loads(json.dumps(True))))
# None类型
print(json.dumps(None), type(json.dumps(None)))
print(json.loads(json.dumps(None)), type(json.loads(json.dumps(None))))
需要注意的是元组反序列化之后不是元组类型而变成了列表类型。
import json
set_type = {1, 3, 5}
print(type(set_type))
print(json.dumps(set_type), type(json.dumps(set_type)))
集合类型是无法进行序列化的。
使用 try-except处理异常
import json
set_type = {1, 3, 5}
print(type(set_type))
try:
json.dumps(set_type)
except TypeError as e:
print(e)
finally:
print('序列化完毕')
class、function 都无法序列化
import pickle
e = {'name': 'stark', 'address': 'NY'}
_e = pickle.dumps(e)
print(_e, type(_e))
print(pickle.loads(_e), type(pickle.loads(_e)))
pickle 模块序列化返回的是 byte 类型的数据
二、hashlib 和 base64 加密模块
Python中常用的加密模块主要有 hashlib 和 base64 两个模块
| 方法 | 参数 | 方法描述 | 使用 | 返回值 |
|---|---|---|---|---|
| md5() | byte | md5算法加密 | hashlib.md5(b'hallo') | Hash对象 |
| sha1() | byte | sha1算法加密 | hashlib.sha1(b'hallo') | Hash对象 |
| sha256() | byte | sha256算法加密 | hashlib.sha256(b'hallo') | Hash对象 |
| sha512() | byte | sha512算法加密 | hashlib.sha512(b'hallo') | Hash对象 |
数值越高，被破解的概率越低
Hash对象中包含了两个加密方法：
- hash.digest() ：返回加密字符串，作为二进制数据字符串值
- hash.hexdigest()：返回加密字符串，作为十六进制数据字符串值
import hashlib
import time
sign = 'stark'
timestamp = int(time.time())
toke = '{}{}'.format(sign, timestamp)
print(toke)
# 获取hash对象
hash_obj_md5 = hashlib.md5(toke.encode('utf-8'))
print(hash_obj_md5)
print(type(hash_obj_md5))
hash_token = hash_obj_md5.hexdigest()
print("md5加密:{}".format(hash_token))
# 获取hash对象
hash_obj_sh1 = hashlib.sha1(toke.encode('utf-8'))
print(hash_obj_sh1)
print(type(hash_obj_sh1))
hash_token = hash_obj_sh1.hexdigest()
print("sha1加密:{}".format(hash_token))
# 获取hash对象
hash_obj_sh256 = hashlib.sha256(toke.encode('utf-8'))
print(hash_obj_sh256)
print(type(hash_obj_sh256))
hash_token = hash_obj_sh256.hexdigest()
print("sha256加密:{}".format(hash_token))
# 获取hash对象
hash_obj_sh512 = hashlib.sha512(toke.encode('utf-8'))
print(hash_obj_sh512)
print(type(hash_obj_sh512))
hash_token = hash_obj_sh512.hexdigest()
print("sha512加密:{}".format(hash_token))
base64 加密模块常用的方法有：
| 函数 | 参数 | 描述 | 使用 | 返回值 |
|---|---|---|---|---|
| encodestring | Byte | 进行base64加密 | base64.encodestring('hi') | Byte |
| decodestring | Byte | 对base64解密 | base64.decodestring(b'aGVsbG8=\n') | Byte |
| encodebytes | Byte | 进行base64加密 | base64.encodebytes(b'hi') | Byte |
| decodebytes | Byte | 进行base64解密 | base64.decodebytes(b'aGVsbG8=\n') | Byte |
import base64
encode_base64 = base64.encodestring(b'hello')
print(encode_base64)
decode_base64 = base64.decodestring(b'aGVsbG8=\n')
print(decode_base64)
前两个方法从 3.1 开始就过时类，使用后面两个方法代替。
import base64
encode_base64 = base64.encodebytes(b'hello')
print(encode_base64)
decode_base64 = base64.decodebytes(b'aGVsbG8=\n')
print(decode_base64)
base64 模块是可以进行解密的，为了防止通过 base64 加密的字符串被解密，通常会进行加盐或者将密码中的某些字符使用特殊字符替换，之后再进行加密。
