Python脱产8期 Day019 2019/5/8

random模块

1.单例集合随机选择1个值：random.choice(item)

  #print(random.choice([1,'23',[4,5]])) # 1或者23或者[4,5]

2.单例集合随机选择n个：random.sample(item, n)

 #print(random.sample([1,'23',[4,5]],2)) #列表元素任意2个组合

3.洗牌单列集合：random.shuffle(item)

4.随机取大于等于开始数且小于等于结束数之间的整数 random.randint()

 #print(random.randint(1, 10))  # [1, 10] 整数循环取10次可能有重复的

5.随机取大于0且小于1之间的小数类型是float ，random.random()

6.随机取大于等于开始数且小于结束数之间的整数 random.randrange()

 #print(random.randrange(1, 10))  # [1, 9] 整数注意与random.randint的区别不包括结束值   注意与random.randint的区别不包括结束值

7.随机取大于开始小于结束的小数

 # random.uniform(1, 10 )# (1, 10) 小数

8.验证码功能实现

序列化

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

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

JSON（主要用于数据的传输）

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

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

# dumps：将对象直接序列化成字符串
# dump：将对象序列化成字符串存储到文件中

例：# 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 wf:
#     json.dump(obj, wf, ensure_ascii=False)

7.反序列化

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（支持所有的类型数据主要用于存，但不能与其他语言交互）

1.注意：序列换成二进制的字符串

2.序列化：

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)

3.反序列化

with open('2.txt', 'rb') as rf:
    data = rf.read()
    print(data)
    o1 = pickle.loads(data)
    print(o1, type(o1))

    rf.seek(0, 0)  # 游标移到开头出现读
    o2 = pickle.load(rf)
    print(o2, type(o2))

hashlib加密

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

# 一次加密：
# 1.获取加密对象 hashlib.md5()
# 2.添加加密数据 lock_obj.update(b'...')
# 3.获取加密结果 lock.hexdigest()

4.例：

lock = hashlib.md5()
lock.update(b'')  # d41d8cd98f00b204e9800998ecf8427e
res = lock.hexdigest()
print(res)

加盐加密
1.保证原数据过于简单，通过复杂的盐也可以提高解密难度
2.即使被碰撞解密成功，也不能直接识别盐与有效数据

3.例：

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)

注：加盐加密一般在数据的前后进行加盐，除了md5还有其他算法加密，

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

hmac加密

import hmac

cipher = hmac.new('加密的数据'.encode('utf-8'))
print(cipher.hexdigest())

cipher = hmac.new('前盐'.encode('utf-8'))
cipher.update('加密的数据'.encode('utf-8'))
print(cipher.hexdigest())

注：与hashlib加密方法使用没有太大区别，但hmac.new(arg)中必须有参数

shutil

# 1.基于路径的文件复制：
shutil.copyfile('source_file', 'target_file')

##shutil.copyfile(r'F:\python8期\课堂内容\day19\代码\5.hmac模块.py', r'F:\python8期\课堂内容\day19\代码\part1\target_file.py')
#2.基于流的文件复制：
with open('source_file', 'rb') as r, open('target_file', 'wb') as w:
shutil.copyfileobj(r, w)

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

# 文件移动
shutil.move('old_file', 'new_file')

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

# 文件夹解压
# unpack_file：被解压文件 unpack_name：解压后的名字 format解压格式
shutil.unpack_archive('unpack_file', 'unpack_name', 'format')

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

转载于:https://www.cnblogs.com/tfzz/p/10834661.html