Python学习记录day5

清疚 2022-07-14 04:45 336阅读 0赞

# 1.多层装饰器 #

多层装饰器的原理是，装饰器装饰函数后，其实也是一个函数，这样又可以被装饰器装饰。 编译是从下至上进行的，执行时是从上至下进行。

#!/usr/bin/env python
    # _*_coding:utf-8_*_
    ''' * Created on 2016/11/29 20:38. * @author: Chinge_Yang. '''
    
    USER_INFO = {}
    
    
    # USER_INFO['is_login'] = True
    # USER_INFO['user_type'] = 2
    
    
    def check_login(func):
        def inner(*args, **kwargs):
            if USER_INFO.get("is_login", None):
                ret = func(*args, **kwargs)
                return ret
            else:
                print("请登录")
    
        return inner
    
    
    def check_admin(func):
        def inner(*args, **kwargs):
            if USER_INFO.get('user_type', None) == 2:
                ret = func(*args, **kwargs)
                return ret
            else:
                print('无权限查看')
    
        return inner
    
    
    @check_login
    @check_admin
    def index():
        """ 管理员的功能 :return: """
        print('Index')
    
    
    @check_login
    def home():
        """ 普通用户功能 :return: """
        print("home")
    
    
    def login():
        user = input("请输入用户名：")
        if user == "admin":
            USER_INFO["is_login"] = True
            USER_INFO["user_type"] = 2
        else:
            USER_INFO["is_login"] = True
            USER_INFO["user_type"] = 1
    
    
    def main():
        while True:
            inp = input("1.登录；2.查看信息；3.超级管理员管理\n >>>")
            if inp == "1":
                login()
            elif inp == "2":
                home()
            elif inp == "3":
                index()
            elif inp == "q":
                exit()
    
    
    main()

# 2.字符串格式化 #

**Python的字符串格式化有两种方式: 百分号方式、format方式**

> 百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。\[PEP-3101\]  
> This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing ‘%’ string formatting operator.

## 1.百分号方式 ##

%\[(name)\]\[flags\]\[width\].\[precision\]typecode

*  (name) 可选，用于选择指定的key
 *  flags 可选，可供选择的值有:  
    \+ 右对齐；正数前加正好，负数前加负号；  
    \- 左对齐；正数前无符号，负数前加负号；  
    空格 右对齐；正数前加空格，负数前加负号；  
    0 右对齐；正数前无符号，负数前加负号；用0填充空白处
 *  width 可选，占有宽度
 *  .precision 可选，小数点后保留的位数
 *  typecode 必选  
    s，获取传入对象的**str**方法的返回值，并将其格式化到指定位置  
    r，获取传入对象的**repr**方法的返回值，并将其格式化到指定位置  
    c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置  
    o，将整数转换成 八 进制表示，并将其格式化到指定位置  
    x，将整数转换成十六进制表示，并将其格式化到指定位置  
    d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置  
    E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）  
    f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）  
    F，同上  
    g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）  
    G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）  
    %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

*注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式*

常用格式化：

tpl = "i am %s" % "ygqygq2"
    
    tpl = "i am %s age %d" % ("ygqygq2", 27)
    
    tpl = "i am %(name)s age %(age)d" % {
       "name": "ygqgyq2", "age": 27}
    
    tpl = "percent %.2f" % 99.97623
    
    tpl = "i am %(pp).2f" % {
       "pp": 123.425556, }
    
    tpl = "i am %.2f %%" % {
       "pp": 123.425556, }

## 2.Format方式 ##

\[\[fill\]align\]\[sign\]\[\#\]\[0\]\[width\]\[,\]\[.precision\]\[type\]

*  fill 【可选】空白处填充的字符
 *  align 【可选】对齐方式（需配合width使用）  
    <，内容左对齐  
    >，内容右对齐(默认)  
    ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字  
    ^，内容居中
 *  sign 【可选】有无符号数字  
    \+，正号加正，负号加负；  
    \-，正号不变，负号加负；  
    空格 ，正号空格，负号加负；  
    \# 【可选】对于二进制、八进制、十六进制，如果加上\#，会显示 0b/0o/0x，否则不显示  
    ， 【可选】为数字添加分隔符，如：1,000,000  
    width 【可选】格式化位所占宽度  
    .precision 【可选】小数位保留精度  
    type 【可选】格式化类型  
    传入” 字符串类型 “的参数  
    s，格式化字符串类型数据  
    空白，未指定类型，则默认是None，同s传入“ 整数类型 ”的参数  
    b，将10进制整数自动转换成2进制表示然后格式化  
    c，将10进制整数自动转换为其对应的unicode字符  
    d，十进制整数  
    o，将10进制整数自动转换成8进制表示然后格式化；  
    x，将10进制整数自动转换成16进制表示然后格式化（小写x）  
    X，将10进制整数自动转换成16进制表示然后格式化（大写X）传入“ 浮点型或小数类型 ”的参数  
    e， 转换为科学计数法（小写e）表示，然后格式化；  
    E， 转换为科学计数法（大写E）表示，然后格式化;  
    f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；  
    F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；  
    g， 自动在e和f中切换  
    G， 自动在E和F中切换  
    %，显示百分比（默认显示小数点后6位）
    
    常用格式化：

# 最常用，括号与内容一一对应，对后面变量位置顺序有要求
    tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
    # 列表值个数不能少于括号个数 
    tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
    # 此方法适用于多个位置有重复内容 
    tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
    # 以列表形式应用多个位置有重复内容 
    tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
    # 类似于变量赋值形式，对后面变量位置顺序无要求 
    tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
    # 类似于变量赋值形式，而是以字典形式，对后面变量位置顺序无要求 
    tpl = "i am {name}, age {age}, really {name}".format(**{
       "name": "seven", "age": 18})
    # 切割后面列表填入括号内，要求括号内填入的内容是已经定义的 
    tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
    # 括号与内容一一对应，严格要求括号内类型与后面内容类型一致 
    tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
    # 以列表形式，括号与内容一一对应，严格要求括号内类型与后面内容类型一致 
    tpl = "i am {:s}, age {:d}".format(*["seven", 18])
    # 严格要求括号内类型与后面内容类型一致，对后面变量位置顺序无要求 
    tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
    # 以字典形式，括号与内容一一对应，严格要求括号内类型与后面内容类型一致 
    tpl = "i am {name:s}, age {age:d}".format(**{
       "name": "seven", "age": 18})
    # 按对应位置，将内容一一转换相应数据类型 
    tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
    # 后面内容类似列表位置，也是从0开始的，将内容一一转换相应数据类型 
    tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15, 10)
    # 引用后面变量，将内容一一转换相应数据类型 
    tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

更多格式化操作：[https://docs.python.org/3/library/string.html][https_docs.python.org_3_library_string.html]

# 3.迭代器和生成器 #

## 1.迭代器 ##

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容  
不能随机访问集合中的某个值 ，只能从头到尾依次访问  
访问到一半时不能往回退  
便于循环比较大的数据集合，节省内存

>>> a = iter([1,2,3,4,5])
    >>> a
    <list_iterator object at 0x101402630>
    >>> a.__next__()
    1
    >>> a.__next__()
    2
    >>> a.__next__()
    3
    >>> a.__next__()
    4
    >>> a.__next__()
    5
    >>> a.__next__()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

## 2.生成器 ##

一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；

def func():
        print(11)
        yield 1
        print(22)
        yield 2
        print(33)
        yield 3
        print(44)
        yield 4

上述代码中：func是函数称为生成器，当执行此函数func()时会得到一个迭代器。

>>> temp = func()
    >>> temp.__next__()
    11
    1
    >>> temp.__next__()
    22
    2
    >>> temp.__next__()
    33
    3
    >>> temp.__next__()
    44
    4
    >>> temp.__next__()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

# 4.函数递归 #

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def func(n):
        n += 1
        if n >= 4:
            return "end"
        return func(n)
    
    res = func(1)
    print(res)

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。

详细请看廖雪峰的官方网站中[递归函数][Link 1]

# 5.模块 #

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。  
模块分为三种：  
\* 自定义模块  
\* 第三方模块  
\* 内置模块

## 1.使用模块有什么好处？ ##

1. 最大的好处是大大提高了代码的可维护性。
    2. 使用模块还可以避免函数名和变量名冲突。

## 2.导入模块 ##

单模块：import
    嵌套在文件夹下：
    from xxx import xxx
    from xxx import as ooo

## 3.第三方模块 ##

pip3安装（pip安装）

pip3 install requests

源码安装

curl -OL https://github.com/kennethreitz/requests/tarball/master

解压后，进入目录

python setup.py install

# 6.序列化 #

Python中用于序列化的两个模块

*  json 用于【字符串】和【python基本数据类型】间进行转换
 *  pickle 用于【python特有的类型】和【python基本数据类型】间进行转换

*Json模块提供了四个功能：dumps、dump、loads、load*  
*pickle模块提供了四个功能：dumps、dump、loads、load*

**json相关用法：**

import json
    
    dict = {
       'k1': 'v1'}
    print(dict, type(dict))
    # 将python基本数据类型转换成字符串形式
    res = json.dumps(dict)
    print(res, type(res))

\{‘k1’: ‘v1’\}

import json
    
    # 将python字符串形式转换成基本数据类型
    s1 = '{"k1": 123}'
    dict = json.loads(s1)   # 反序列化时，一定要使用 ""
    print(dict, type(dict))

\{‘k1’: 123\}

import json
    
    li = [11,22,33]
    json.dump(li,open('test.txt','w'))
    
    li = json.load(open('test.txt','r'))
    print(type(li),li)

**pickle相关用法：**

import pickle
    
    li = [11,22,33]
    r = pickle.dumps(li)
    print(r) res = pickle.loads(r) print(res)

b’\\x80\\x03\]q\\x00(K\\x0bK\\x16K!e.’  
\[11, 22, 33\]

li = [11,22,33]
    pickle.dump(li, open('test4.txt', 'wb'))
    
    res = pickle.load(open('test4.txt', 'rb'))
    print(res)

\[11, 22, 33\]

**json和pickle对比：**  
1. *json更适合跨语言，字符串，基本数据类型*  
2. *pickle更适合python所有类型的序列化操作*

# 7.time & datetime模块 #

Python格式化日期时间的函数为datetime.datetime.strftime()；由字符串转为日期型的函数为：datetime.datetime.strptime()，两个函数都涉及日期时间的格式化字符串，列举如下：

%a Abbreviated weekday name  
%A Full weekday name  
%b Abbreviated month name  
%B Full month name  
%c Date and time representation appropriate for locale  
%d Day of month as decimal number (01 - 31)  
%H Hour in 24-hour format (00 - 23)  
%I Hour in 12-hour format (01 - 12)  
%j Day of year as decimal number (001 - 366)  
%m Month as decimal number (01 - 12)  
%M Minute as decimal number (00 - 59)  
%p Current locale’s A.M./P.M. indicator for 12-hour clock  
%S Second as decimal number (00 - 59)  
%U Week of year as decimal number, with Sunday as first day of week (00 - 51)  
%w Weekday as decimal number (0 - 6; Sunday is 0)  
%W Week of year as decimal number, with Monday as first day of week (00 - 51)  
%x Date representation for current locale  
%X Time representation for current locale  
%y Year without century, as decimal number (00 - 99)  
%Y Year with century, as decimal number  
%z, %Z Time-zone name or abbreviation; no characters if time zone is unknown  
%% Percent sign

#_*_coding:utf-8_*_
    
    import datetime
    
    i = datetime.datetime.now()
    print ("当前的日期和时间是 %s" % i)
    print ("ISO格式的日期和时间是 %s" % i.isoformat() )
    print ("当前的年份是 %s" %i.year)
    print ("当前的月份是 %s" %i.month)
    print ("当前的日期是 %s" %i.day)
    print ("dd/mm/yyyy 格式是 %s/%s/%s" % (i.day, i.month, i.year) )
    print ("当前小时是 %s" %i.hour)
    print ("当前分钟是 %s" %i.minute)
    print ("当前秒是 %s" %i.second)

#_*_coding:utf-8_*_
    
    import time
    
    
    # print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
    # print(time.altzone) #返回与utc时间的时间差,以秒计算\
    # print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
    # print(time.localtime()) #返回本地时间 的struct time对象格式
    # print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式
    
    # print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
    #print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上
    
    
    
    # 日期字符串 转成 时间戳
    # string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
    # print(string_2_struct)
    # #
    # struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
    # print(struct_2_stamp)
    
    
    
    #将时间戳转为字符串格式
    # print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
    # print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式
    
    
    
    
    
    #时间加减
    import datetime
    
    # print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
    #print(datetime.date.fromtimestamp(time.time()) ) # 时间戳直接转成日期格式 2016-08-19
    # print(datetime.datetime.now() )
    # print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
    # print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
    # print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
    # print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分
    
    
    #
    # c_time = datetime.datetime.now()
    # print(c_time.replace(minute=3,hour=2)) #时间替换

# 8.logging模块　　 #

很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别，下面我们看一下怎么用。  
最简单用法

import logging
    
    logging.warning("user [alex] attempted wrong password more than 3 times")
    logging.critical("server is down")

WARNING:root:user \[alex\] attempted wrong password more than 3 times  
CRITICAL:root:server is down

看一下这几个日志级别分别代表什么意思

<table> 
 <thead> 
  <tr> 
   <th>Level</th> 
   <th>When it’s used</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DEBUG</td> 
   <td>Detailed information, typically of interest only when diagnosing problems.</td> 
  </tr> 
  <tr> 
   <td>INFO</td> 
   <td>Confirmation that things are working as expected.</td> 
  </tr> 
  <tr> 
   <td>WARNING</td> 
   <td>An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected.</td> 
  </tr> 
  <tr> 
   <td>ERROR</td> 
   <td>Due to a more serious problem, the software has not been able to perform some function.</td> 
  </tr> 
  <tr> 
   <td>CRITICAL</td> 
   <td>A serious error, indicating that the program itself may be unable to continue running.</td> 
  </tr> 
 </tbody> 
</table>

如果想把日志写到文件里，也很简单

import logging
    
    logging.basicConfig(filename='example.log',level=logging.INFO)
    logging.debug('This message should go to the log file')
    logging.info('So should this')
    logging.warning('And this, too')

其中下面这句中的level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，在这个例子， 第一条日志是不会被纪录的，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。

logging.basicConfig(filename='example.log',level=logging.INFO)

感觉上面的日志格式忘记加上时间啦，日志不知道时间怎么行呢，下面就来加上!

import logging
    logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
    logging.warning('is when this event was logged.')

12/12/2010 11:46:36 AM is when this event was logged.

**日志格式**

<table> 
 <thead> 
  <tr> 
   <th>%(name)s</th> 
   <th>Logger的名字</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>%(levelno)s</td> 
   <td>数字形式的日志级别</td> 
  </tr> 
  <tr> 
   <td>%(levelname)s</td> 
   <td>文本形式的日志级别</td> 
  </tr> 
  <tr> 
   <td>%(pathname)s</td> 
   <td>调用日志输出函数的模块的完整路径名，可能没有</td> 
  </tr> 
  <tr> 
   <td>%(filename)s</td> 
   <td>调用日志输出函数的模块的文件名</td> 
  </tr> 
  <tr> 
   <td>%(module)s</td> 
   <td>调用日志输出函数的模块名</td> 
  </tr> 
  <tr> 
   <td>%(funcName)s</td> 
   <td>调用日志输出函数的函数名</td> 
  </tr> 
  <tr> 
   <td>%(lineno)d</td> 
   <td>调用日志输出函数的语句所在的代码行</td> 
  </tr> 
  <tr> 
   <td>%(created)f</td> 
   <td>当前时间，用UNIX标准的表示时间的浮 点数表示</td> 
  </tr> 
  <tr> 
   <td>%(relativeCreated)d</td> 
   <td>输出日志信息时的，自Logger创建以 来的毫秒数</td> 
  </tr> 
  <tr> 
   <td>%(asctime)s</td> 
   <td>字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒</td> 
  </tr> 
  <tr> 
   <td>%(thread)d</td> 
   <td>线程ID。可能没有</td> 
  </tr> 
  <tr> 
   <td>%(threadName)s</td> 
   <td>线程名。可能没有</td> 
  </tr> 
  <tr> 
   <td>%(process)d</td> 
   <td>进程ID。可能没有</td> 
  </tr> 
  <tr> 
   <td>%(message)s</td> 
   <td>用户输出的消息</td> 
  </tr> 
 </tbody> 
</table>

如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识 了

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：  
1. logger提供了应用程序可以直接使用的接口；  
2. handler将(logger创建的)日志记录发送到合适的目的输出；  
3. filter提供了细度设备来决定输出哪条日志记录；  
4. formatter决定日志记录的最终输出格式。

**logger**  
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：  
LOG=logging.getLogger(”chat.gui”)  
而核心模块可以这样：  
LOG=logging.getLogger(”chat.kernel”)

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高  
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter  
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler  
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

**handler**  
handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler  
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略  
Handler.setFormatter()：给这个handler选择一个格式  
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：  
1) logging.StreamHandler  
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：  
StreamHandler(\[strm\])  
其中strm参数是一个文件对象。默认是sys.stderr  
2) logging.FileHandler  
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：  
FileHandler(filename\[,mode\])  
filename是文件名，必须指定一个文件名。  
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a’，即添加到文件末尾。  
3) logging.handlers.RotatingFileHandler  
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：  
RotatingFileHandler( filename\[, mode\[, maxBytes\[, backupCount\]\]\])  
其中filename和mode两个参数和FileHandler一样。  
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。  
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。  
4) logging.handlers.TimedRotatingFileHandler  
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：  
TimedRotatingFileHandler( filename \[,when \[,interval \[,backupCount\]\]\])  
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。  
interval是时间间隔。  
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：  
S 秒  
M 分  
H 小时  
D 天  
W 每星期（interval==0时代表星期一）  
midnight 每天凌晨

import logging
    
    #create logger
    logger = logging.getLogger('TEST-LOG')
    logger.setLevel(logging.DEBUG)
    
    
    # create console handler and set level to debug
    ch = logging.StreamHandler()
    ch.setLevel(logging.DEBUG)
    
    # create file handler and set level to warning
    fh = logging.FileHandler("access.log")
    fh.setLevel(logging.WARNING)
    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    
    # add formatter to ch and fh
    ch.setFormatter(formatter)
    fh.setFormatter(formatter)
    
    # add ch and fh to logger
    logger.addHandler(ch)
    logger.addHandler(fh)
    
    # 'application' code
    logger.debug('debug message')
    logger.info('info message')
    logger.warn('warn message')
    logger.error('error message')
    logger.critical('critical message')

import logging
    
    from logging import handlers
    
    logger = logging.getLogger(__name__)
    
    log_file = "timelog.log"
    #fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
    fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)
    
    
    formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
    
    fh.setFormatter(formatter)
    
    logger.addHandler(fh)
    
    
    logger.warning("test1")
    logger.warning("test12")
    logger.warning("test13")
    logger.warning("test14")

[https_docs.python.org_3_library_string.html]: https://docs.python.org/3/library/string.html
[Link 1]: http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431756044276a15558a759ec43de8e30eb0ed169fb11000