本文介绍了Python中的一些常用模块，包括random模块的随机数生成，如random.random()、randint等；logging模块的成员组成及在项目中的配置应用；re模块的正则表达式基本语法；以及加密相关的hashlib和hmac模块。同时提到了序列化模块如json和pickle，以及shutil模块的文件操作。
常用模块目录
序列化模块
加密模块
random模块
(0, 1)：random.random()
# (0, 1)之间的小数
In [2]: random.random()
Out[2]: 0.14764601161971802
[1, 10]：random.randint(1, 10)
#底层调用randrange(start, end + 1) 取值范围[1, 10]
In [7]: random.randint(1,10)
Out[7]: 8
[1, 10)：random.randrange(1, 10)
#取值范围[1, 10)
In [8]: random.randrange(1,10)
Out[8]: 9
(1, 10)：random.uniform(1, 10)
import random
for i in range(10):
print('%.2f' % random.uniform(1, 10)) # 小数：(1, 10) #保留两位小数
单例集合随机选择1个：random.choice(item)
单例集合随机选择n个：random.sample(item, n)
洗牌单列集合：random.shuffle(item)
import random
ls = [1, 2, 3, 4, 5]
print(random.shuffle(ls)) #洗牌 无返回值
print(ls) #[5, 1, 4, 3, 2]
print(random.choice(ls)) #随机取一个值
print(random.sample(ls, 3)) #随机取3个值，但不重复 [5, 4, 1]
生成验证码示例：
def get_code(count):
code = ""
# 能产生大小写字母与数字
# 进行字符串拼接
for i in range(count):
r = random.choice([1, 2, 3])
if r == 1:
c = chr(random.randint(65, 90))
elif r == 2:
c = chr(random.randint(97, 122))
else:
c = str(random.randint(0, 9))
code += c
return code
print(get_code(18))
序列化模块
# 什么是序列化：将对象转化为字符串
# 什么是反序列化：将字符串转化为对象
# 为什么要序列化：数据的存储和传输都采用的是字符串类型
# 序列化的模块：json pickle shelve
# json：支持跨语言，用于数据的传输
# pickle：支持py的所有数据类型，所有可以将所有py的对象序列化后存储
# shelve：支持py的所有数据类型，可以即时存于取
# 序列化
dump
dumps
# 反序列化
load
loads
json模块: 用于传输（多语言支持）
#什么是json：就是完成文本序列化得到的文本字符串，json字符串具有一定的语法规范
1.支持的数据类型：int float str bool dict list null
2.复杂的json都是由{}与[]嵌套形成的数据
3.json字符串只能有一个根: json_str = '{}{}' | '{}[]' | '[][]' | '1null' # 报错，都是两个根
4.json中的str类型必须用""包裹(json字符串中的字符串类型不支持'' """""")
# python对象 序列化 json字符串
data = None
res = json.dumps(data)
print(res) #结果null
# json字符串 反序列化 python对象
# 基本不用关心json的存储格式
json_str = '3.14'
json_str = 'true'
json_str = 'null'
json_str = '{}'
json_str = '[]'
json_str = '1, null' # 有误，两个根
# str类型，json只支持""
json_str = "\"abc\""
json_str = '"abc"'
obj = json.loads(json_str)
print(obj, type(obj))
json操作文件
obj = {'name': 'Owen', 'age': 17, 'gender': '男'}
with open('a.txt', 'w', encoding='utf-8') as wf:
json.dump(obj, wf, ensure_ascii=False) #默认为true，false使用utf8编码
# json.dump(obj, wf, ensure_ascii=False)
# wf.write('123')
# wf.write('456')
# 反序列化
with open('a.txt', 'r', encoding='utf-8') as rf:
obj = json.load(rf)
print(obj)
print(json.load(open('a.txt', 'r', encoding='utf-8')))
# 注：json模块的序列化与反序列化是一一对应关系
pickle模块：支持所有数据类型
import pickle
# 序列化
obj = {'name': 'Owen', 'age': 17, 'gender': '男'}
res = pickle.dumps(obj)
print(res)
pickle.dump(obj, open('b.txt', 'wb'))
# 反序列化
print(pickle.loads(res))
print(pickle.load(open('b.txt', 'rb')))
shelve模块：支持所有数据类型，即时存取
import shelve
shv_tool = shelve.open('c.shv')
# 序列化
shv_tool['name'] = 'Owen'
# 反序列化
res = shv_tool['name']
print(res)
# 文件通过shelve对象来关闭
shv_tool.close()
# writeback将反序列化到内存的数据，操作后即时同步到文件中
with shelve.open('c.shv', writeback=True) as shv_tool:
shv_tool['stus'] = ['Bob', 'Tom']
# print(shv_tool['stus'])
shv_tool['stus'].append('Jobs')
print(shv_tool['stus'])
shutil模块：可以操作权限的处理文件模块
# 基于路径的文件复制：
shutil.copyfile('source_file', 'target_file')
# 基于流的文件复制：
with open('source_file', 'rb') as r, open('target_file', 'wb') as w:
shutil.copyfileobj(r, w)
# 递归删除目标目录
shutil.rmtree('target_folder')
# 文件移动
shutil.move('old_file', 'new_file')
# 文件夹压缩
# package_file_name: 压缩后得到的文件名 format：压缩格式 archive_path：要压缩的文件夹路径
shutil.make_archive('package_file_name', 'format', 'archive_path')
# 文件夹解压
# package_file: 需要解压的文件 unpack_name：解压得到的文件夹名 format：解压格式
shutil.unpack_archive('package_file', 'unpack_name', 'format')
加密模块
# 加盐
# 什么是加盐：在原数据前或后添加一些预定的数据，与原数据一起进行加密
# 为什么要加盐：
# 1.当原数据过于简单，可以对其加盐，提高数据的复杂度
# 2.盐与数据有一定相似度，混淆对真实数据的提取
hashlib模块
import hashlib
lock_obj = hashlib.md5() # 生产锁对象可以添加数据参数也可以省略
lock_obj.update(b'before_salt')
lock_obj.update('要被加密的数据'.encode('utf-8'))
lock_obj.update(b'after_salt')
print(lock_obj.hexdigest())
# 注：要为新数据提供加密，一定要为该数据创建一个加密对象
# 其他算法
lock_obj = hashlib.sha3_256(b'123')
print(lock_obj.hexdigest())
lock_obj = hashlib.sha3_512(b'123')
lock_obj.update(b'salt')
print(lock_obj.hexdigest())
hmac模块
import hmac
# 与hashlib的不同点：hmac模块实现了hmac算法，需要一个key来进行加密
lock_obj = hmac.new(b'key')
lock_obj.update(b'salt')
lock_obj.update(b'content')
print(lock_obj.hexdigest())
logging模块
import logging
import sys
# 2.日志的基本配置
logging.basicConfig(
# 输出级别
# level=logging.INFO,
level=10,
# 输出位置
stream=sys.stderr, # sys.stdout 往控制台输出
# filename='log/my.log', # 往文件输出 => 如果需要同时往多个位置输出，需要handles
# 输出格式
format='%(asctime)s: %(msg)s',
datefmt='%H:%M:%S'
)
# 1.五大级别
logging.debug('debug msg')
logging.info('info msg')
logging.warning('warning msg')
# logging.warn('warning msg') # 弃用
logging.error('error msg')
logging.critical('critical msg')
logging.fatal('critical msg') # 同critical
logging的成员组成
import logging
# 1.打印者：自定义的打印者如何配置
log1 = logging.getLogger('logger name')
# 2.输出位置：两个文件输出位置与一个控制台输出位置
hd_a = logging.FileHandler('log/a.log', encoding='utf-8')
hd_cmd = logging.StreamHandler()
# 3.输出格式
fmt1 = logging.Formatter('%(asctime)s 【%(name)s】- %(msg)s')
fmt2 = logging.Formatter('%(asctime)s - %(msg)s')
# 4.打印者添加句柄 - 设置打印者的输出位置
log1.addHandler(hd_a)
log1.addHandler(hd_cmd)
# 5.将格式绑定给输出位置(句柄)
hd_a.setFormatter(fmt1)
hd_cmd.setFormatter(fmt2)
# 6.权限控制
log1.setLevel(logging.DEBUG) # 打印者规定打印级别
hd_a.setLevel(logging.WARNING) # 不同输出位置(句柄)再可以二次限定输出级别
hd_cmd.setLevel(logging.DEBUG) # 不同输出位置(句柄)再可以二次限定输出级别
# 7.不同级别输出信息
log1.debug('debug msg')
log1.info('info msg')
log1.warning('warning msg')
log1.error('error msg')
log1.critical('critical msg')
logging配置文件的项目应用
# 1.将打印者，句柄，与格式封装成配置信息
# 2.加载配置信息
# 3.使用自定义logger，采用的就是配置信息设置的logger
# 优势：1，2两步是一劳永逸的，后期开发只需要在要记录日志的文件中使用自定义logger
# 一、配置
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'o_fmt1': {
'format': '%(asctime)s 【%(name)s】- %(msg)s'
},
'o_fmt2': {
'format': '%(asctime)s - %(msg)s'
}
},
'filters': {},
'handlers': {
'o_hd_file': {
'level': 'WARNING',
'class': 'logging.handlers.RotatingFileHandler', # 打印到控制台
'formatter': 'o_fmt1',
'filename': 'log/sys.log',
'encoding': 'utf-8',
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5,
},
'o_hd_cmd': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到控制台
'formatter': 'o_fmt2'
}
},
'loggers': {
'o_owen': {
'level': 'DEBUG',
'handlers': ['o_hd_file', 'o_hd_cmd']
},
'o_zero': {
'level': 'DEBUG',
'handlers': ['o_hd_cmd'],
# 'propagate': True # 向上传递
}
}
}
# 二、加载配置
#在项目中可封装好getLogger 在lib/common中
import logging.config
logging.config.dictConfig(LOGGING_DIC)
# 三、使用
log = logging.getLogger('o_zero')
log.critical('信息')
log1 = logging.getLogger('o_owen')
log1.critical('信息')
re模块
# re：正则，全称正则字符串 - re就是有特殊语法的字符串
# re可以将有正则语法的字符串解析为对应的正则对象，用来匹配目标字符串
# 学习re的目的：1.判断目标字符串是否合法 2.在目标字符串中提取想要的信息（信息匹配规则采用正则）
# 基本使用
import re
r1 = re.findall(r'1', '123abc123')
print(r1)
# re.I不区分大小写匹配
r2 = re.findall(r'a', '123abc123ABC', flags=re.I)
print(r2)
# 1.将 r'\d' 丢给_compile得到可以匹配数字的 正则对象
# 2.正则对象.findall('目标字符串')
r3 = re.findall(r'\d', '123abc123')
print(r3)
re_obj = re.compile(r'\d') # 将 r'\d' 丢给_compile得到可以匹配数字的 正则对象
r4 = re_obj.findall('123abc123') # 正则对象.findall('目标字符串')
print(r4)
#re模块的其他方法
# match:不是全文匹配，必须从头开始匹配，且只匹配一次
res = re.match(r'(www\.(?P<site_name>.+?)\.(?:com|edu))', 'www.baidu.comwww.sina.edu')
# 可以通过分组号直接取出分组内容
print(res.group(1))
print(res.group(2))
# print(res.group(0), res) # 匹配的整体
# 有名分组
print(res.group('site_name'))
# split(): 拆分
print('abc def xyz'.split(' '))
print(re.split(r' ', 'abc def xyz'))
print(re.split(r'[,@ ]', 'abc,def@xyz opq'))
# sub(): 替换
res = re.sub(r'good', 'bed', 'good good day a')
print(res) # bed bed day a
res = re.sub(r'good', 'bed', 'good good day a', count=1)
print(res) # bed good day a
res = re.sub(r'good day a', '123', 'good day a!!!')
print(res) # 123!!!
# 结合分组可以完成数据的重组
res = re.sub(r'(good) (day) (a)', r'today is \3 \1 \2', 'good day a!!!')
print(res) # today is a good day!!!
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
