Python--day19（random、json、pickle、hashlib、hmac、shutil、shevle模块）
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)
# (0, 1)：random.random()
print(random.random()) # (0,1)内的任意的浮点数
# [1, 10]：random.randint(1, 10)
print(random.randint(1,10)) # [1,10]内的任意整数
# [1, 10)：random.randrange(1, 10)
print(random.randrange(1,10)) # [1,10)内的任意整数
# (1, 10)：random.uniform(1, 10)
print(random.uniform(1,10)) # (1,10) 内的任意浮点数
# 单例集合随机选择1个：random.choice(item)
print(random.choice(['a','b','c',1,2,3])) # 单例集合随机选择1个
# 单例集合随机选择n个：random.sample(item, n)
print(random.sample((1,2,5,4,3),3)) # [3, 1, 4] 单例集合随机选择n个
# 洗牌单列集合：random.shuffle(item)
res = ['a','b','c',1,2,3]
random.shuffle(res)
print(res) # [3, 'a', 'c', 2, 1, 'b'] 重新打乱原单列集合、
SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。
# 生成随机验证码
# 方法一
import random
def random_code(num):
code = ""
for i in range(num):
d = random.randint(65,90)
x = random.randint(97,122)
n = random.randint(0,9)
code += random.choice([chr(d),chr(x),str(n)])
return code
# 方法二
def random_code1(num):
code = ""
for i in range(num):
choose = random.randint(1,3)
if choose == 1:
c = chr(random.randint(65,90))
if choose == 2:
c = chr(random.randint(97,122))
else:
c = str(random.randint(0,9))
code += c
return code
# 方法三
def random_code2(num):
target = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
code_list = random.sample(target,num)
return ''.join(code_list)
2. json：序列化（传数据方便）
2.1 json语言
就是一种有语法规范的字符串，用来存放数据的，完成各种语言之间的数据交互
1. 就是{}与[]的组合，{}存放双列信息（类比为字典），[]存放为单列信息（类比为列表）
2. {}的key必须是字符串，且必须为 " " 包裹
3. {}与[]中支持的，类型：dict、list、int、float、bool、null、str
2.2 序列化与反序列化
为什么会有很多序列化和反序列化模块？
因为程序中会出现各种的对象，如果要将这些对象持久化存储，必须先序列化
只有序列化存储后，必须有对应的反序列化，才能保证存储的数据能被重新读取和使用
2.2.1 序列化:将对象转化为字符串
方法：dump，dumps
dump：将对象直接修恶化为字符串存储到文件中
dumps：将对象直接系列化为字符串
import json
obj = {'name': 'Owen', "age": 18, 'height': 180, "gender": "男"}
r1 = json.dumps(obj, ensure_ascii=False) # 取消默认ascii编码，同该文件的编码utf-8 py3默认，py2规定文件头
print(r1) # {"name": "Owen", "age": 18, "height": 180, "gender": "男"}
with open('1.txt','w',encoding='utf-8') as f:
json.dump(obj, f, ensure_ascii = False) # 在当前目录生成文件 1.txt，文件内容同上
2.2.2 反序列化：将字符串转换为对象
方法：load，loads
import json
json_str = '{"name": "Owen", "age": 18, "height": 180, "gender": "男"}'
r2 = json.loads(json_str) # 默认跟当前文件被解释器执行的编码走 encoding = 'utf-8'有没有都行
print(r2,type(r2)) # {'name': 'Owen', 'age': 18, 'height': 180, 'gender': '男'} <class 'dict'>
with open('1.txt','r',encoding = 'utf-8') as f:
r3 = json.load(f)
print(r3,type(r3)) # {'name': 'Owen', 'age': 18, 'height': 180, 'gender': '男'} <class 'dict'>
3. pickle：序列化（存数据方便）
方法：dump，dumps
dump：将对象直接修恶化为字符串存储到文件中
dumps：将对象直接系列化为字符串
import pickle
obj = {"name": 'Owen', "age": 18, "height": 180, "gender": "男"}
# 序列化
r1 = pickle.dumps(obj)
print(r1) # b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Owenq\.....
with open('2.txt','wb') as f:
pickle.dump(obj,f)
# 反序列化
r2 = pickle.loads(b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Owenq\...
print(r2) # {'name': 'Owen', 'age': 18, 'height': 180, 'gender': '男'}
with open('2.txt','rb') as f:
# data = f.read()
obj = pickle.load(f)
print(obj,type(obj)) # {'name': 'Owen', 'age': 18, 'height': 180, 'gender': '男'} <class 'dict'>
4. hashlib 加密
hash是什么？hash是一种算法，用于将任意长度的数据，压缩映射到一段固定长度的字符串
hash的特点:
1. 输入数据不同，得到的hash值不同，所以每一个数据会对应一个hash值
2. 不能通过hash值能返回解密得到输入的值，是不可逆加密：没有解密的方式
3. 如果算法相同，无论输入的数据长度多少，得到的hash的值长度相同
4. 解密方式：碰撞解密
import hashlib
lock = hashlib.md5()
# data = 'hello world'
# lock.update(data.encode('utf-8')) = lock.update(b'hello world')# encode是因为只能识别二进制码，所以要编码
# print(lock.hexdigest()) # 5eb63bbbe01eeed093cb22bb8f5acdc3
lock.update('hello'.encode('utf-8'))
lock.update(' '.encode('utf-8'))
lock.update('world'.encode('utf-8'))
print(lock.hexdigest()) # 5eb63bbbe01eeed093cb22bb8f5acdc3
特点：加密的总数据一样，加密结果一定一样，且算法不变，加密结果的长度不变
一次加密：
1. 获得加密对象 hashlib.md5() =>lock_obj
2. 添加加密数据 lock_obj.update(b'...') ... lock_obj.update(b'...')
3. 获取加密结果 lock.hexdigest() => result
lock = hashlib.md5()
lock.update(b' ')
print(lock.hexdigest())
加盐加密
1. 保证原数据过于简单，通过复杂的盐可以提高解密难度
2. 即使被碰撞解密成功，也不能直接识别盐与有效数据
lock_obj = hashlib.md5()
lock_obj.update(b'goodgoodstudy')
lock_obj.update(b'123')
lock_obj.update(b'daydayup')
print(lock_obj.hexdigest())
5. hmac 加密
import hmac
# hmac.new(arg) # 必须提供一个数据
# cipher = hmac.new('前盐'.encode('utf-8'))
# cipher.update('加密的数据'.encode('utf-8'))
# cipher.update('后盐'.encode('utf-8'))
# print(cipher.hexdigest())
6. shutil模块 可以操作的处理文件模块更方便
# shutil 模块 可以操作权限的处理文件模块
import shutil
# 基于路径的文件复制(绝对路径) shutil.copyfile(A,B) ===>>> 将A文件内容复制到B文件中，
# shutil.copyfile(r'D:\practice\day19\1.txt',r'D:\practice\day19\123\123.py')
# 基于流的文件复制：（相对路径）
# with open('1.txt','rb') as rf, open(r'123\abc.txt','wb') as wf:
# shutil.copyfileobj(rf,wf)
# 递归删除目标目录 删除整个文件夹包括里面的子文件夹或者子文件
# shutil.rmtree('123456')
# 文件移动 shutil(A,B)将文件A移动到文件B内，若B是文件夹，则会在文件夹下生成复制的文件
# shutil.move('1.txt','123/abc')
# 文件夹压缩
# file_name：被压缩后形成的文件名
# format：压缩的格式
# archive_path：要被压缩的文件夹路径
# shutil.make_archive('file_name', 'format', 'archive_path')
# shutil.make_archive('abc/my', 'zip','123')
# 文件夹解压
# unpack_file：被解压文件 unpack_name：解压后的名字 format解压格式
# shutil.unpack_archive('unpack_file', 'unpack_name', 'format')
# shutil.unpack_archive('abc/my.zip', 'abc/part2', 'zip')
7. shelve模块 即存即取的序列化模块
# shelve模块 采用字典存储
import shelve
shv_dic = shelve.open('2.txt') # 会生成几个2.txt.乱七八糟的文件，不用管
shv_dic['name'] = 'wangyong'
shv_dic['name'] = '123'
print(shv_dic) # 123 默认key已知
shv_dic.close()
shv_dic = shelve.open('2.txt') # 重新打开是因为上一步关闭了文件，否则打不开文件内容会报错
print(shv_dic['name']) # 123
stus = ['abc','qwe']
shv_dic['stus'] = stus
print(shv_dic['stus']) # ['abc', 'qwe']
shv_dic.close()
shv_dic = shelve.open('2.txt',writeback=True) # writeback=True 是为了将即时写的数据从内存同步到硬盘
shv_dic['stus'].append('852')
print(shv_dic['stus']) # ['abc', 'qwe', '852']
shv_dic.close()
更多精彩
