python第二十三课---hashlib模块、subprocess模块、logging日志模块、软件开发主要流程等
昨日内容回顾
- python下载第三方模块
命令行操作 2.7 3.6 3.8
pip3.8 install 模块名
1.注意pip到底是哪个解释器版本的
2.下载可能会出现的问题
1.版本过低报错 按照提示拷贝更新命令执行即可
2.报错含有timeout关键字 网络波动较大 换网或者多执行几次
3.下载速度过慢 切换下载仓库地址
pip install 模块名 -i 仓库地址
4.报错并没有上述的情况 需要结合百度查找
3.pycharm下载相关操作
- 网络爬虫之requests模块
import requests
res = requests.get(网址)
res.content
res.encoding = 'utf8'或者'gbk'
res.text
"""防爬措施"""
- 自动化办公之openpyxl模块
1.excel版本问题
xls xlsx 苹果的csv
2.学会查看官方文档
3.基本操作
from openpyxl import WorkBook,load_workbook
res = WorkBook() # 创建excel
wb1 = res.create_sheet('学员名单')
wb1.append([111, 222, 333, 444])
res.save(r'111.xlsx') # 保存excel
- 基于openpyxl完成数据写入
公式编写需要注意公式要写完整例如 =sum()
- 基于openpyxl完成数据读取及补充
from openpyxl import WorkBook,load_workbook
max_row
max_column
rows
columns
今日内容概要
- hashlib加密模块
- subprocess模块 模拟cmd执行窗口，用代码来执行cmd里面的命令
- logging日志模块
- 软件开发主要流程
今日内容详细
hashlib加密模块
1.何为加密
将明文数据处理成密文数据 让人无法看懂
2.为什么加密
保证数据的安全
3.如何判断数据是否是加密的
一串没有规律的字符串(数字、字母、符号)
4.密文的长短有何讲究
密文越长表示使用的加密算法(数据的处理过程)越复杂
5.常见的加密算法有哪些
md5、base64、hmac、sha系列等等
鼠标右键 点击检查 到网络 负载里面就能看到 输入的密码被加密了
.
.
6.加密算法基本操作
hashlib.XXX（） 选择XXX加密算法
.update() 传入明文数据
.hexdigest() 获取加密密文
6.加密算法基本操作
import hashlib
md888 = hashlib.md5() # 1.选择加密算法，比如md5
md888.update(b'hello') # 2.传入明文数据，明文数据必须是二进制
如果是纯英文的字符串可以直接在前面加一个b就可以直接转为二进制了，还可以用.encode('utf8')方法 最后还可以用bytes（数据，'utf8'） 方法
res = md888.hexdigest() # 3.获取加密密文
print(res)
# 5d41402abc4b2a76b9719d911017c592
.
加密补充说明
import hashlib
md999 = hashlib.md5()
1.加密算法不变 内容如果相同 那么结果肯定相同！！！！！！
md999.update(b'hello~world~python~666') # 一次性传可以
res = md999.hexdigest()
print(res)
md999.update(b'hello') # 分多次传也可以
md999.update(b'~world') # 分多次传也可以
md999.update(b'~python~666') # 分多次传也可以
res = md999.hexdigest()
print(res)
2.加密之后的结果是无法反解密的！！！
只能从明文到密文正向推导 无法从密文到明文反向推导
常见的解密过程其实是提前猜测了很多种结果,所以一般要求密码设置的复杂一些，这样就不容易被提前猜到
123 密文
321 密文
222 密文
3.对明文加盐处理
import hashlib
3.加盐处理
在明文里面添加一些额外的干扰项
md111 = hashlib.md5() # 1.选择加密算法
md111.update('公司设置的干扰项'.encode('utf8')) # 2.传入明文数据
md111.update(b'hello python') # 一次性传可以
res = md111.hexdigest() # 3.获取加密密文
print(res)
# e53024684c9be1dd3f6114ecc8bbdddc
4.动态加盐
干扰项是随机变化的
eg:当前时间、用户名部分...
比如传入的干扰项是个实时时间，这样每一刻与密码一起生成的密文都不一致了
5.加密实战操作
5.加密实战操作
1.用户密码加密
比如用户注册登录的时候， 比如数据库里面存储用户信息的时候，用户的密码就是已密文存储的，这样就算数据库里面的信息泄露了，别人也不知道用户的密码是什么，当用户在登录的时后还是以同样的加密算法进行加密，最后进行比较用户实时输入的密码的密文，与数据库里面的密码的密文是不是一致的，确定用户密码是否输对了！！！
2.文件安全性校验
比如软件开发者开发了一个软件，最后对软件内容加密生成一个密文，这样下载这个软件的人，在下载这个软件的时候，会被告知算法与密文，这样用户计算机不会先运行这个下载下来的软件，而是也用同样的算法，对这个文件进行加密，比较下载下来的软件的加密的密文与开发者的密文是否一致，就可以知道该下载的软件有没有被恶意的添加了木马等病毒在里面了，一旦发现密文不一致，直接不让这个下载下来的软件进行运行！！！
3.文件内容一致性校验
与上面的原理一致，当发现两个文件的加密后的密文一致，那么就确定这两个文件的内容是一致的
文件打开for循环，不停的传入明文数据，传完后，用hexdigest()得到密文数据，那么这个密文数据就是该文件内容在该加密算法下唯一的密文数据。假如又一个文件内容的密文数据和这个数据的密文一样，那么两文件内容一定是一样的！！！
4.大文件内容加密
策略： 截取部分内容加密即可!!!!!!在不降低安全性的基础上，提升效率！！！
subprocess模块
模拟操作系统终端 执行命令并获取结果
可以写一个自动化管理操作系统的一个代码
这个模块学会了以后，可以把代码发到别人的电脑上，然后让别人把代码启动起来，就可以在自己的电脑上通过敲命令，来操控他的电脑！！！但是只能在cmd终端里面执行！！！
subprocess.Popen() # 激活一个终端
res.stdout 就是获取操作系统，执行完命令之后的，正确的结果
res.stderr 就是获取操作系统，执行完命令之后的，错误的结果
import subprocess
res = subprocess.Popen(
'tasklist', # 操作系统要执行的命令
shell=True, # 固定配置 表示是一个脚本命令
stdin=subprocess.PIPE, # 输入命令
stdout=subprocess.PIPE, # 输出结果
)
print('正确结果', res.stdout.read().decode('gbk')) # 获取操作系统执行命令之后的正确结果
print('错误结果', res.stderr) # 获取操作系统执行命令之后的错误结果
windows系统底层终端cmd里面默认的编码是gbk，所以获取的二进制结果，解码要用gbk解码！！！
二进制转字符串用.decode（对应的编码类型）
字符串转二进制用.encode(对应的编码类型)
logging日志模块！！！！！！
前言 抄的别人的文章！！！
在自动化测试中，为了定位问题，调试框架代码，需要使用日志模块，今天我们重点讲解Python中的logging模块，在学习使用logging模块前，我们先要了解logging模块的四大天王：logger、handler、filter、formatter
一.logging模块的四大组件
logger：日志器，提供程序可使用的接口
handler：处理器，用于写入日志文件并输出到指定位置，如文件、控制台或网络等
filter：过滤器，用于输出符合指定条件的日志记录
formatter：格式器，决定日志记录的输出格式
二.如何使用logging模块---基本用法
1.创建logger对象，返回一个日志器
logger = logging.getlogger()
2.设置日志器等级
logger.setLevel("DEBUG") # 设置日志等级为debug
常见的日志级别有：DEBUG、INFO、WARNING、ERROR、CRITICAL，具体用法如下：
DEBUG:最低级别，追踪问题时使用
INFO:记录程序中一般事件的信息，或确认一切工作正常
WARNING:记录信息，用于警告
ERROR:用于记录程序报错信息
CRITICAL:最高级别，记录可能导致程序崩溃的错误
————————————————
3.创建一个处理器对象 返回一个处理器
fh = logging.FileHandler(filename="bbb.log", mode='a', encoding="utf-8", delay=False) #创建一个文件处理器，日志输入文件，需要指定文件名称，写入的模式，编码格式等
4.创建一个格式器对象 返回一个格式器
fmt = logging.Formatter("[%(asctime)s]-[%(levelname)s]-[%(pathname)s]-[Line:%(lineno)d]-[LoggerInfo:%(message)s]") #一般格式器中要定义好日志产生时间，日志级别，产生日志的模块全路径，模块的哪一行，具体的日志信息等
5.为处理器添加格式 让处理器把格式器功能包进去！！！！！
fh.setFormatter(fmt=fmt)，将第4步中生成的格式器给第3步生成的处理器“吞吃”
6.为日志器添加处理方式 让日志器再把处理器功能包进去！！！！！
logger.addHandler(fh)，将设置格式后的处理器对象给日志器“吞吃”，使日志器有处理日志的能力
7.调用日志器对象，生成日志 最后调用日志器！！！
logger.debug("这是一个debug错误")
————————————————
源码如下：
import logging #导入日志模块
logger = logging.getLogger() #创建日志器
logger.setLevel(logging.DEBUG) #设置日志的打印级别
fh = logging.FileHandler(filename="kkk.log",mode='a',encoding="utf-8") #创建日志处理器，用文件存放日志
sh = logging.StreamHandler() # 创建日志处理器，在控制台打印
创建格式器，指定日志的打印格式
fmt = logging.Formatter("[%(asctime)s]-[%(levelname)s]-[%(filename)s]-[Line:%(lineno)d]-[Msg:%(message)s]")
给处理器设置格式
fh.setFormatter(fmt=fmt)
sh.setFormatter(fmt=fmt)
给日志器添加处理器
logger.addHandler(fh)
logger.addHandler(sh)
logger.debug("ajffasfdsas") #调用日志器
————————————————
三.优化
上面的日志的基本用法，没有做封装，实际工作中使用不方便，我们接下来将其进行封装，方便需要使用时，进行调用，同时将具体包括将日志按日期分别存放到不同的文件，日志名称以时间命名；具体方法如下：
import logging,os,time
class Logging():
def make_log_dir(self,dirname='logs'): #创建存放日志的目录，并返回目录的路径
now_dir = os.path.dirname(file)
father_path = os.path.split(now_dir)[0]
path = os.path.join(father_path,dirname)
path = os.path.normpath(path)
if not os.path.exists(path):
os.mkdir(path)
return path
————————————————
def get_log_filename(self):#创建日志文件的文件名格式，便于区分每天的日志
filename = "{}.log".format(time.strftime("%Y-%m-%d",time.localtime()))
filename = os.path.join(self.make_log_dir(),filename)
filename = os.path.normpath(filename)
return filename
————————————————
def log(self,level='DEBUG'):#生成日志的主方法,传入对那些级别及以上的日志进行处理
logger = logging.getLogger()#创建日志器
levle = getattr(logging,level) #获取日志模块的的级别对象属性
logger.setLevel(level)#设置日志级别
if not logger.handlers: #作用,防止重新生成处理器
sh = logging.StreamHandler()#创建控制台日志处理器
fh = logging.FileHandler(filename=self.get_log_filename(),mode='a',encoding="utf-8")#创建日志文件处理器
#创建格式器
fmt = logging.Formatter("%(asctime)s-%(levelname)s-%(filename)s-Line:%(lineno)d-Message:%(message)s")
#给处理器添加格式
sh.setFormatter(fmt=fmt)
fh.setFormatter(fmt=fmt)
#给日志器添加处理器，过滤器一般在工作中用的比较少，如果需要精确过滤，可以使用过滤器
logger.addHandler(sh)
logger.addHandler(fh)
return logger #返回日志器
————————————————
if name == 'main':
logger = Logging().log(level='DEBUG') #调用封装的日志方法，生成处理后的日志器
logger.debug("1111111111111111111111") #使用日志器生成日志
logger.info("222222222222222222222222")
logger.error("附件为IP飞机外婆家二分IP文件放")
logger.warning("3333333333333333333333333333")
logger.critical("44444444444444444444444444")
————————————————
以上抄自
版权声明：本文为CSDN博主「测试界的彭于晏」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/IT_LanTian/article/details/123854042
------------------------------------------------------------
logging日志模块！！！！！！
ATM项目用
1.如何理解日志
简单的理解为是记录行为举止的操作(历史史官)
2.日志的级别
五种级别,越往下，严重级别越高！！！
import logging
logging.debug('debug message') # 调试信息
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message') # 严重的，危急的信息
3.日志模块要求
代码无需掌握 但是得会CV并稍作修改
logging.FileHandler（）
import logging
file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf8',)
这行代码的意思是以后产生日志的信息全部记录到'x1.log'文件里面去。
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p', # %p 是上下午的意思
handlers=[file_handler,], # 处理方式
level=logging.ERROR # 记录的级别
)
logging.error('你好')
这行代码的作用是控制日志的格式，basicConfig 就算基本配置的意思，时间、人、等级、模块、
。
了解一下即可
配置参数：
logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：
filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息
日志的组成 4个部分组成
Handler 处理器，处理者
getLogger 获取记录器
FileHandler 文件处理程序
StreamHandler 流处理器 可以理解为就是终端
Formatter 格式化程序
1.产生日志
2.过滤日志
基本不用 因为在日志产生阶段就可以控制想要的日志内容
3.输出日志
4.日志格式
logger 记录器！！！
Handler 处理器！！！
formmatter 格式器！！！
import logging
# 1.日志的产生
logger = logging.getLogger('购物车记录') # 括号里面放将来主要记哪方面的数据的描述
# 2.日志的过滤(剔除不良品) 可以忽略 不用使用！！
# 3.日志的产出(成品) 定制日志往哪个地方输出
hd1 = logging.FileHandler('a1.log', encoding='utf-8') # 输出到'a1.log'文件中
hd2 = logging.FileHandler('a2.log', encoding='utf-8') # 输出到'a2.log'文件中
hd3 = logging.StreamHandler() # 输出到终端！！
# 4.日志的格式(包装) 可以提前定制多种日志格式！！！
fm1 = logging.Formatter(fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',datefmt='%Y-%m-%d %H:%M:%S %p',)
fm2 = logging.Formatter(fmt='%(asctime)s - %(name)s: %(message)s', datefmt='%Y-%m-%d',)
# 5.给logger记录对象绑定handler处理对象！！！ 通俗点将就是给记录的信息绑定要输出的地方！！！
logger.addHandler(hd1)
logger.addHandler(hd2)
logger.addHandler(hd3)
# 6.给handler对象绑定formmate对象！！！ 通俗点讲就是输出的信息以及确定了输出地方了，再绑定输出的格式，这样记录的日志就清楚应该往哪输出，以什么样的格式输出！！！！！！
hd1.setFormatter(fm1)
hd2.setFormatter(fm2)
hd3.setFormatter(fm1)
# 7.设置日志等级！！！
logger.setLevel(10) # debug
先介绍一下日志的作用：方便自己与他人查看问题和定位问题
一、日志级别
1、DEBUG 10 调试信息，一些额外的信息
2、INFO 20 主体功能信息、做了些什么
3、WARNING 30 警告，下次可能要出错了
4、ERROR 40 报错，违法的
5、CRITICAL 50 极其严重的
# 8.记录日志
logger.debug('写了半天 好累啊 好热啊')
日志的大致流程：
产生日志--过滤日志--给日志定制各种格式--控制日志最后到什么地方！！
.
.
日志配置字典
import logging
import logging.config 这个不能少，模块有点小bug
# 定义日志输出格式 标准格式与简单格式！！！
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
# 自定义文件路径
logfile_path = 'a3.log'
# 日志配置字典！！！！！！
LOGGING_DIC = {
'version': 1, # 版本
'disable_existing_loggers': False, # 使现有记录器无效功能
'formatters': {
'standard': {'format': standard_format}, # 要提前提供！！
'simple': {'format': simple_format}, }, # 要提前提供！！
'filters': {}, # 过滤日志
# 下面一行是打印到终端的日志，console是终端的意思
'handlers': {
'console': {
'level': 'DEBUG', # 级别
'class'：'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple' # 采用的打印格式为简单格式！
},
# 打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG', # 级别
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard', # 打印格式为标准格式！
'filename': logfile_path, # 日志文件路径！！！要提前提供！！！
'maxBytes': 1024 * 1024 * 5, # 单个日志最大字节数5M，超过就会再创一个空的再存
'backupCount': 5, # 最大能存在的日志数量，满了就会自动覆盖最早的日志
'encoding': 'utf-8', }, # 日志文件的编码，再也不用担心中文log乱码了
},
# logging.getLogger(__name__)拿到的logger配置
'logger': {
# '':{
# 'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
# 'level': 'DEBUG',
# 'propagate': True, # 向上（更高level的logger）传递
# }, # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
'购物车记录': {
'handlers': ['default','console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'WARNING', # 级别
'propagate': True, # 向上（更高level的logger）传递
}, # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置！！！！
},
}
logging.config.dictConfig(LOGGING_DIC) # 自动加载字典中的配置
logger1 = logging.getLogger('购物车记录') # 括号里面一定要和上面logger字典里面的最下面的键'购物车记录'一样的！！！
logger1.warning('尊敬的VIP客户 晚上好 您又来啦') # 定义日志的级别与提示的内容
logger1 = logging.getLogger('注册记录') # 括号里面填写的内容一定要是logger字典里面的出现过的键！！！！！！！！！！！！！
logger1.debug('jason注册成功') # 还是一样，定义日志的级别与提示的内容
logger1 = logging.getLogger('红浪漫顾客消费记录')
logger1.debug('慢男 猛男 骚男')
如果想记录多个级别的日志，那么就要有实键的那几行黑掉，把有空键的那几行打开就行了！！！
可以直接复制粘贴这几行代码！！！
这一个LOGGING_DIC大字典里面，就这5个键！！！
'version'
'disable_existing_loggers'
'formatters'
'filters'
'handlers'
'logger'
日志实战应用
.
.
自定义路径要改一下，不能写死！！！
要动态获取创建log文件夹！！！！！！
.
再在log文件夹里面创建.log的文件！！
.
.
.
促发日志记录的操作是通过，logger1点debug或者info等来记录的，这个地方通过return拿返回值，不急着走这步，这样，在调用这个自定义函数的时候，就可以利用返回值，再调用logger1点的方式来自己选择要用什么日志级别！！
.
.
.
这个调用日志的函数要放到lib文件夹的common.py 文件里面去！！！
.
.
这样最后，setting里面放配置字典，common里面放日志记录的函数，src里面还是放项目的框架文件
日志字典模板，直接复制粘贴用！！！
import logging
import logging.config
# 定义日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
# 自定义文件路径
logfile_path = 'a3.log'
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
},
'filters': {}, # 过滤日志
'handlers': {
# 打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple'
},
# 打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard',
'filename': logfile_path, # 日志文件
'maxBytes': 1024 * 1024 * 5, # 日志大小 5M
'backupCount': 5,
'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了
},
},
'loggers': {
# logging.getLogger(__name__)拿到的logger配置
'': {
'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕，把'console'去掉就不往屏幕上打印了，只写入文件
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
}, # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
# '购物车记录': {
# 'handlers': ['default','console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
# 'level': 'WARNING',
# 'propagate': True, # 向上（更高level的logger）传递
# }, # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
},
}
一般如果一个日志器要多好几个函数进行记录的话，就把最下面几行都黑掉，只留上面的几行就行了
这几行是要在src文件里面粘贴的！！！
logging.config.dictConfig(LOGGING_DIC) # 自动加载字典中的配置
logger1 = logging.getLogger('购物车记录') # 生成日志器
logger1.warning('尊敬的VIP客户 晚上好 您又来啦') # 运行日志器，括号里面放你想要日志记录的内容！！日志不会主动记录任何内容，你必须在括号里面告诉它要记录的内容。也就是说你在括号里面写个'sb',只要运行到这行代码，记录的信息就是sb。日志的级别实际是你自己设定的，日志器本身并不能分辨他要记录的内容是什么等级，是你自己提前根据你写在括号里面的内容，划分的等级。
# logger1 = logging.getLogger('注册记录')
# logger1.debug('jason注册成功')
logger1 = logging.getLogger('红浪漫顾客消费记录')
logger1.debug('慢男 猛男 骚男')
.
.
.
.
.
.
flask中使用logger
funcs.py
import logging
import datetime
import logging.handlers
import os
LOG_LEVEL_DICT = {
'CRITICAL': 50,
'FATAL': 50,
'ERROR': 40,
'WARNING': 30,
'WARN': 30,
'INFO': 20,
'DEBUG': 10,
'NOTSET': 0,
}
def create_logger(name: str, folder_path: str, log_level: str) -> None:
"""
用于再当前环境中创建一个名为name的logger
"""
logger = logging.getLogger(name)
logger.setLevel(LOG_LEVEL_DICT[log_level])
# 判断文件夹是否存在，没有则创建多层文件夹
os.makedirs(folder_path, exist_ok=True)
# 配置 logger 写入 rotating日志文件
file_handler = logging.handlers.RotatingFileHandler(f'{folder_path}log_{name}.log', maxBytes=1024 * 1024 * 10,
backupCount=5, encoding='utf-8')
file_handler.setLevel(LOG_LEVEL_DICT[log_level])
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
# 自定义时间字段的获取方法
def custom_time(record, datefmt=None):
return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
# 将自定义时间字段的获取方法添加到格式化器
formatter.converter = custom_time
# 添加自定义时间字段
formatter.formatTime = custom_time
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
----------------------------------------------
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_caching import Cache
from utils.logs.funcs import create_logger
from flask_cors import CORS
class EnhancedApp(Flask):
"""
Flask App的继承类，用于更灵活的App调用
"""
def create_app_logger(self, log_level: str = 'INFO'):
"""
用于创建一个以该父类App的name命名的logging.logger
"""
create_logger(self.name, './logs/', log_level)
def bind_app_sqlalchemy_db(self, db: SQLAlchemy):
"""
将一个SqlAlchemy的db实例绑定到该App中
"""
db.init_app(self)
def bind_app_flask_cache(self, cache_flask: Cache):
"""
将一个flask-cache实例绑定到该App中
"""
cache_flask.init_app(self)
def register_blueprints(self, blueprints: dict):
for key, val in blueprints.items():
self.register_blueprint(blueprint=val, url_prefix=key)
def set_cors(self):
"""
解决跨域
"""
CORS(self, supports_credentials=True)
----------------------------------------------
# app设置日志记录器
app.create_app_logger('INFO')
----------------------------------------------
.
.
.
.
.
.
.
日志总结
第一步：
后面日志可以直接先在conf里面的setttings文件里面直接复制粘贴上面的两个格式与loger配置字典。
第二步：
然后可以把加载日志字典的配置，与日志器的生成封成一个日志器生成函数，放到common里面去
import logging
import logging.config
from conf import settings
def get_logger(msg):
logging.config.dictConfig(settings.LOGGING_DIC) # 自动加载字典中的配置
logger1 = logging.getLogger(msg) # 生成日志器
return logger1
第三步：
这样在其他文件里面，只要在要记录日志的文件里面，先调用日志器生成函数比如：
logger = common.get_logger('银行模块') # 这里的变量名logger把日志生成器给接收了
第四步：
然后在你想要记录日志的地方再写一行代码比如：
logger.debug('你是sb') # 运行日志器，记录日志！！
还是一样这个括号里面是你自己提前写好的内容，走这行代码日志器就要记录记录一次你写在括号里面的内容！！！！！
日志器就就认为是个sb，你告诉它运行这行代码要记录什么，运行到这行代码，它就会记录什么！！
就4步，先复制粘贴，然后加载功能字典的配置，然后生成日志器，最后运行日志器！！！
.
.
.
.
.
作业
1.整理今日内容及博客
2.完善购物车程序 尝试拆分成软件开发目录规范并添加日志功能
3.预习ATM程序
浙公网安备 33010602011771号