一、随机数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'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02M\xc8\x01u.'
将序列化后的数据写进文件中:
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')