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 bc 12f3_*()-= ')) #小写s 匹配任意空白字符串，等价于 [ f]
# print(re.findall("S","aA bc 12f3_*()-= ")) #匹配任意非空字符
# print(re.findall("d",'aA bc 12f3_*()-= ')) #匹配任意数字 等价于[0-9]
# print(re.findall('D','aA bc 12f3_*()-= ')) #匹配任意非数字
# print(re.findall('Aalex','alexis alex sb'))#返回alex #匹配字符串开始
# print(re.findall('mm',"lsakfd mm mmm mm ")) # 重要
# 匹配字符串結束，如果存在换行，只匹配到换行前的结束字符串

# print(re.findall('sb',' alexis alexsb sb'))
# sb
# print(re.findall('sb',"""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 b a b a*b')) # . 匹配任意字符串，除了换行符，当 re_Dotall标记被指定时，则可以匹配包括换行符的任意字符
# ['a1b', 'a2b', 'a b', 'abb', 'a b', 'a*b']
# print(re.findall('a.b','a1b a2b a b abbbb a b a b 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('adb','a1111111b a3b a4b a9b aXb a b a b',re.DOTALL))
# print(re.findall('a[501234]b','a1111111b a3b a4b a9b aXb a b a b',re.DOTALL))
# print(re.findall('a[0-5]b','a1111111b a3b a1b a0b a4b a9b aXb a b a b',re.DOTALL))
# print(re.findall('a[0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a b',re.DOTALL))
# print('-----')
# print(re.findall('a[^0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a b',re.DOTALL)) #非0到9，非a到z,非A到Z
# print(re.findall('a-b','a-b aXb a b a b',re.DOTALL))
# print(re.findall('a[-0-9 ]b','a-b a0b a1b a8b aXb a b a b',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','ac')) #对于正则来说a\c确实可以匹配到ac,但是在python解释器读取a\c时，会发生转义，然后交给re去执行，所以抛出异常
# print(re.findall(r'a\c','ac')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
# print(re.findall('a\\c','ac')) #同上面的意思一样，和上面的结果一样都是['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'52341','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