一、随机数random，验证码，可以一个随机花名册，
random.random() # 返回0~1之间的小数
random.randint(1, 10) #【1， 10】随机返回一个整数，范围两端都包含
random.randrange(1, 10) #【1， 10】随机返回一个整数，会出现前，不会出现后面的数据，相当于range(), 不顾后端。
random.uniform(1, 10) # 【1，10】 返回随机一个小数，不含两端
random.choice(item) # 单例集合随机选择1个
random.sample(item, n) # 单例集合随机选择n个
random.shuffle(item) # 洗牌单列集合，返回一个打乱的单列集合
二、序列化 （dump/dumps）与 反序列化 【load / loads】
序列化：将数据转化为一种有序的格式（如：pickle的二进制，json的字符串），可以对这些数据进行存储 、读写、传输。
存储：之前可以通过文件的读写，但是只能做简单的读写（只能写字符串到文件中），如购物车中作业里，with open读到的都是字符串形式的数据，要向里面添加、修改信息，还需要转成 字典，修改后再转成字符串形式写回去。每次都这样好麻烦，pickle出现了：
1. pickle.dump 将python中数据类型（str,int,bool,set,dict,float, tuple）序列化成二进制，存储到硬盘中。存是为了后面要用，从硬盘中读进来再写.
2. pickle.load 反序列，将存储的二进制恢复成python数据格式（字典）来操作。
2.1 pickle序列化
import pickle
pickle.dumps（python数据类型）===> 参数为一个python数据类型 返回一个二进制类型
pickle.dump（python数据类型, 文件对象） ====> pickle.dump(a, open('8.txt', 'wb') )
2.11 序列化 之 dumps
obj = {"name": 'Owen', "age": 18, "height": 180, "gender": "男"}
r1 = pickle.dumps(obj) # obj为需要序列化的对象
print(r1) # 返回一个二进制 b'x80x03}qx00(Xx01x00x00x00aqx01Kx01Xx01x00x00x00bqx02Mxc8x01u.'
将序列化后的数据写进文件中：
f =open('2.txt', 'wb')
f.write(pickle.dumps(a))
f.close（）
2.12 序列化 之 dump ==> 序列化后dump帮我写。
with open('2.txt', 'wb') as wf:
pickle.dump(obj, wf)
2.2.1 反序列化 ：
pickle.loads(二进制数据格式) ==> 返回python数据格式，（需要自己把内存中的二进制数据读进来）
pickle.load(文件对象) ==> pickle.load ( open ( r 'D:day19序列json模块6.txt', 'rb' ) ) # 返回python 数据类型 （从文件中直接反序列为python数据类型）
with open('2.txt', 'rb') as rf:
data = rf.read()
o1 = pickle.loads(data)
print(o1, type(o1))
rf.seek(0, 0) # 游标移到开头出现读
o2 = pickle.load(rf)
print(o2, type(o2))
2.2、json序列化 : 以字符串的方式存放数据，完成各种语言之间的数据交互。
2.2.1 json.dumps(python数据类型) ===> 将所有python数据类型序列化为字符串形式的数据，需要自己with open 方法写进文件（可以直接写，因为序列化后是字符串）
a = [{'a':1, 'b':[1, 2, 3]}]
res_dic = json.dumps(a)
print(res_dic, type(res_dic))
with open('j1.txt', 'w', encoding='utf-8') as wf:
wf.write(res_dic)
2.2.2 json.dump(python数据类型，文件对象) ===> 序列化后并写入文件
json.dump(a, open('j2.txt', 'w', encoding='utf-8'))
2.3.1 反序列
json.loads ( json格式的字符串， encoding = 'utf-8' ) ===> 返回python格式的数据，只能吃json格式的字符串，或者自己读文件
a ='{"a": 1, "b": [1, 2, 3]}'
b = json.loads(a, encoding='utf-8')
json.loads ( 文件对象) ===> 返回python格式的数据，需要一个问问然后对像，如下例子
res2 = json.load(open('j2.txt', 'r', encoding='utf-8'))
print(res2, type(res2))
json语言，就是一种有语法规范的字符串，用来存放数据的，完成各种语言之间的数据交互
1.就是{}与【】的组合，{} 存放双列信息（类比为字典），【】存放单列信息（类比为列表）
2. {} 的key 必须是字符串，且必须用""包裹
3. {} 与 【】中支持的值的类型：dict | list | int | float |bool | null | str
序列化：将对象转换为 json 字符串 ： 对象 --- json.dunp ----> json 字符串
dumps: 将对象直接序列化成字符串：
dump: 将对象序列化成字符串存储到文件中
obj = {'name': 'Owen', "age": 18, 'height': 180, "gender": "男"}
r1 = json.dumps(obj, ensure_ascii=False) # 取消默认ascii编码，同该文件的编码 utf-8 py3默认，py2规定文件头
print(r1)
dump: 存储到文件中
with open('1.txt', 'w', encoding='utf-8') as wf:
json.dump(obj, wf, ensure_ascii=False)
反序列化：将字符串转换为对象
json_str = '{"name": "Owen", "age": 18, "height": 180, "gender": "男"}'
r2 = json.loads(json_str, encoding='utf-8') # 默认跟当前文件被解释器执行的编码走
print(r2, type(r2))
with open('1.txt', 'r', encoding='utf-8') as rf:
r3 = json.load(rf)
print(r3, type(r3))
2.3 shelve 字典的方式存取文件
shv_dic = shelve.open('目标文件名‘ ，writeback=False) ==> 参数为目标文件名，writeback默认为False, 存取不可变类型
import shelve
# shv_dic = shelve.open("target_file") # 打开一个字典式的文件
# shv_dic['key1'] = 'value1' # 以字典key的方式存数据
# shv_dic['key2'] = 'value2'
# shv_dic.close() # 关闭文件， 文件关闭后就不可以存取数据了，可以重开。
# shv_dic = shelve.open("target_file")
# print(shv_dic['key1']) ==> 通过key取到value
shv_dic = shelve.open('目标文件名' ，writeback= True) ==> 参数为目标文件名， 存取可变数据类型
shv_dic1 = shelve.open('s.txt',writeback=True)
shv_dic1['a'] = [1, 2] # 原数据
# print(shv_dic1['a']) ===> [1, 2]
shv_dic1['a'].append(['c']) #新数据
print(shv_dic1['a']) ====> [1, 2, ['c']] #原数据 + 新数据
shv_dic = shelve.open("target_file") # 注：writeback允许序列化的可变类型，可以直接修改值
序列化：存
shv_dic['key1'] = 'value1'
shv_dic['key2'] = 'value2'
文件这样的释放
shv_dic.close()
shv_dic = shelve.open("target_file", writeback=True)
# 存 可变类型值
shv_dic['info'] = ['原数据']
# 取 可变类型值，并操作可变类型
# 将内容从文件中取出，在内存中添加, 如果操作文件有writeback=True，会将内存操作记录实时同步到文件
shv_dic['info'].append('新数据')
# 反序列化：取
print(shv_dic['info']) # ['原数据', '新数据']
shv_dic.close()
三、.加 密【hashlib 、hmac】
hashlib 一个加密模块，
不可逆加密：没有解密的加密方式 常用 md5() ,也有其他的sha512, 384,只是加密出来的长度不一样
解密方式：碰撞解密
加密的对象：用于传输的数据（字符串类型数据）
import hashlib
lock = hashlib.md5() # 加密方式 ===>
lock.update('我很帅'.encode('utf-8')) # 加密 ，只能吃字符串，encode成二进制
res = lock.hexdigest()
print(res) #f3b3a84d3f3c4856918299b41efc669c
import hashlib
lock = hashlib.md5()
lock.update('我'.encode('utf-8'))
lock.update('很'.encode('utf-8'))
lock.update('帅'.encode('utf-8'))
res = lock.hexdigest()
print(res) #f3b3a84d3f3c4856918299b41efc669c
# 加盐加密
1.保证原数据过于简单，通过复杂的盐也可以提高解密难度
2.即使被碰撞解密成功，也不能直接识别盐与有效数据
lock_obj = hashlib.md5()
lock_obj.update(b'goodgoodstudy')
lock_obj.update(b'123')
lock_obj.update(b'daydayup')
res = lock_obj.hexdigest()
print(res)
lock_obj = hashlib.sha3_256(b'1')
print(lock_obj.hexdigest())
lock_obj = hashlib.sha3_512(b'1')
print(lock_obj.hexdigest())
import hmac
# hmac.new(arg) # 必须提供一个参数
cipher = hmac.new('加密的数据'.encode('utf-8'))
print(cipher.hexdigest())
cipher = hmac.new('前盐'.encode('utf-8'))
cipher.update('加密的数据'.encode('utf-8'))
print(cipher.hexdigest())
cipher = hmac.new('加密的数据'.encode('utf-8'))
cipher.update('后盐'.encode('utf-8'))
print(cipher.hexdigest())
cipher = hmac.new('前盐'.encode('utf-8'))
cipher.update('加密的数据'.encode('utf-8'))
cipher.update('后盐'.encode('utf-8'))
print(cipher.hexdigest())
shutil：
# 基于路径的文件复制：
shutil.copyfile('source_file', 'target_file')
# 基于流的文件复制：
with open('source_file', 'rb') as r, open('target_file', 'wb') as w:
shutil.copyfileobj(r, w)
# 递归删除目标目录
shutil.rmtree('target_folder')
# 文件移动
shutil.move('old_file', 'new_file')
# 文件夹压缩
# file_name：被压缩后形成的文件名 format：压缩的格式 archive_path：要被压缩的文件夹路径
shutil.make_archive('file_name', 'format', 'archive_path')
# 文件夹解压
# unpack_file：被解压文件 unpack_name：解压后的名字 format解压格式
shutil.unpack_archive('unpack_file', 'unpack_name', 'format')