random模块
""
(0, 1)：random.random()
[1, 10]：random.randint(1, 10)
[1, 10)：random.randrange(1, 10)
(1, 10)：random.uniform(1, 10)
单例集合随机选择1个：random.choice(item)
单例集合随机选择n个：random.sample(item, n)
洗牌单列集合：random.shuffle(item)
"""
import random
random.random()
for i in range(1,10):
print(random.randint(1,10))
print('============')
for i in range(0,5):
print(random.randrange (0,5))
print('=============')
# 整数
for i in range(1,10):
print(random.uniform (1,10))
# 小数
# 单例集合随机选择1个
print('=========')
a=[1,2,3,5,8,4,]
for i in range(1,10):
print(random.choice(a) )
print('=========')
# 单例集合随机选择n个
for i in range(1,10):
print(random.sample(a,2) )
print('=========')
a=[1,2,3,5,8,4,]
random.shuffle(a)
print(a)
# 验证码
# 方法1
def random_code(num):
code=""
for v in range(num):
d=random.randint(65,90)
x=random.randint(97,122)
n=random.randint(0,10)
code += random.choice([chr(d),chr(x),str(n)])
return code
a=random_code(11)
print(a)
# 方法2
def random_code(num):
code=""
for v in range(num):
choose = random.randint(1,3)
if choose == 1 :
z=chr(random.randint(65,90) )
elif choose == 2 :
z=chr(random.randint(97,122) )
else:
z=str(random.randint(0,10) )
code += z
return code
a=random_code(11)
print(a)
# 方法3
def random_code(num):
qwe='123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
code_list=random.sample(qwe,num)
return ''.join(code_list )
a=random_code(11)
print(a)
Json模块：序列化
import json
# json语言，就是一种有语法规范的字符串，用来存放数据，完成各种语言之间的数据交互
# 1.就是{}与[]的组合，{}存放双列信息(类比为字典)，[]存放单列信息(类比为列表)
# 2.{}的key必须是字符串，且必须用""包裹
# 3.{}与[]中支持的值的类型: dict | list | int | float | bool | null | str
# 转化为字符串
json_str='{"a":1,"q":["-a",7.12,true,8]}'
a=json.loads(json_str)
print(a,type(a))
# 序列化：将对象转换为字符串
# dumps：将对象直接序列化成字符串
# dump：将对象序列化成字符串存储到文件中
obj={'name': 'Owen', "age": -18, 'height': 180, "gender": "男"}
a1=json.dumps(obj,ensure_ascii=False)
print(a1)
with open('1.txt','w',encoding='utf-8') as wf:
json.dump(obj,wf,ensure_ascii= False)
# 注：字符形式操作
# 反序列化成对象：json.loads(json_str)
# 从文件读流中反序列化成对象：json.load(read_file)
json_str='{"name":"qwe","age":177,"height":188}'
a=json.loads(json_str,encoding='utf-8')
print(a,type(a))
with open('1.txt','r',encoding='utf-8') as d:
a3=json.load(d)
print(a3,type(a3))
pickle模板：序列化
# 为什么有很多序列化和反序列化模块
# 因为程序中会出现各种各样的对象，如果要将这些对象持久化存储，必须先序列化
# 只有序列化存储后，必须有对应的反序列化，才能保证存储的数据能被重新读取使用
# 什么是序列化：对象 => 字符串
# 为什么序列化：存 或 传
# 序列化成字符串：pickle.dumps(obj)
# 序列化字符串到文件中：pickle.dump(obj, write_bytes_file)
# 为什么要反序列化：再次使用
# 为什么有很多序列化模块：存与取的算法可以多种多样，且要配套
# 反序列化成对象：pickle.loads(bytes_str)
# 从文件读流中反序列化成对象：pickle.load(read_bytes_file)
import pickle
obj = {"name": 'Owen', "age": 18, "height": 180, "gender": "男"}
# 序列化
a1=pickle.dumps(obj)
print(a1)
with open('2.txt','wb')as wf:
pickle.dump(obj,wf)
# 反序列化
with open('2.txt', 'rb') as rf:
data = rf.read()
a=pickle.loads(data)
print(a,type(a))
rf.seek(0,0)
a1=pickle.load(rf)
print(a1,type(a1))
hashlib:加密
# 不可逆加密：没有解密的加密方式 md5
# 解密方式：碰撞解密
# 加密的对象：用于传输的数据（字符串类型数据）
import hashlib
cipher = hashlib.md5 ('需要加密的数据的二进制形式'.encode('utf-8'))
print(cipher.hexdigest()) # 加密结果码
import hashlib
lock=hashlib.md5()
date='你好丑'
lock.update(date.encode('utf-8'))
lock.update('你'.encode('utf-8') )
lock.update('好'.encode('utf-8') )
lock.update('丑'.encode('utf-8') )
# 特点：加密的总数据一样，加密结果一定一样，且算法不变，加密结果的长度不变
# print(cipher.hexdigest()) # 加密结果码
res = lock.hexdigest()
print(res)
# 一次加密：
# 1.获取加密对象 hashlib.md5() => lock_obj
# 2.添加加密数据 lock_obj.update(b'...') ... lock_obj.update(b'...')
# 3.获取加密结果 lock.hexdigest() => result
lock=hashlib.md5('3a3adbec86fbcfa61d1f4ba4b02a5ae7'.encode('utf-8'))
lock.update (b'123')
res=lock.hexdigest()
print(res)
# 语法
# 加盐加密
# 1.保证原数据过于简单，通过复杂的盐也可以提高解密难度
# 2.即使被碰撞解密成功，也不能直接识别盐与有效数据
cipher = hashlib.md5()
cipher.update('前盐'.encode('utf-8'))
cipher.update('需要加密的数据'.encode('utf-8'))
cipher.update('后盐'.encode('utf-8'))
print(cipher.hexdigest()) # 加密结果码
lock=hashlib.md5()
lock.update('123'.encode('utf-8'))
lock.update('qwertyuiop'.encode('utf-8'))
lock.update('123'.encode('utf-8'))
a=lock.hexdigest()
print(a)
# 其他算法
cipher = hashlib.sha3_256(b'')
print(cipher.hexdigest())
cipher = hashlib.sha3_512(b'')
print(cipher.hexdigest())
hmac模块：加密
# 加密
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())
要想保证hmac最终结果一致，必须保证：
1:hmac.new括号内指定的初始key一样
2:无论update多少次，校验的内容累加到一起是一样的内容
shutil模块:可以操作权限的处理文件模块
# shutil：可以操作权限的处理文件模块
import shutil
# 基于路径的文件复制
shutil.copyfile(r'F:\python8期\课堂内容\day19\代码\5.hmac模块.py', r'F:\python8期\课堂内容\day19\代码\part1\target_file.py')
# 基于流的文件复制
with open('soure_file','rb') as r,open('target_file','wb') as w :
shutil.copyfile(r,w)
递归删除目标目录
shutil.rmtree('qwe')
# 文件移动(旧地址，新地址，文件存在才能移动)
shutil.move('awe11','part1/new_file.py')
# 文件夹压缩
# file_name：被压缩后形成的文件名
# format：压缩的格式
# archive_path：要被压缩的文件夹路径
shutil.make_archive('file_name', 'format', 'archive_path')
shutil.make_archive('123496', 'zip', 'part1/new_file.py/awe11')
# 文件夹解压
# unpack_file：被解压文件
# unpack_name：解压后的名字
# format解压格式
shutil.unpack_archive('unpack_file', 'unpack_name', 'format')
shutil.unpack_archive('123496.zip', 'qwer22', 'zip')
Shelve
只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve
# 即时存取的序列化模块
'''
# 将序列化文件操作dump与load进行封装
s_dic = shelve.open("target_file", writeback=True)
# 注：writeback允许序列化的可变类型，可以直接修改值
# 序列化:：存
s_dic['key1'] = 'value1'
s_dic['key2'] = 'value2'
# 反序列化：取
print(s_dic['key1'])
# 文件这样的释放
s_dic.close()
'''
sh_dic=shelve.open('my.sh')
sh_dic ['name']='qwer'
sh_dic ['name']='asd'
sh_dic .close()
sh_dic=shelve.open('my.sh')
print(sh_dic['name'] )
na=['只是''知识']
sh_dic ['na']=na
print(sh_dic['na'] )
sh_dic .close()
sh_dic =shelve.open('my.sh',writeback= True)
# 将内容从文件中取出，在内存中添加,
# 如果操作文件有writeback=True，
# 会将内存操作记录实时同步到文件
sh_dic['na'].append('注释')
print(sh_dic['na'] )
sh_dic.close()
