Python常用模块

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 arget_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()