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

标签：+=   filter   version   sts   bash   mat   代码实现   网络通信   mutate   

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级别以上的日志

日志格式：

如果想同时把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"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

仅需轻轻知道的几个匹配模式：

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）

例：re.search(‘a’,r’ABC’,flags=re.I)

M(MULTILINE): 多行模式，改变‘^‘和‘$‘的行为（参见上图）

例：re.search(r”^a”,”\nabc\neee”,flags=re.M)

S(DOTALL): 点任意匹配模式，改变‘.‘的行为

re.search(r”.+”,”\nabc\neee”,flags=re.S)

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

标签：+=   filter   version   sts   bash   mat   代码实现   网络通信   mutate   

原文地址：http://www.cnblogs.com/decorator/p/7898871.html