logging_deprecationwarning: the 'warn' function is depreca-CSDN博客

python 标准包，
https://www.red-dove.com/python_logging.html
https://www.cnblogs.com/Nicholas0707/p/9021672.html
https://docs.python.org/2/library/logging.handlers.html

import logging

示例：

#python
import logging
logging.info('this is info')        
logging.warn('this is warn')			#warn 已经不存在  由warning替换
logging.warning('this is warning')

结果

#result

/Users/tongchanweibo/PycharmProjects/VM/my_django/bin/python3 /Users/tongchanweibo/PycharmProjects/resource_mysql/test_log.py
/Users/tongchanweibo/PycharmProjects/resource_mysql/test_log.py:11: DeprecationWarning: The 'warn' function is deprecated, use 'warning' instead
  logging.warn('this is warn')
WARNING:root:this is warn									
WARNING:root:this is warning					#默认显示级别为warning

日志的等级

日志等级（level）	描述
DEBUG	最详细的日志信息，典型应用场景是问题诊断
INFO	信息详细程度仅次于DEBUG，通常只记录关键节点信息，用于确认一切都是按照我们预期的那样进行工作
WARNING	当某些不期望的事情发生时记录的信息（如，磁盘可用空间较低），但是此时应用程序还是正常运行的
ERROR	由于一个更严重的问题导致某些功能不能正常运行时记录的信息
CRITICAL	当发生严重错误，导致应用程序不能继续运行时记录的信息

使用的两种方式：
1、logging.basicConfig(level = logging.DEBUG,format = ‘%(asctime)s - %(name)s - %(levelname)s - %(message)s’)

#python
logging.debug('this is debug')
logging.info('this is info')
logging.warning('this is warning')
logging.error('%sthis is error%d','haha',100)    #利用第二个参数*args  相当于字符串传值
logging.critical('this is critical %s %d'%('hahah',1000))

logging.log(30,'buibuibui')         #数字代表级别，但不明白多大代表什么
logging.log(logging.WARNING,'buibuibui')


# logging.basicConfig(level = logging.INFO,filename= 'text.log',format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    #设置了filename后将只会写入到文件
logging.basicConfig(level = logging.DEBUG,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # 如果事先使用了logging.debug之类的这条设置将没有用，并且这个设置只能设置一次,谁先设置以谁为准
logger = logging.getLogger(__name__)
logger.info('this is debug')

#result
WARNING:root:this is warning
ERROR:root:hahathis is error100
CRITICAL:root:this is critical hahah 1000
WARNING:root:buibuibui
WARNING:root:buibuibui

logging.basicConfig 的参数：

参数名称	描述
filename	指定日志输出目标文件的文件名（可以写文件名也可以写文件的完整的绝对路径，写文件名日志放执行文件目录下，写完整路径按照完整路径生成日志文件），指定该设置项后日志信心就不会被输出到控制台了
filemode	指定日志文件的打开模式，默认为’a’。需要注意的是，该选项要在filename指定时才有效
format	指定日志格式字符串，即指定日志输出时所包含的字段信息以及它们的顺序。logging模块定义的格式字段下面会列出。
datefmt	指定日期/时间格式。需要注意的是，该选项要在format中包含时间字段%(asctime)s时才有效
level	指定日志器的日志级别
stream	指定日志输出目标stream，如sys.stdout、sys.stderr以及网络stream。需要说明的是，stream和filename不能同时提供，否则会引发 ValueError异常
style	Python 3.2中新添加的配置项。指定format格式字符串的风格，可取值为’%’、’{‘和’$’，默认为’%’
handlers	Python 3.3中新添加的配置项。该选项如果被指定，它应该是一个创建了多个Handler的可迭代对象，这些handler将会被添加到root logger。需要说明的是：filename、stream和handlers这三个配置项只能有一个存在，不能同时出现2个或3个，否则会引发ValueError异常。

format 日志格式：

字段属性名	称使用格式	描述
asctim	%(asctime)s	将日志的时间构造成可读的形式，默认情况下是‘2016-02-08 12:00:00,123’精确到毫秒name %(name)s 所使用的日志器名称，默认是’root’，因为默认使用的是 rootLogger
filename	%(filename)s	调用日志输出函数的模块的文件名； pathname的文件名部分，包含文件后缀
funcName	%(funcName)s	由哪个function发出的log，调用日志输出函数的函数名
levelname	%(levelname)s	日志的最终等级（被filter修改后的）
message	%(message)s	日志信息，日志记录的文本内容
lineno	%(lineno)d	当前日志的行号，调用日志输出函数的语句所在的代码行
levelno	%(levelno)s	该日志记录的数字形式的日志级别（10, 20, 30, 40, 50）
pathname	%(pathname)s	完整路径，调用日志输出函数的模块的完整路径名，可能没有
process	%(process)s	当前进程，进程ID。可能没有
processName	%(processName)s	进程名称，Python 3.1新增
thread	%(thread)s	当前线程，线程ID。可能没有
threadName	%(thread)s	线程名称
module	%(module)s	调用日志输出函数的模块名， filename的名称部分，不包含后缀即不包含文件后缀的文件名
created	%(created)f	当前时间，用UNIX标准的表示时间的浮点数表示；日志事件发生的时间–时间戳，就是当时调用time.time()函数返回的值
relativeCreated	%(relativeCreated)d	输出日志信息时的，自Logger创建以来的毫秒数；日志事件发生的时间相对于logging模块加载时间的相对毫秒数
msecs	%(msecs)d	日志事件发生事件的毫秒部分。logging.basicConfig()中用了参数datefmt，将会去掉asctime中产生的毫秒部分，可以用这个加上

2、日志流处理流程
logging的四大模块

组件名称	对应类名	功能描述
日志器	Logger	提供了应用程序可一直使用的接口
处理器	Handler	将logger创建的日志记录发送到合适的目的输出
过滤器	Filter	提供了更细粒度的控制工具来决定输出哪条日志记录，丢弃哪条日志记录
格式器	Formatter 决定日志记录的最终输出格式

Logger:
最常用的配置方法如下：

方法	描述
Logger.setLevel()	设置日志器将会处理的日志消息的最低严重级别
Logger.addHandler() 和 Logger.removeHandler()	为该logger对象添加和移除一个handler对象
Logger.addFilter() 和 Logger.removeFilter()	为该logger对象添加和移除一个filter对象
Logger.debug(), Logger.info(), Logger.warning(), Logger.error(), Logger.critical()	创建一个与它们的方法名对应等级的日志记录
Logger.exception()	创建一个类似于Logger.error()的日志消息
Logger.log()	需要获取一个明确的日志level参数来创建一个日志记录
Logger.getLogger(name)	创建一个logger对象
Logger.setLevel(logging.Debug)	设置日志的显示等级

header

Handler	描述
logging.StreamHandler	将日志消息发送到输出到Stream，如std.out, std.err或任何file-like对象。
logging.FileHandler	将日志消息发送到磁盘文件，默认情况下文件大小会无限增长
logging.handlers.RotatingFileHandler	将日志消息发送到磁盘文件，并支持日志文件按大小切割
logging.hanlders.TimedRotatingFileHandler	将日志消息发送到磁盘文件，并支持日志文件按时间切割
logging.handlers.HTTPHandler	将日志消息以GET或POST的方式发送给一个HTTP服务器
logging.handlers.SMTPHandler	将日志消息发送给一个指定的email地址
logging.NullHandler	该Handler实例会忽略error messages，通常被想使用logging的library开发者使用来避免’No handlers could be found for logger XXX’信息的出现。

hander的方法


Handler.setLevel(lel)	指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()	给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)	新增或删除一个filter对象

Formater类
Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是，应用代码可以直接实例化Formatter类。另外，如果你的应用程序需要一些特殊的处理行为，也可以实现一个Formatter的子类来完成。

Formatter类的构造方法定义如下：

logging.Formatter.init(fmt=None, datefmt=None, style=’%’)
可见，该构造方法接收3个可选参数：
fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
datefmt：指定日期格式字符串，如果不指定该参数则默认使用"%Y-%m-%d %H:%M:%S"
style：Python 3.2新增的参数，可取值为 ‘%’, ‘{‘和 ‘$’，如果不指定该参数则默认使用’%’
一般直接用logging.Formatter（fmt, datefmt）

#python
logger1 = logging.getLogger('logger1')          #创建logger1
logger2 = logging.getLogger('logger2')          #创建logger2

logger1.setLevel(logging.DEBUG)                 #设置logger1的日志级别为debug
logger2.setLevel(logging.DEBUG)                 #设置logger2的日志级别为debug

hander1 = logging.FileHandler(filename= 'text.log',mode= 'a',encoding='utf8')   #创建文件hander1
hander2 = logging.StreamHandler()                                               #创建hander2

hander2.setLevel(logging.WARNING)                                               #设置hander2日志级别为warning

hander3 = logging.StreamHandler()                                               #创建hander3


format = logging.Formatter(fmt = '%(levelname)s %(funcName)s %(filename)s %(asctime)s %(name)s %(message)s',
                           datefmt= "%Y-%m-%d %H:%M:%s %a"
                           )                                                    #设置信息显示格式formatter
format2 = logging.Formatter(fmt='%(name)s %(message)s')                         #设置信息显示格式formatter2

hander1.setFormatter(format)                                                    #设置hander的显示格式
hander2.setFormatter(format)
hander3.setFormatter(format2)               #加入和hander2不同的格式用做对比

logger1.addHandler(hander1)                       #给logger添加hander
logger2.addHandler(hander2)


logger1.info('this is info')                      #logger1写入文件信息        成功

logger2.info('this is logger2')                   #logger2没有打印出信息，说明执行了hander2的日志级别
                          #



logger2.addHandler(hander3)                       #给looger2 添加hander3

logger2.info('this is infologger2')
'''只打印了一条信息     格式为hander3
此时：日志级别
logger2: debug
hander2 warning
hander3 无       
日志级别符合logger2 不符合hander2 符合hander3，所以只打印了hander3
'''

logger2.setLevel(logging.CRITICAL)                #设置logger2为更高的日志级别

logger2.warning('this is warninglogger2')
'''
未打印任何信息 warning 日志级别符合hander2 和hander3 但不符合looger2 
所以打印日志的级别以logger和hander中级别较高的为准
'''

'''符合越多的hander就会打印出越多条日志信息，不需要时可使用logger.removeHander删除hander'''

logger2.setLevel(logging.DEBUG)
hander2.setLevel(logging.DEBUG)

logger2.info('this is info')                #打印两条打印hander2 和hander3 的信息
logger2.removeHandler(hander2)
logger2.info('this is logger2')             #打印一条，hander3的信息

大部分内容转自博客https://www.cnblogs.com/Nicholas0707/p/9021672.html（只转载部分）

====后补充内容
两个handlers：
logging.hanlders.TimedRotatingFileHandler
logging.handlers.RotatingFileHandler
https://docs.python.org/2/library/logging.handlers.html

在使用时发现并不能这样引用，我的python版本为 python3.7:
import logging
logging.hanlders.TimedRotatingFileHandler
logging.handlers.RotatingFileHandler

需要这样：
from logging import handlers
handlers.TimedRotatingFileHandler
handlers.RotatingFileHandler

1 、logging.hanlders.TimedRotatingFileHandler

源码：
filehander = handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None)
filehander.suffix = '%Y-%m-%d.log'  # 设置文件后缀的格式


filename	打印到日志文件的路径 str
when	发生滚动的时间间隔str[‘s’,‘m’,‘h’,‘d’,‘w0-w6’,‘MIDNIGHT’]
interval	滚动时间间隔的倍数，如果when 为s 则表示interval * s when为d 则表示interval * d
backupCount	日志文件存在最多个数，多于这个数字会删除最旧的日志文件必须为int
encoding	想必是编码，没有试过
utc	True 使用utc时间 False 使用当地时间
atTime	当when 为MIDNIGHT 或者以W开头时生效，表示当天滚动的时间

when 的值

值	间隔类型
‘S’	秒
‘M’	分钟
‘H’	小时
‘D’	天
‘W0’-‘W6’	平日（0 =星期一）
‘midnight’	半夜0点

when 取到s,m,h,d的时候并不是根据文件的创建时间决定滚动的时间，而是根据最后的修改时间决定。

atTime
在源码中有这样一段：
-----
 if self.when == 'MIDNIGHT' or self.when.startswith('W'):
            # This could be done with less code, but I wanted it to be clear
            if self.utc:
                t = time.gmtime(currentTime)
            else:
                t = time.localtime(currentTime)
            currentHour = t[3]
            currentMinute = t[4]
            currentSecond = t[5]
            currentDay = t[6]
            # r is the number of seconds left between now and the next rotation
            if self.atTime is None:
                rotate_ts = _MIDNIGHT
            else:
                rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
                    self.atTime.second)

            r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +
                currentSecond)
            if r < 0:
                # Rotate time is before the current time (for example when
                # self.rotateAt is 13:45 and it now 14:15), rotation is
                # tomorrow.
                r += _MIDNIGHT   
                currentDay = (currentDay + 1) % 7
            result = currentTime + r
# _MIDNIGHT  ： 一天之内的秒数
# rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 + self.atTime.second)  判断atTime 应该是一个时间，rotate_ts 应该为atTime距离当日0点的秒数

#r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +currentSecond)  r为rotate_ts减掉当前时间的秒数
# if r < 0:  判断当前有没有过去atTime 时间 如果过去了，r += _MIDNIGHT  
# result = currentTime + r 最终结果为当前时间+ r 这不就应该是atTime的时间吗。

所以表示为下：
如果 atTime不是None：
	rotate_ts = atTime距离当天0点的秒数
	r = rotate_ts - 当前时间距离当天0点的秒数  也就是atTime 距离 当前时间 的秒数
	如果r>0 表示今天未滚动
	如果r<0 表示今天已经滚动 则时间加一天
	
所以atTime 应该指滚动那天什么时间滚动
-----
when 的值
-----
class TimedRotatingFileHandler(BaseRotatingHandler):
    def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None):
        BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
        self.when = when.upper()
        self.backupCount = backupCount
        self.utc = utc
        self.atTime = atTime
        # Calculate the real rollover interval, which is just the number of
        # seconds between rollovers.  Also set the filename suffix used when
        # a rollover occurs.  Current 'when' events supported:
        # S - Seconds
        # M - Minutes
        # H - Hours
        # D - Days
        # midnight - roll over at midnight
        # W{0-6} - roll over on a certain day; 0 - Monday
        #
        # Case of the 'when' specifier is not important; lower or upper case
        # will work.
        if self.when == 'S':
            self.interval = 1 # one second
            self.suffix = "%Y-%m-%d_%H-%M-%S"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'M':
            self.interval = 60 # one minute
            self.suffix = "%Y-%m-%d_%H-%M"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'H':
            self.interval = 60 * 60 # one hour
            self.suffix = "%Y-%m-%d_%H"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$"
        elif self.when == 'D' or self.when == 'MIDNIGHT':
            self.interval = 60 * 60 * 24 # one day
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when.startswith('W'):
            self.interval = 60 * 60 * 24 * 7 # one week
            if len(self.when) != 2:
                raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
            if self.when[1] < '0' or self.when[1] > '6':
                raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
            self.dayOfWeek = int(self.when[1])
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        else:
            raise ValueError("Invalid rollover interval specified: %s" % self.when)
-----
值得注意的是，when 取到s,m,h,d的时候并不是根据文件的创建时间决定滚动的时间，而是根据最后的修改时间决定。
-----
        filename = self.baseFilename
        if os.path.exists(filename):
            t = os.stat(filename)[ST_MTIME]		#获取文件最后的修改时间
        else:
            t = int(time.time())
        self.rolloverAt = self.computeRollover(t)	#把修改时间传入函数computeRollover

    def computeRollover(self, currentTime):
        """
        Work out the rollover time based on the specified time.
        """
        result = currentTime + self.interval		#生成下一次滚动时间
-----

2、logging.handlers.RotatingFileHandler

class RotatingFileHandler(BaseRotatingHandler):
    """
    Handler for logging to a set of files, which switches from one file
    to the next when the current file reaches a certain size.
    """
    def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False):
filename 日志文件路径
mode 	 文件打开方式
maxBytes 文件最大的字节数    1024*1024*5 表示5M
backupCount 文件最多个数
encoding 应该是编码，没试过
谁能解释一下delay是什么意思呢》》》》