日志模块、正则表达式、时间模块

最新推荐文章于 2024-05-13 06:18:38 发布

Mr-Liuqx

最新推荐文章于 2024-05-13 06:18:38 发布

阅读量1.6k

点赞数

分类专栏： python 文章标签： logger模块正则模块时间模块

本文链接：https://blog.csdn.net/qq_34857250/article/details/79008494

版权

python 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

logging->模块

日志级别

CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置

默认级别为warn，默认打印到终端

import logging

logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical

为logging模块指定全局配置，针对所有logger有效，控制打印到文件中

#可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
#filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
#filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
#format：指定handler使用的日志显示格式。 
#datefmt：指定日期时间格式。 
#level：设置rootlogger（后边会讲解具体概念）的日志级别 
#stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为#sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

#格式
%(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：用户输出的消息

介绍：

可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为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用户输出的消息

使用：

import logging
logging.basicConfig(
    filename='access.log',  #创建logging日志文件
    format='%(asctime)s - %(name)s - %(levelname)s - %(module)s:    %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',  #定义时间格式
    level=10,    #定义日志级别
)
logging.debug('debug') #日志级别10
logging.info('info') #20
logging.warning('warn') #30
logging.error('error') #40
logging.critical('critial') #50

logging模块的Formatter，Handler，Logger，Filter对象

logger：产生日志的对象
Filter：过滤日志的对象
Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端
Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler：日志格式

#logger:产生日志
logger1=logging.getLogger('访问日志')
logger2=logging.getLogger('错误日志')

#Filter:基本不用
#Handler:接收logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件
sh=logging.StreamHandler()  #打印到终端
fh1=logging.FileHandler('s1.log',encoding='utf-8')  #打印到文件s1.log中
fh2=logging.FileHandler('s2.log',encoding='utf-8')  

#Formatter:设置日志格式
formatter1=logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s - %(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
)
formatter2=logging.Formatter(
    fmt='%(asctime)s : %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
)
formatter3=logging.Formatter(
    fmt='%(asctime)s : %(module)s : %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
)

#Handler:绑定日志格式
sh.setFormatter(formatter1)
fh1.setFormatter(formatter2)
fh2.setFormatter(formatter3)

#logger绑定Handler
logger1.addHander(sh)
logger1.addHander(fh1)
logger1.addHander(fh2)

#设置日志级别：logger对象的日志级别应该<=handler的日志级别
logger1.setLevel(50)
sh.setLevel(10)
fh1.setLevel(10)
fh2.setLevel(10)

#测试：
logger1.debug('测试玩101010')
logger1.info('运行正常202020')
logger1.warn('有点问题303030')
logger1.error('有问题404040')
logger1.critical('出大问题505050')

图解：

# 这里写图片描述

Logger与Handler的级别

logger是第一级过滤，然后才能到handler，我们可以给logger和handler同时设置level，但是需要注意的是
####应用
#####logging的配置

"""
logging配置
"""

import os
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'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# 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数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

logging使用

"""
MyLogging Test
"""

import time
import logging
import my_logging  # 导入自定义的logging配置

logger = logging.getLogger(__name__)  # 生成logger实例


def demo():
    logger.debug("start range... time:{}".format(time.time()))
    logger.info("中文测试开始。。。")
    for i in range(10):
        logger.debug("i:{}".format(i))
        time.sleep(0.2)
    else:
        logger.debug("over range... time:{}".format(time.time()))
    logger.info("中文测试结束。。。")

if __name__ == "__main__":
    my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
    demo()

关于如何拿到logger对象的详细解释

注意注意注意：


#1、有了上述方式我们的好处是：所有与logging模块有关的配置都写到字典中就可以了，更加清晰，方便管理


#2、我们需要解决的问题是：
    1、从字典加载配置：logging.config.dictConfig(settings.LOGGING_DIC)

    2、拿到logger对象来产生日志
    logger对象都是配置到字典的loggers 键对应的子字典中的
    按照我们对logging模块的理解，要想获取某个东西都是通过名字，也就是key来获取的
    于是我们要获取不同的logger对象就是
    logger=logging.getLogger('loggers子字典的key名')

    
    但问题是：如果我们想要不同logger名的logger对象都共用一段配置，那么肯定不能在loggers子字典中定义n个key   
 'loggers': {    
        'l1': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
        'l2: {
            'handlers': ['default', 'console' ], 
            'level': 'DEBUG',
            'propagate': False,  # 向上（更高level的logger）传递
        },
        'l3': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },

}

    
#我们的解决方式是，定义一个空的key
    'loggers': {
        '': {
            'handlers': ['default', 'console'], 
            'level': 'DEBUG',
            'propagate': True, 
        },

}

这样我们再取logger对象时
logging.getLogger(__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去loggers里找key名时却发现找不到，于是默认使用key=''的配置

re->正则模块

常见的匹配模块
http://blog.csdn.net/yufenghyc/article/details/51078107
# 这里写图片描述

re.findall使用

简单匹配

import re
#\w，匹配字母或者数字及下划线
#\W,匹配非字母数字下划线
print(re.findall('\w','engon 123 + _  *'))
print(re.findall('\W','engon 123 + _ *'))
#\s，匹配任意空白字符，等价于[\t\n\r\f],匹配空格,回车，tab，
#\S,匹配任意非空字符
print(re.findall('\s','engon 123 + \t \n \r \f _ *'))
print(re.findall('\S','engon 123 + —— *'))
#\d,匹配任意数字，等价于[0-9]
#\D,匹配任意非数字，
print(re.findall('\d','engon 123 + —— *'))
print(re.findall('\s','engon 123 + \t \n \r \f _ *'))
#\A，匹配字符串开始,如果存在则返回匹配到的，如果没有则反回空
#\Z，匹配字符串介绍，如果是存在换行，只匹配到换行前的结束字符串，
print(re.findall('\Aengon','engon 123 + \t \n \r \f _ *'))
print(re.findall('123\Z','\tengon 123'))
#\n,\t，匹配换行符、制表符
print(re.findall('\n','engon 123 + \t \n \r \f _ *'))
print(re.findall('\t','engon 123 + \t \n \r \f _ *'))
#e,^e,e$，匹配字符，字符串，匹配符串串开头，匹配结尾
print(re.findall('ego','ego\tn 12\n3 +hello _ - *'))
print(re.findall('^ego','ego\tn 12\n3 +hello _ - *'))
print(re.findall('\*$','ego\tn 12\n3 +hello _ - *'))

重复：.|?||+|{m,n}|.|.*?

#.代表任意一个字符
print(re.findall('a.b','a1b a b a-b aaaaaab'))
#?:代表?号左边的字符出现0次或者1
print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']
#*:代表*号左边的字符出现0次或者无穷次
print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']
#+:代表+号左边的字符出现1次或者无穷次
print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# {m,n}:代表左边的字符出现m次到n次
print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb']

print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb']

print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']

#.*:贪婪匹配
print(re.findall('a.*b','xxxy123a123b456b'))
#.*?:非贪婪匹配
print(re.findall('a.*?b','xxxy123a123b456b'))
#|:或者（取出来是元组形式，并且显示元组内匹配的内容，可以使用？：分组）
print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
# print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击我</a>'))

#rawstring：
print(re.findall(r'a\\c','a\c a1c aBc')) #a\\c->a\c

#[]:取中括号内任意的一个
print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))
print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))
print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))
print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))
print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))
print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b'))

re.search:只匹配成功一次就返回结果

#re.search :只匹配成功一次就返回
print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))
print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group())

re.match:从开头取

print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))
print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())
print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

re.split:分割

print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))
#类似：
'root:x:0:0::/root:/bin/bash'.split(':')

re.sub:从开后匹配，匹配即停止并且替换

print(re.sub('root','admin','root:x:root:0::/root:/bin/bash',1))

re.compile

obj=re.compile('a\d{2}b')
print(obj.findall('a12b a123b a12345b abbb'))
print(obj.search('a12b a123b a12345b abbb').group())

time->时间模块

时间格式转换

时间戳(timestamp)

通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

print(time.time())
>>>
1515590092.5067177

格式化的时间字符串(Format String)

print(time.strftime('%Y-%m-%d %X')) 
>>>
 '2017-02-15 11:40:53'

结构化的时间(struct_time)：

struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

print(time.localtime())
>>>
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=21, tm_min=15, tm_sec=12, tm_wday=2, tm_yday=10, tm_isdst=0)

这里写图片描述

#格式化字符时间------unix时间戳
print(time.localtime(1515590092.5067177))
print(time.mktime(time.localtime()))
>>>time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=21, tm_min=14, tm_sec=52, tm_wday=2, tm_yday=10, tm_isdst=0)
>>>1518093658.0
#格式化的时间字符串-------格式化字符时间
print(time.strftime('%Y-%m-%d %X',time.localtime()))
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))
>>>2018-02-08 20:42:01
>>>time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)

这里写图片描述

#结构化时间----Wed Jan 10 21:31:10 2018
print(time.asctime())
print(time.asctime(time.localtime()))
>>>Thu Feb  8 20:42:23 2018
>>>Thu Feb  8 20:42:23 2018

#unix时间戳----Wed Jan 10 21:31:10 2018
print(time.ctime())
print(time.ctime(time.time()))
>>>Thu Feb  8 20:42:49 2018
>>>Thu Feb  8 20:42:49 2018

时间计算

线程推迟指定时间运行，单位是s

sleep(10)

时间加减（datetime模块）

#+3天
print(datetime.datetime.now() + datetime.timedelta(3))
#-3天
print(datetime.datetime.now() + datetime.timedelta(-3))
#当前时间+3小时
print(datetime.datetime.now() + datetime.timedelta(hours=3)) 
# 当前时间+30分
print(datetime.datetime.now() + datetime.timedelta(minutes=30))
#时间替换
c_time  = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2))
>>>2018-02-11 20:43:29.693812
>>>2018-02-05 20:43:29.693812
>>>2018-02-08 23:43:29.693812
>>>2018-02-08 21:13:29.693812
>>>2018-02-08 02:03:29.693812

import datetime
time_now = datetime.datetime.now()
time_to_add = datetime.timedelta(days=-3)
n_days = time_now + time_to_add
print(type(n_days))
print(n_days.ctime())
print((datetime.datetime.now() + datetime.timedelta(1)).ctime())
>>><class 'datetime.datetime'>
>>>Tue Feb  6 11:39:32 2018
>>>Sat Feb 10 11:39:32 2018

utc时间转换北京时间


import time
import datetime
abc='2019-02-14T03:48:43'

bjtime=datetime.datetime.strptime(abc,'%Y-%m-%dT%H:%M:%S')+ datetime.timedelta(hours=8)
print(bjtime)
>2019-02-14 11:48:43

Mr-Liuqx

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
日志模块、正则表达式、时间模块

logging-&amp;amp;gt;模块日志级别CRITICAL = 50 #FATAL = CRITICALERROR = 40WARNING = 30 #WARN = WARNINGINFO = 20DEBUG = 10NOTSET = 0 #不设置默认级别为warn，默认打印到终端import logginglogging.debug('调试debug')...
复制链接

扫一扫

专栏目录