day19

day19

 

 

random模块

"""

(0, 1)：random.random()                                     0-1之间的小数

[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):                                         0-1之间的小数

#     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))    随机取n个

 

# 打乱

# random.shuffle(item)               把列表里面数据的顺序打乱

# print(item)

 

 

# 验证码

 

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模块

 

import json

 

# json语言，就是一种有语法规范的字符串，用来存放数据的，完成各种语言之间的数据交互

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

# 2.{}的key必须是字符串，且必须用""包裹

# 3.{}与[]中支持的值的类型: dict | list | int | float | bool | null | str

 

###############引号里面必须是同一个类型的

 

 

json_str = '{"info": 1, "msg": [1, "a", true, false, null, 3.14]}'                        load是     json转换为python里   ————反序列化

obj = json.loads(json_str)

print(obj, type(obj))

 

 

# 序列化：将对象转换为字符串

# dumps：将对象直接序列化成字符串                             

# dump：将对象序列化成字符串存储到文件中                      #####################是吧python里的语言转换为json的语言----序列化

# 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模块

 

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

 

s = str(obj)

print(s, type(s))

o = eval(s)

print(o, type(o))

 

# 为什么有很多序列化和反序列化模块？？

#             因为程序中会出现各种各样的对象，如果要将这些对象持久化存储，必须先序列化

#             只有序列化存储后，必须有对应的反序列化，才能保证存储的数据能被重新读取使用

 

# 什么是序列化：对象 => 字符串

# 为什么序列化：存 或 传

# 为什么要反序列化：再次使用

# 为什么有很多序列化模块：存与取的算法可以多种多样，且要配套

 

import pickle

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

# 序列化        序列化成二进制。支持所有类型，字节形式的操作

r1 = pickle.dumps(obj)

print(r1)

 

 

 

把图片变成字符串存储------就是序列化

 

 

 

 

with open('2.txt', 'wb') as wf:

    pickle.dump(obj, wf)

 

# 反序列化

with open('2.txt', 'rb') as rf:

    data = rf.read()

    o1 = pickle.loads(data)

    print(o1, type(o1))

 

    rf.seek(0, 0)  # 游标移到开头出现读

    o2 = pickle.load(rf)

    print(o2, type(o2))

 

 

 

 

 

 

hashlib模块

 

# 不可逆加密：没有解密的加密方式 md5

# 解密方式：碰撞解密

# 加密的对象：用于传输的数据（字符串类型数据）

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)

 

# 一次加密：

# 1.获取加密对象  hashlib.md5() => lock_obj

# 2.添加加密数据  lock_obj.update(b'...') ... lock_obj.update(b'...')

# 3.获取加密结果  lock.hexdigest() => result

lock = hashlib.md5()

lock.update(b'')  # d41d8cd98f00b204e9800998ecf8427e

res = lock.hexdigest()

print(res)

 

# d41d8cd98f00b204e9800998ecf8427e

# 特点：加密的总数据一样，加密结果一定一样，且算法不变，加密结果的长度不变

 

# 加盐加密

# 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)

# goodgoodstudy123daydayup

 

 

lock_obj = hashlib.sha3_256(b'1')

print(lock_obj.hexdigest())

lock_obj = hashlib.sha3_512(b'1')

print(lock_obj.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())

 

 

 

 

 

 

 

shutil模块

 

# shutil：可以操作权限的处理文件模块

import shutil

 

# 基于路径的文件复制：

shutil.copyfile(r'F:\python8期\课堂内容\day19\代码\5.hmac模块.py', r'F:\python8期\课堂内容\day19\代码\part1\target_file.py')

 

# 基于流的文件复制：             ##################是完成任意格式文件的复制， 二进制流

# with open('5.hmac模块.py', 'rb') as r, open('target_file.py', 'wb') as w:

#     shutil.copyfileobj(r, w)

 

# 递归删除目标目录

# shutil.rmtree('abc')

 

# 文件移动

# 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模块

 

# 即时存取的序列化模块

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