python之路-16-常用模块学习-白红宇

python之路-16-常用模块学习

阅读量：6293 次

发布时间：2019-06-22

本文共 19550 字，大约阅读时间需要 65 分钟。

16.1模块定义

定义：用一砣代码实现了某个功能的代码集合（n个 .py 文件组成的代码集合就称为模块）

模块分为三种：

自定义模块

内置标准模块（又称标准库）

开源模块

16.2导入方法

单个模块导入：import module_name

一个模块多个函数：from module_lanhan import *

别名导入：from module_lanhan import def_name as module_lanhan_def_name

多模块一起导入需要用逗号（，）隔开

Import module_lanhan与from module_lanhan import * （as）区别：

module_lanhan.py文件代码：

#!Author:lanhan

name = "lanhan"
def say_hello():

print('hello lanhan')

def logger():

print('in the module lanhan')

def running():

pass

Import导入后的引用示例1：

import module_lanhan ####单个导入模块

print(module_lanhan.name)

module_lanhan.say_hello()

本质：将模块里面的代码执行一遍赋值给模块名（模块名可看作一个变量）

from module_lanhan import *导入后的引用示例1：

print(name)

say_hello()

from module_lanhan import def_name as 别名导入后的引用示例1：

from module_lanhan import logger as logger_lanhan

def logger(): ###如果文件与调用模块函数或变量同名，本地函数或变量会覆盖导入模块相同的函数和变量
print('in the main')

#logger()
logger_lanhan()

本质：将模块的代码cp到执行文件里，执行一遍

总结导入本质：导入模块的本质就是把python文件解释一遍

包定义：用来从逻辑上组织模块的，本质就一个目录（必须带有一个__init__.py文件）

16.3包

__init__.py文件代码：

print('from the package package_lahan')

Package_test.py代码：

import package

导入包的本质就是执行该包下的__init__.py文件

16.4常用模块

16.4.1 time

在Python中，通常有这几种方式来表示时间：1）时间戳 2）格式化的时间字符串 3）元组（struct_time）共九个元素

UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。

时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。返回时间戳方式的函数主要有time()，clock()等。

元组（struct_time）方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，localtime()，strptime()。下面列出这种方式元组中的几个元素：

#!Author:lanhan

import time

print(time.time())

print(time.localtime())

print(time.timezone)       ###28800/3600 = 8 中国在东八区
print(time.daylight)       ###是否使用夏令时
print(time.sleep(2))        ###睡2秒
print(time.gmtime())        ###若参数为空，将当前时间戳传进去得到标准时间（UTC）元组（有参数就是所传的值）
print(time.localtime())      ###若参数为空，将当前时间戳传进去得到本地时间（本地UTC+8）元组
print(time.localtime().tm_year)

print('this is 2360 day:%d'%time.localtime(12322222221).tm_yday) ###从时间戳转换成元组
print(time.mktime(time.localtime())) ###从元组转换成时间戳
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) ###将元组转换成格式化的字符串
print(time.strptime("2017-11-16 22:38:38","%Y-%m-%d %H:%M:%S"))

print(time.asctime()) ###将元组转换成固定字符串，不传参数就默认当前时间
print(time.ctime()) ###将时间戳转换成固定字符串，不传参数就默认当前时间戳
#help(time)
#help(time.gmtime)
#help(time.mktime)
#help(time.strftime)
#help(time.strptime)
#help(time.asctime)
#help(time.ctime)

格式参照：

%a 本地（locale）简化星期名称

%A 本地完整星期名称

%b 本地简化月份名称

%B 本地完整月份名称

%c 本地相应的日期和时间表示

%d 一个月中的第几天（01 - 31）

%H 一天中的第几个小时（24小时制，00 - 23）

%I 第几个小时（12小时制，01 - 12）

%j 一年中的第几天（001 - 366）

%m 月份（01 - 12）

%M 分钟数（00 - 59）

%p 本地am或者pm的相应符一

%S 秒（01 - 61）二

%U 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。三

%w 一个星期中的第几天（0 - 6，0是星期天）三

%W 和%U基本相同，不同的是%W以星期一为一个星期的开始。

%x 本地相应日期

%X 本地相应时间

%y 去掉世纪的年份（00 - 99）

%Y 完整的年份

%Z 时区的名字（如果不存在为空字符）

%% ‘%’字符

16.4.2 datetime

#!Author:lanhan

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)) #时间替换

注：用pycharm执行报错？

16.4.3 random模块

#!Author:lanhan

import random

print(random.random())        ###生成一个[0,1]之间的随机符点数
print (random.randint(1,7))   ###生成一个指定范围内的整数，a <= n <= b （1和7都能取）
print (random.randrange(1,3)) ###不包含最后一位
print(random.randrange(0, 101, 2)) ###随机选取0到100间的偶数
print(random.choice('hello')) ###从序列中获取一个随机元素
print(random.choice('[1,2,3,4]')) ###从序列中获取一个随机元素
print(random.sample('hello',2))   ###从序列中随机取2位
print(random.uniform(1,3))     ###生成一个[1,3]之间的随机符点数

示例1:

##洗牌
import random

items = [1,2,3,4,5,6,7]

print(items)

random.shuffle(items)

print(items)

示例2：

##生成随机验证码
checkcode = ''
for i in range(4):

#print(i)
current=random.randint(0,4)

print(current)

if current == i:

tmp=chr(random.randint(65,90))

else:

tmp=random.randint(0,9)

checkcode+=str(tmp)

print(checkcode)

16.4.4 OS模块

#!Author:lanhan

import os

print(os.getcwd()) ###获取当前目录
os.chdir("C:\\Users") ###改变当前脚本工作目录；相当于shell下cd
print(os.getcwd())

os.chdir(r"C:\Users") ###改变当前脚本工作目录；相当于shell下cd
print(os.getcwd())

print(os.curdir)           ###返回当前目录: ('.')
print(os.pardir)           ###获取当前目录的父目录字符串名：('..')
#os.makedirs(r"C:/a/b/c/d") ###可生成多层递归目录
os.removedirs(r"C:/a/b/c/d")###若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.rmdir(r"C:/a")            ###删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.mkdir(r"C:/a")     ###生成单级目录；相当于shell中mkdir dirname
os.listdir('.')        ###列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()             ###删除一个文件
os.rename("oldname","newname") ###重命名文件/目录
os.stat('path/filename')    ### 获取文件/目录信息
print(os.sep)       ###输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
print(os.linesep)    ###输出当前平台使用的行终止符(换行符)，win下为"\r\n",Linux下为"\n"
print(os.environ) ###查看当前系统的环境变量
print(os.pathsep)    ###输出用于分割文件路径的字符串（windows用分号； liunx用冒号：）.
print(os.name)    ###输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") ###运行shell命令，直接显示
os.path.abspath(path) ###返回path规范化的绝对路径
os.path.split(path)   ###将path分割成目录和文件名二元组返回
os.path.dirname(path) ###返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) ###返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(r'C:\a')    ###如果path存在，返回True；如果path不存在，返回False
os.path.isabs(r'C:\a')      ###如果path是绝对路径，返回True
os.path.isfile(r'C:\client.txt')     ###如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(r'C:\a')     ###如果path是一个存在的目录，则返回True。否则返回False
#os.path.join(path1[, path2[, ...]]) ###将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.join(r'C:',r'\a.txt')

os.path.getatime(r'\a.txt') ###返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(r'\a.txt') ###返回path所指向的文件或者目录的最后修改时间

16.4.5 sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径(传输入的参数)

sys.exit(n) 退出程序，正常退出时exit(0)

sys.version 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.stdout.write('please:')

16.4.6 shutil模块

参考：http://www.cnblogs.com/wupeiqi/articles/4963027.html

高级的文件、文件夹、压缩包处理模块

shutil.copyfileobj(fsrc, fdst[, length])

示例1：

import shutil

f1 = open("本节笔记",encoding="utf-8")

f2 = open("笔记2","w",encoding="utf-8")

shutil.copyfileobj(f1,f2)

shutil.copyfile(src, dst) 拷贝文件

示例2：

shutil.copyfile("笔记2","笔记3")

shutil.copymode(src, dst) ###仅拷贝权限。内容、组、用户均不变

shutil.copystat(src, dst) ###拷贝状态的信息，包括：mode bits, atime, mtime, flags，前提是dst文件已经存在

shutil.copy(src, dst) ###拷贝文件和权限

shutil.copy2(src, dst) ###拷贝文件和状态信息

shutil.copytree(src, dst) ###递归的去拷贝文件（复制目录）

shutil.rmtree(path[, ignore_errors[, onerror]]) ###递归的去删除文件

shutil.move(src, dst) ###递归的去移动文件

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

base_name：压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

如：www =>保存至当前路径

如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/

format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir：要压缩的文件夹路径（默认当前目录）

owner：用户，默认当前用户

group：组，默认当前组

logger：用于记录日志，通常是logging.Logger对象

示例3：

shutil.make_archive("shutil_archive_test","zip")

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，如：

import zipfile

z = zipfile.ZipFile("day4.zip","w")

z.write("time.py")

z = zipfile.ZipFile("day4.zip","r") ###解压

z.extractall()

z.close()

import tarfile

tar = tarfile.open("day4.tar","w")

tar.add("day4.zip",arcname="day4.zip") ###压缩
tar.close()

tar = tarfile.open('day4.tar','r')

tar.extractall() ### 解压
tar.close()

16.4.7 shelve模块

shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

import shelve

###写
'''
d = shelve.open('shelve_test') #打开一个文件
info = {'age':22,'job':'it'}
name = ["alex","rain","test"]
d["name"] = name #持久化列表
d["info"] = info #持久化dict
d.close()
'''
###读
d = shelve.open('shelve_test') #打开一个文件
print(d.get("name"))

print(d.get("info"))

16.4.8 xml处理模块

16.4.8.1 xml查询

xml协议在各个语言里的都是支持的，在python中可以用以下模块操作xml

Xmltest内如如下：

<?xml version="1.0"?>

<data>

<country name="Liechtenstein">

<rank updated="yes">2</rank>

<year>2008</year>

<gdppc>141100</gdppc>

<neighbor name="Austria" direction="E"/>

<neighbor name="Switzerland" direction="W"/>

</country>

<country name="Singapore">

<rank updated="yes">5</rank>

<year>2011</year>

<gdppc>59900</gdppc>

<neighbor name="Malaysia" direction="N"/>

</country>

<country name="Panama">

<rank updated="yes">69</rank>

<year>2011</year>

<gdppc>13600</gdppc>

<neighbor name="Costa Rica" direction="W"/>

<neighbor name="Colombia" direction="E"/>

</country>

</data>

示例1：

#!Author:lanhan

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

#遍历xml文档
for child in root:

print(child.tag, child.attrib)

for i in child:

print(i.tag,i.text)

#只遍历year 节点
for node in root.iter('year'):

print(node.tag,node.text)

16.4.8.2xml修改即删除

示例1：

#!Author:lanhan

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

#修改
for node in root.iter('year'):

new_year = int(node.text) + 1

node.text = str(new_year)

node.set("updated","yes")

tree.write("xmltest.xml")

#删除node
for country in root.findall('country'):

rank = int(country.find('rank').text)

if rank > 50:

root.remove(country)

tree.write('output.xml')

16.4.8.2xml新建想xml文档

示例1：

#!Author:lanhan

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")

name = ET.SubElement(new_xml,"name",attrib={

"enrolled":"yes"})

age = ET.SubElement(name,"age",attrib={

"checked":"no"})

sex = ET.SubElement(name,"sex")

age.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={

"enrolled":"no"})

age = ET.SubElement(name2,"age")

age.text = '19'
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

16.4.9 PyYAML模块

使用前先安装

参考：http://pyyaml.org/wiki/PyYAMLDocumentation

from yaml import load, dump

try:

from yaml import CLoader as Loader, CDumper as Dumper

except ImportError:

from yaml import Loader, Dumper

# ...

data = load(stream, Loader=Loader)

# ...

output = dump(data, Dumper=Dumper)

16.4.10 ConfigParser模块

注：用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser，2.x为Configparser

16.4.10.1 生成文件

#!Author:lanhan

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {

'ServerAliveInterval': '45',

'Compression': 'yes',

'CompressionLevel': '9'}

config['bitbucket.org'] = {}

config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}

topsecret = config['topsecret.server.com']

topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:

config.write(configfile)

生成的example.ini文件内容如下：

[DEFAULT]

serveraliveinterval = 45
compression = yes
compressionlevel = 9
forwardx11 = yes

[bitbucket.org]
user = hg

[topsecret.server.com]
host port = 50022
forwardx11 = no

16.4.10.2 解析文件

#!Author:lanhan

import configparser

conf = configparser.ConfigParser()

conf.read("example.ini")

print(conf.defaults())

print(conf['bitbucket.org']['user'])

16.4.10.3 修改文件

###修改

import configparser

conf = configparser.ConfigParser()

sec= conf.remove_section('bitbucket.org')

conf.write(open('example.ini',"w"))

sec = conf.has_section('wupeiqi')

sec = conf.add_section('wupeiqi')

conf.write(open('example.ini', "w"))

conf.set('wupeiqi','k1','11')

conf.write(open('example.ini', "w"))

16.4.11hashlib&hmac模块

参考:https://www.tbs-certificates.co.uk/FAQ/en/sha256.html

用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

m = hashlib.md5()

m.update(b"Hello")

print(m.hexdigest())

m.update(b"It's me")

print(m.hexdigest())

m.update(b"It's been a long time since we spoken...")

print(m.hexdigest())

m2 = hashlib.md5()

m2.update(b"HelloIt's me")

print(m2.hexdigest())

s2 = hashlib.sha1()

s2.update(b"It's me")

print(s2.hexdigest())

扩： hmac 模块

python 还有一个 hmac 模块，它内部对我们创建 key 和内容再进行处理然后再加密

散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；

一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，然后消息发送把用key把消息加密，接收方用key ＋消息明文再加密，拿加密后的值跟发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了

import hmac

h = hmac.new(b"12345","250".encode(encoding='utf-8'))

print(h.digest())

print(h.hexdigest())

16.4.12 hashlib模块

16.4.13 Subprocess模块

16.4.14 logging模块

#!Author:lanhan

import logging

logging.basicConfig(filename="app.log",

level=logging.DEBUG,

format='%(asctime)s %(filename)s-%(lineno)d %(module)s (levelname)s %(message)s',

datefmt='%m/%d/%Y %I:%M:%S %p') ###默认为warning
logging.debug("test debug")

logging.info("test info")

logging.warning("user [alex] attempted wrong password more than 3 times")

logging.error("test error")

logging.critical("server is down")

app.log文件内容：

11/19/2017 03:16:48 PM loggingģ��.py-7 loggingģ�� (levelname)s test debug

11/19/2017 03:16:48 PM loggingģ��.py-8 loggingģ�� (levelname)s test info

11/19/2017 03:16:48 PM loggingģ��.py-9 loggingģ�� (levelname)s user [alex] attempted wrong password more than 3 times

11/19/2017 03:16:48 PM loggingģ��.py-10 loggingģ�� (levelname)s test error

11/19/2017 03:16:48 PM loggingģ��.py-11 loggingģ�� (levelname)s server is down

注：level等级默认为WARNING，那么只会输出包含WARNING级别以上的日志

日志格式：

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

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

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：

logger提供了应用程序可以直接使用的接口；

handler将(logger创建的)日志记录发送到合适的目的输出（远程机器、邮件）；

filter提供了细度设备来决定输出哪条日志记录；

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'，即添加到文件末尾。

示例1：

#!Author:lanhan

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.WARNING)

# create file handler and set level to warning
fh = logging.FileHandler("access.log",encoding="utf-8")

fh.setLevel(logging.ERROR)

# create formatter
fh_formatter = logging.Formatter('%(asctime)s %(filename)s:%(lineno)d %(module)s (levelname)s %(message)s')

ch_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(fh_formatter)

ch.setFormatter(ch_formatter)

logger.addHandler(fh)

logger.addHandler(ch)

logger.warning("warning commint........")

logger.error("error commint.........")

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 每天凌晨

示例2：日志切割

#!Author:lanhan

import logging

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3,encoding="utf-8")
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3,encoding="utf-8")

formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)

import time

logger.warning("test1")

time.sleep(2)

logger.warning("test12")

time.sleep(2)

logger.warning("test13")

logger.warning("test14")

time.sleep(2)

logger.warning("test15")

logger.warning("test16")

16.4.15 re模块

常用正则表达式符号

'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行

'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$' 匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以

'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']

'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']

'?' 匹配前一个字符1次或0次

'{m}' 匹配前一个字符m次

'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']

'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'

'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c

re.search(“(\d{2})(\d{2})(\d{4})”,”371481199206143421” name:alex”).groups()结果

(‘37’,’14’,’8119’)

'\A' 只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的

'\Z' 匹配字符结尾，同$

'\d' 匹配数字0-9

'\D' 匹配非数字

'\w' 匹配[A-Za-z0-9]

'\W' 匹配非[A-Za-z0-9]

's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

注：.groups() 元组格式

groupdict() 字典格式

最常用的匹配语法

re.match 从头开始匹配

re.search 匹配包含

re.search(“\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}”,”inet 地址:192.168.12.55 广播192.168.12.255”)

re.search(“(\d{1,3}\.){3}\d{1,3}”,”inet 地址:192.168.12.55 广播192.168.12.255”)

re.findall 把所有匹配到的字符放到以列表中的元素返回

re.findall(“\d+”,”ab3c4sdfd45634sfsd26ds6”)

返回结果：[‘3’,’4’,’45634’,’26’,’6’]

re.findall(“\D+”,”ab3c4sdfd45634sfsd26ds6”)

返回结果：[‘ab’,’c’,’sdfd’,’sfsd’,’ds’]

re.split以匹配到的字符当做列表分隔符

re.split(“\d+”,”ab3c4sdfd45634sfsd26ds6”)

返回结果：[‘ab’,’c’,’sdfd’,’sfsd’,’ds’，‘’]

re.sub 匹配字符并替换

re.sub(“\d+”,”|”,”ab3c4sdfd45634sfsd26ds6”)

返回结果：‘ab|c|sdfd|sfsd|ds’

re.sub(“\d+”,”|”,”ab3c4sdfd45634sfsd26ds6”,count=2)

返回结果：’ab|c|sdfd45634sfsd26ds6’

注：反斜杠的困扰

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。