random、json、pickle、hashlib、hmac、shutil、shevle模块

今日内容：

1. random 模块

2. json模块

3. pickle 模块

4.hashlib 模块

5. hmac 模块

6. shutil 模块

7. shelve 模块

1. random 模块：

random 模块  获取随机值
import random

for i in range(10):
    print(random.random())  # random.random() 随机获取0~1 之间的数字，不包括0和1，
返回的是浮点型0.5319902943759903  0.9539062824026727

随机获取指定范围内的整数值，比如1~10 范围内的整数，包含起始位和结束位
for i in range(10):
    print(random.randint(1,10))

 随机获取指定范围内的整数，比如1~10 范围内的整数，不包含结束位置
for i in range(10):
    print(random.randrange(1,10))

 随机获取指定范围内的浮点数，比如1~10 范围内的浮点数，返回类型4.793951896180604
for i in range(10):
    print(random.uniform(1,10))

random.choice  在item中取值，可以重复，取指定的range('次数')
item = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
for i in range(10):
    print(random.choice(item),end='')

如果不使用for循环，每次取一个
item = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(random.choice(item),end='')

random.sample 在item中随机取值，根据传入的数字决定每次取值的个数(此处为每次取4个)，range('次数')内放取值的次数
item = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
for i in range(10):
    print(random.sample(item,4))

打乱   将item列表打乱
item = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
random.shuffle(item)
print(item)

验证码功能
方法1：
使用chr找到数字所对应的ascii码表中的字母
def random_code(num):               # 传入验证码的位数
    code = ""
    for i in range(num):            # 循环五次，取5 次值，然后随机再下列三个条件中选择一个。
        d = random.randint(65, 90)  # 随机取值后，再在ascii码表中大写字母的位置
        x = random.randint(97, 122)  # 随机取值后，再在ascii码表中小写字母的位置
        n = random.randint(0, 9)  # 数字是原意字符，直接转str就行
        code += random.choice([chr(d), chr(x), str(n)])  # 此处做字符串拼接
    return code

res = random_code(5)
print(res)

方法2：
def random_code(num):
    code = ""
    for i in range(num):                    # 进入for循环后会随机在1~3之间取值，然后找到相对应的条件，再取值
        choose = random.randint(1,3)
        if choose == 1:
            c = chr(random.randint(65,90))  #  随机取到值后找到对应的acsii码表中的字符
        elif choose == 2:
            c = chr(random.randint(97,122)) #  随机取到值后找到对应的acsii码表中的字符
        else:
            c = str(random.randint(0,9))    # 原义字符，直接转成str做字符串拼接用
        code += c                           # 此处做字符串拼接。
    return code

res = random_code(6)
print(res)

方法3
此方法有投机取巧的嫌疑。。。
def random_code(num):
    target = '1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm'  # 把所有字母数字做成一个字符串
    code_list = random.sample(target, num)  # 然后随机抽取指定个数的字符。
    return ''.join(code_list)  # 然后使用 .join() 的方法拼接

res = random_code(5)
print(res)

2. json模块

json模块
import json

json语言，就是一种有语法规范的字符串，用来存放数据的，完成各种语言之间的数据交互
1.只能使用{}与[]的组合，{}存放双列信息(与python中的字典类似)，而[]存放单列信息(与python中的列表类似)
2.{}中的key必须是字符串，而且必须使用" " 来包裹
3.{} 与 [] 中支持的值的类型：dict ,list , int , float, bool ，null(类比python中的None), str

案例：
json_str = '{"info":1,"msg":[1,"a",true,false,null,3.14]}'
obj = json.loads(json_str)    # json.loads 反序列化，可以把字符串类型转换成它本身的类型
print(obj, type(obj))         # type()后此处obj的类型就变成了dict类型

序列化： 将对象转换成字符串
dumps :只做将对象直接序列化成字符串的工作
dump: 不止做将对象序列化成字符串，还做write()功能，将序列化之后的字符串存储到文件中
obj = {'name': 'owen', "age": 18, 'height': 180, "gender": "男"}  # 此处对象为字典类型dict
# r1 = json.dumps(obj, ensure_ascii=False)                          # 然后使用dumps() 序列化为字符串，并取消默认ascii编码，
# print(r1)

# 同该文件的编码(utf-8)，python3中默认，python2中需要规定文件头coding:utf-8
with open('1.txt','w',encoding='utf-8') as wf:                    # 然后通过'w'模式打开文件
   json.dump(obj,wf,ensure_ascii=False)                           # 通过dump()方法来写入文件.(此处dump会把对象序列化并 做write() 的功能，来写入文件中)

反序列化
loads :只做将字符串直接反序列化成对象的工作
load: 不止做将字符串序列化成对象，还做reda()功能，将反序列化之后的字符串读取出来
json_str = '{"name":"owen","age":18,"height":180,"gender":"男"}'
r2 = json.loads(json_str,encoding = 'utf-8')   # loads() 将字符串转换为它本身的类型，默认与当前文件的解释器编码一致
print(r2,type(r2))

with open('1.txt','r',encoding='utf-8')as rf:
    r3 = json.load(rf)
    print(r3,type(r3))

3. pickle 模块

pickle 模块
为什么有很多序列化和反序列模块
因为程序会出现各种各样的对象，如果要将这些对象持久化存储，必须先序列化
只有序列化存储后，必须有对应的反序列化，才能保证你存储数据能够内重新读取使用

什么是序列化？：将对象-->转换成字符串
为什么要序列化？：用来存储再次使用或者传递给别人使用
为什么有很多序列化模块？：存与取的算法可以多种多样，且要配套

 pickle序列化做的是直接转成了二进制，那么pickle的功能比json要广泛，因为json只能序列化文本文件，而pickle全部类型的文件都可以序列化
import pickle

obj = {"name": "Owen", "age": 18, "height": 180, "gender": "男"}

序列化 dumps()
r1 = pickle.dumps(obj)
print(r1)     # 此处返回的是二进制

序列化存储dump()
with open('2.txt','wb')as wf:
    pickle.dump(obj,wf)

反序列化
with open('2.txt', 'rb') as rf:
    data = rf.read()
    ol = pickle.loads(data)
    print(ol, type(ol))

序列化读取load()
with open('2.txt','rb') as rf:
    ol = pickle.load(rf)
    print(ol,type(ol))

4.hashlib 模块

hashlib模块
不可逆加密：没有解密的加密方式 md5
解密方式：碰撞解密
加密的对象：用于传输的数据（字符串类型的数据）
import hashlib
lock = hashlib.md5()

data = '变有钱'
lock.update(data.encode('utf-8'))   # 此处声明utf-8是为了告诉hashlib，此处是以utf-8编码的汉字

res = lock.hexdigest()              # 此处是将加密后的数据以16进制的格式打印出来
print(res)                          # 输入结果6bc477bd73049f77b5946f7c18449e65

如果是普通的字母或者数字，可以在字符串前加 b 来声明
data = b'qweasdzxc123'
lock.update(data)
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()
lock.update(b'')
res = lock.hexdigest()
print(res)
特点：加密的总数居一样，加密结果一样，且算法不变，加密结果长度不变

加盐加密
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()
lock_obj = hashlib.sha3_512()
使用情况很少，不一一介绍

5. 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())

6. shutil 模块

shutil 模块  #高级的 文件、文件夹、压缩包 处理模块

import shutil

基于路径的文件复制：  shutil.copyfile(a(文件路径)，b(新路径))
shutil.copyfile(r'D:\python练习\python十万行代码\学day19\2.txt', r'D:\python练习\python十万行代码\学day19\a\b.txt')

基于流(二进制)的文件赋值     # with open('目标文件'，rb)as r,open('新文件','wb')as w:
with open('day19博客.py','rb') as r,open('target_file.py','wb')as w:
    shutil.copyfileobj(r,w)

递归删除目标目录  # 必须传入绝对路径，或者是当前目录下的文件夹或者文件
shutil.rmtree(r'D:\python练习\python十万行代码\学day18\a')

文件移动   shutil.move('文件名'，'新路径+新文件名')
shutil.move('target_file.py', 'part1/new_file.py')

文件夹压缩
file_name:被压缩后形成的文件名
format: 压缩的格式
archive_path:要被压缩的文件夹路径
shutil.make_archive('file_name','format','archive_path')

案例：
shutil.make_archive('abc/my','zip','part1')

文件夹解压
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('my.shv')
shv_dic['name'] = 'Owen'
shv_dic['name'] = 'Zero'
shv_dic.close()

shv_dic = shelve.open('my.shv')
print(shv_dic['name'])
stus = ['张三', '涨姿势']
shv_dic['stus'] = stus
print(shv_dic['stus'])
shv_dic.close()

shv_dic = shelve.open('my.shv', writeback=True)
# 将内容从文件中取出，在内存中添加, 如果操作文件有writeback=True，会将内存操作记录实时同步到文件
shv_dic['stus'].append('装13')
print(shv_dic['stus'])
shv_dic.close()