day24_log_re
"""
日志配置字典LOGGING_DIC
"""
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(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用户输出的消息
# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '%(asctime)s - %(threadName)s:%(thread)d - 日志名字:%(name)s - %(filename)s:%(lineno)d -' \
'%(levelname)s - %(message)s'
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
test_format = '%(asctime)s] %(message)s'
# 3、日志配置字典
LOGGING_DIC = {
'version': 1, #日志版本 ，不用管，
'disable_existing_loggers': False, #暂时不需要关注，默认为False就行
'filters': {}, #不用管
'formatters': { #，这个结构体包含的都是日志的格式，供后面的调用
'standard': { #这个standard名字可以修改，后面调用的时候，同样修改就行
'format': standard_format #这个 key format 不能修改,standard 只想了时间的格式
},
'simple': {
'format': simple_format
},
'test': {
'format': test_format
},
}, #日志格式，key 不能修改
#handlers是日志的接收者，不同的handler会将日志输出到不同的位置
'handlers': {
#打印到终端的日志
'console': {
'level': 'DEBUG', #设置日志最低级别，大于，这个的就会被打印到文件或者终端
'class': 'logging.StreamHandler', # 打印到屏幕，设置位置，key,不要修改
'formatter': 'simple' #调用上面的日志根式，
},
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件且轮循
# 'maxBytes': 1024*1024*5, # 日志大小 5M
'maxBytes': 1000,
'backupCount': 5,
'filename': 'a1.log', # os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
'encoding': 'utf-8', #文件的保存格式
'formatter': 'standard', #日志格式
},
#打印到文件的日志,收集info及以上的日志
'other': {
'level': 'DEBUG',
'class': 'logging.FileHandler', # 保存到文件
'filename': 'a2.log', #用后面的设置文件夹， os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
'encoding': 'utf-8',
'formatter': 'test',
},
},
# loggers是日志的产生者，产生的日志会传递给handler然后控制输出，handler又会调用日志格式，
'loggers': {
#logging.getLogger(__name__)拿到的logger配置
'kkk': {
'handlers': ['console','other'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False, # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'终端提示': {
'handlers': ['console',], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False, # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'': { # 设置默认的key 为空，当调用找不到 loggers的name 的时候会找到默认这里来
'handlers': ['default', ], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False, # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
},
}
日志配置
# src 和settings 两个文件组成日志输出
# 课后了解性质——》闲着没事自己研究下
# import logging.config
#
# logging.config.dictConfig(settings.LOGGING_DIC)
# print(logging.getLogger)
# 接下来要做的是：拿到日志的产生者即loggers来产生日志
# 第一个日志的产生者：kkk
# 第二个日志的产生者：bbb
# 但是需要先导入日志配置字典LOGGING_DIC，在settings文件里
import settings
from logging import config,getLogger
config.dictConfig(settings.LOGGING_DIC) #加载日志配置
logger1=getLogger('kkk')
logger1.info('这是一条info日志')
# logger2=getLogger('终端提示')
# logger2.info('logger2产生的info日志')
# logger3=getLogger('用户交易')
# logger3.info('logger3产生的info日志')
# logger4=getLogger('用户常规')
# logger4.info('logger4产生的info日志')
# 补充两个重要额知识
# 1、日志名的命名
# 日志名是区别日志业务归属的一种非常重要的标识
# 2、日志轮转
# 日志记录着程序员运行过程中的关键信息
import logging
logging.basicConfig( # logging 对象
# filename="access.log", # 不指定文件默认打印到终端
format="%(asctime)s - %(name)s -%(levelname)s - %(module)s: %(message)s", # 格式
# asctime 时间格式 name 为root(可设置) levelanme,:日志级别 ，module(文件名)，message 日志信息
# 时间格式
# datefmt="%Y-%m---%d %H:%M:%S %p",
# 日志级别
# critical >50
# error >40
# waring >30,
# info>>20
# debug,10,
level=10 #设置的日志级别，只要大于这个级别的都会打印到终端，或者文件
)
# logging.debug("walker_debug") #10
# logging.info("消息info")
# logging.warning("消息warning")
# logging.error("体现失败")
# logging.critical("what errro") #50 最高级别，严重
# re 模块 ，这个正则的语法太难记了
# 一：什么是正则？
# 正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。
# 或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在 Python 中，并通过 re 模块实现。
# 正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行
import re
# print(re.findall('\w','AaBC123_*()-=')) #匹配字母數字下滑綫
# print(re.findall('\W','SDKFLJ-==()')) #匹配非字母數字下劃綫
# print(re.findall('\s','aA\rbc\t\n12\f3_*()-= ')) #小写s 匹配任意空白字符串，等价于 [\t\n\r\f]
# print(re.findall("\S","aA\rbc\t\n12\f3_*()-= ")) #匹配任意非空字符
# print(re.findall("\d",'aA\rbc\t\n12\f3_*()-= ')) #匹配任意数字 等价于[0-9]
# print(re.findall('\D','aA\rbc\t\n12\f3_*()-= ')) #匹配任意非数字
# print(re.findall('\Aalex','alexis alex sb'))#返回alex #匹配字符串开始
# print(re.findall('mm\Z',"lsakfd mm mmm\t\n mm\n")) # 重要
# 匹配字符串結束，如果存在换行，只匹配到换行前的结束字符串
# print(re.findall('sb\Z',' alexis alexsb sb'))
# sb\Z
# print(re.findall('sb\Z',"""alex
# alexis
# alex
# sb #这里有个换行所以匹配不到
# """))
# print(re.findall("^walker","walker is best walker")) #匹配字符串开头
# print(re.findall("sk$","what is sk sk")) #匹配字符串结束
# print(re.findall('sb$',"""alex #这个还是能匹配到
# alexis
# alex
# sb
# """))
# print(re.findall('^walker$','walker is nice')) #匹配不到
# print(re.findall('^walker$','walk er')) #匹配不到
# print(re.findall('^walker$','walker')) #这个可以匹配到
# -----------------
#重复匹配 | . | * | ? | .* | .*? | + | {n,m} |
# print(re.findall('a.b','a1b a2b a>b abbbb a\nb a\tb a*b')) # . 匹配任意字符串，除了换行符，当 re_Dotall标记被指定时，则可以匹配包括换行符的任意字符
# ['a1b', 'a2b', 'a b', 'abb', 'a\tb', 'a*b']
# print(re.findall('a.b','a1b a2b a b abbbb a\nb a\tb a*b',re.DOTALL))
# 2、*：左侧字符重复0次或无穷次，性格贪婪
# print(re.findall('ab*','a ab abb abbbbbbbb bbbbbbbb'))
# 3、+：左侧字符重复1次或无穷次，性格贪婪
# print(re.findall('ab+','a ab abb abbbbbbbb bbbbbbbb'))
# ab+
# 4、？：左侧字符重复0次或1次，性格贪婪
# print(re.findall('ab?','a ab abb abbbbbbbb bbbbbbbb'))
# ab?
# ['a','ab','ab','ab']
# 5、{n,m}：左侧字符重复n次到m次，性格贪婪
# {0,} => *
# {1,} => +
# {0,1} => ?
# {n}单独一个n代表只出现n次，多一次不行少一次也不行 #重要
# print(re.findall('ab{2,5}','a ab abb abbb abbbb abbbbbbbb bbbbbbbb'))
# print(re.findall('\d+\.?\d*',"asdfasdf123as1111111.123dfa12adsf1asdf3"))
#
#
## []匹配指定字符一个
# print(re.findall('a\db','a1111111b a3b a4b a9b aXb a b a\nb',re.DOTALL))
# print(re.findall('a[501234]b','a1111111b a3b a4b a9b aXb a b a\nb',re.DOTALL))
# print(re.findall('a[0-5]b','a1111111b a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL))
# print(re.findall('a[0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL))
# print('-----')
# print(re.findall('a[^0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL)) #非0到9，非a到z,非A到Z
# print(re.findall('a-b','a-b aXb a b a\nb',re.DOTALL))
# print(re.findall('a[-0-9\n]b','a-b a0b a1b a8b aXb a b a\nb',re.DOTALL))
#匹配所有包含小数在内的数字
# print(re.findal#匹配所有包含小数在内的数字
# print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']
#
# # .*默认为贪婪匹配
# print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']
#
# # .*?为非贪婪匹配：推荐使用
# print(re.findall('a.*?b','a1b22222222b')) #['a1b']
#
# # +
# print(re.findall('ab+','a')) #[]
# print(re.findall('ab+','abbb')) #['abbb']
#
# #{n,m}
# print(re.findall('ab{2}','abbb')) #['abb']
# print(re.findall('ab{2,4}','abbb')) #['abb']
# print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
# print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'
#
# #[]
# print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
# print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
# print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
# print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b']
# print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b']
#
# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
# print(re.findall(r'a\\c','a\c')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
# print(re.findall('a\\\\c','a\c')) #同上面的意思一样，和上面的结果一样都是['a\\c']
#
# #():分组
# print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
# print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab
# print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容 重要
# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">6点击</a>'))#返回 ['http://www.baidu.com']
# print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']
#
# #| 或
# print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
import re
#1
# print(re.findall('e','alex make love') ) #返回符合條件並組成列表 #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里
# # #2
# print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
# #
# # #3
# print(re.match('e','ealex make love').group()) #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
#
# #4
# print(re.split('[ab]','abcd')) #感觉不怎么用 ，['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
#
# #5
# print('===>',re.sub('a','A','alex make aa')) #===> Alex mAke love，不指定n，默认替换所有
# print('===>',re.sub('a','A','alex make aaa',2)) #===> ===> Alex mAke aaa
#重要
# print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','alex make love')) #===> love make alex
# print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),结果带有总共替换的个数
#
# obj=re.compile('\d{2}')
#
# print(obj.search('abc123eeee').group()) #12
# print(obj.findall('abc123eeee')) #['12'],重用了obj
