阅读目录

　　　　random模块

SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

　　　　json和pickle模块

　　　　hashlib模块

　　　　hmac模块

　　　　shutil模块

　　　　shelve模块

　　##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 # for i in range(10): # print(random.random())

# for i in range(10): # print(random.randint(1, 10)) # [1, 10] 整数

# for i in range(10): # print(random.randrange(1, 10)) # [1, 9] 整数

# for i in range(10): # print(random.uniform(1, 10)) # (1, 10) 小数

# item = [1, 2, 3, 4, 5] # for i in range(10): # print(random.choice(item)) # for i in range(10): # print(random.sample(item, 3))

# 打乱 # random.shuffle(item) # print(item)


# 外部提供一个数字n，随机生成n位验证码

def random_code0(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)) elif 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) r1 = random_code2(18) print(r1)

 

　　##json和pickle模块

 

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

# 什么是序列化：对象 => 字符串 # 为什么序列化：存 或 传 # 为什么要反序列化：再次使用 # 为什么有很多序列化模块：存与取的算法可以多种多样，且要配套

#这是用于序列化的两个模块：
• json: 用于字符串和python数据类型间进行转换，用于传输 • pickle： 用于python特有的类型和python的数据类型间进行转换 Json模块提供了四个功能：dumps、dump、loads、load pickle模块提供了四个功能：dumps、dump、loads、load #那pickle和json有什么区别呢？

#1、json是可以在不同语言之间交换数据的，而pickle只在python之间使用。 #2、json只能序列化最基本的数据类型，而pickle可以序列化所有的数据类型，包括类，函数都可以序列
#json模块用法# json语言，就是一种有语法规范的字符串，是一种轻量级的数据交换格式，

# 1.就是{}与[]的组合，{}存放双列信息(类比为字典)，[]存放单列信息(类比为列表)

# 2.{}的key必须是字符串，且必须用""包裹
# 3.{}与[]中支持的值的类型: dict | list | int | float | bool | null | str # 序列化：将对象转换为字符串 # dumps：将对象直接序列化成字符串 # dump：将对象序列化成字符串存储到文件中 obj = {'name': 'Owen', "age": 18, 'height': 180, "gender": "男"} r1 = json.dumps(obj, ensure_ascii=False) # 取消默认ascii编码，同该文件的编码 utf-8 py3默认，py2规定文件头 print(r1) 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))

#pickle：以二进制进行序列化
# json语言，就是一种有语法规范的字符串，用来存放数据的，完成各种语言之间的数据交互
# 1.就是{}与[]的组合，{}存放双列信息(类比为字典)，[]存放单列信息(类比为列表)
# 2.{}的key必须是字符串，且必须用""包裹
# 3.{}与[]中支持的值的类型: dict | list | int | float | bool | null | str
# 序列化：将对象转换为字符串
# dumps：将对象直接序列化成字符串
# dump：将对象序列化成字符串存储到文件中
obj = {'name': 'Owen', "age": 18, 'height': 180, "gender": "男"}
r1 = json.dumps(obj, ensure_ascii=False)  # 取消默认ascii编码，同该文件的编码 utf-8 py3默认，py2规定文件头
print(r1) 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))

 　　##hashlib模块

# 1、什么叫hash:hash是一种算法（3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），
该算法接受传入的内容，经过运算得到一串hash值 # 2、hash值的特点是： #2.1 只要传入的内容一样，得到的hash值必然一样=====>要用明文传输密码文件完整性校验 #2.2 不能由hash值返解成内容=======》把密码做成hash值，不应该在网络传输明文密码 #2.3 只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的

# 不可逆加密：没有解密的加密方式 md5 # 解密方式：碰撞解密 # 加密的对象：用于传输的数据（字符串类型数据）

# 一次加密： # 1.获取加密对象 hashlib.md5() => lock_obj # 2.添加加密数据 lock_obj.update(b'...') ... lock_obj.update(b'...') # 3.获取加密结果 lock.hexdigest() => result
 lock = hashlib.md5(b'...')#二进制
lock.update(b'...') # ...
lock.update(b'...') res = lock.hexdigest() print(res)
import hashlib
lock = hashlib.md5() 
  # 195eaff9c88bceae9f094f5ef322e5da 

# data = '你好帅' 

# lock.update(data.encode('utf-8'))  

  # 195eaff9c88bceae9f094f5ef322e5da 

lock.update('你'.encode('utf-8')) 

lock.update('好'.encode('utf-8')) 

lock.update('帅'.encode('utf-8'))  

  res = lock.hexdigest() 

print(res) 

      

#import hashlib
 #m=hashlib.md5()# m=hashlib.sha256() 
 #m.update('hello'.encode('utf8'))
 # print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592
 # m.update('alvin'.encode('utf8'))
  
#print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
  
# m2=hashlib.md5() # m2.update('helloalvin'.encode('utf8')) # print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

#注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样 #18 但是update多次为校验大文件提供了可能。

# 加盐加密 # 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())
  

 　　##hmac模块
  

 #hmac 模块它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:要想保证hmac最终结果一致，必须保证： #1:hmac.new括号内指定的初始key一样 #2:无论update多少次，校验的内容累加到一起是一样的内容

import hmac h1=hmac.new(b'egon')#以字节
h1.update(b'hello') h1.update(b'world') print(h1.hexdigest()) h2=hmac.new(b'egon') h2.update(b'helloworld') print(h2.hexdigest()) h3=hmac.new(b'egonhelloworld') print(h3.hexdigest()) ''' f1bf38d054691688f89dcd34ac3c27f2 f1bf38d054691688f89dcd34ac3c27f2 bcca84edd9eeb86f30539922b28f3981 '''
#以字符
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：可以操作权限的处理文件模块
import shutil # 基于路径的文件复制： #shutil.copyfile('source_file', 'target_file') #示例
shutil.copyfile(r'F:\python8期\课堂内容\day19\代码\5.hmac模块.py', r'F:\python8期\课堂内容\day19\代码\part1\target_file.py') # 基于流的文件复制： #with open('source_file', 'rb') as r, open('target_file', 'wb') as w: # shutil.copyfileobj(r, w) #示例 # with open('5.hmac模块.py', 'rb') as r, open('target_file.py', 'wb') as w: # shutil.copyfileobj(r, w)

# 递归删除目标目录： #shutil.rmtree('target_folder') # shutil.rmtree('abc')

# 文件移动 #shutil.move('old_file', 'new_file') # 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')
  

　　##shelve模块
  

#shelve 可以用字典存取数据到文件的序列化模块 # 即时存取的序列化模块

# 将序列化文件操作dump与load进行封装
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() #示例
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('王五') print(shv_dic['stus']) shv_dic.close()

#writeback方式有优点也有缺点
优点是减少了我们出错的概率，且让对象的持久化对用户更加的透明了； 
但这种方式并不是所有的情况下都需要， 
首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗， 
并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。 
因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。

  

 

    

        

            

                

                    

                        
                    

                    

                        

                            扫码关注我们
                        

                        

                            微信号：SRE实战
                        

                        

                            拒绝背锅 运筹帷幄