day--6_python常用模块

标签：art   lib   pytho   核心模块   sys   hmm   this   自己的   mat   

常用模块：

1. time和datetime

2. shutil模块

3. radom

4. string

5. shelve模块

6. xml处理

7. configparser处理

8. hashlib

9. subprocess

10. logging模块

11. re正则表达式

time模块

time模块，即时间模

import time    # 导入时间模块

print(time.process_time())  # 返回处理时间，不包含sleep时间，mac上测试不出来

print(time.asctime())  # 返回时间格式Mon Nov 14 10:07:07 2016

print(time.localtime())  # 返回被点时间对象struct time：time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=10, tm_min=8, tm_sec=41, tm_wday=0, tm_yday=319, tm_isdst=0)

print(time.altzone)   # 返回UTC时间差，以秒计算
print(time.time())    # 返回时间戳

‘‘‘
# 返回UTC时间的struc时间对象格式：
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=3,
tm_hour=16, tm_min=14, tm_sec=11,
tm_wday=3, tm_yday=308, tm_isdst=0)
‘‘‘
print(time.gmtime(time.time()-900000))

print(time.asctime(time.localtime()))   # 返回时间格式：Mon Nov 14 10:14:11 2016

print(time.ctime())  # 返回格式：Mon Nov 14 10:15:12 2016

# 日期字符串转换为时间戳
time2 = time.strptime("2016/11/13 22:22:22", ‘%Y/%m/%d %H:%M:%S‘) # 将日期字符串转换为时间对象
print(time2)

time2_stamp = time.mktime(time2)     # 将时间对象转换为时间戳
print(time2_stamp)

time2_time = time.asctime(time2)    # 将时间戳转换为时间格式
print(time2_time)

# 将时间戳转换为字符串格式
time3 = time.gmtime(time2_stamp) # 返回时间对象
print(time3)
print(time.strftime(‘%Y/%m/%d %H:%M:%S‘, time3))   # 返回格式：2016/11/13 14:22:22

datetime模块

时间模块

import datetime
import time
# 返回当前时间
print(datetime.datetime.now())  # 返回格式：2016-11-14 10:32:10.415558

#时间戳直接转换为日期格式
print(datetime.datetime.fromtimestamp(time.time())) # 返回格式：2016-11-14 10:32:10.415558

# 当前时间加3天
print(datetime.datetime.now() + datetime.timedelta(3))  # 返回结果：2016-11-17 10:43:07.668299

# 当前时间减3天
print(datetime.datetime.now() - datetime.timedelta(3))  # 返回结果2016-11-11 10:43:07.668299

# 当前时间加3小时
print(datetime.datetime.now() - datetime.timedelta(hours=3))  # 返回结果2016-11-14 07:43:07.668299

# 当前时间减30分钟

print(datetime.datetime.now() - datetime.timedelta(minutes=30))  # 返回结果：2016-11-14 10:13:07.668299

# 时间替换
c_time = datetime.datetime.now()    # 返回2016-11-14 10:54:44.986484
print(c_time.replace(minute=3,hour=2))  # 返回：2016-11-14 02:03:44.986484

常用时间字符

radom随机数

随机数模块

import random  # 导入随机数模块
import string  # 导入字符串模块

print(random.random())  # 生成随机数

print(random.randint(1, 5))  # 生成1-5的随机数包含5本身，每次显示一个

print(random.randrange(1, 5))  # 生成1-5的随机数,不包含5本身,每次显示一个

print(random.sample(range(10), 5))  # 生成5个随机数，格式为列表格式[7, 0, 1, 9, 5]

# 生成随机验证码

print(‘‘.join(random.sample(string.ascii_lowercase, 5)))  # 生成5个随机字母 返回：kbzdn

print(‘‘.join(random.sample(string.ascii_letters, 5)))  # 生成5个随机验证码 返回：sNpGj


# 生成随机验证码的另一种方法
checkcode = ‘‘
for i in range(4):
    current = random.randrange(0, 4)
    if current != i:
        ‘‘‘
        chr(random.randint(65, 90))将数字转换为ascii码的对应表
        chr(65) = A,chr(66) = B
        ‘‘‘
        temp = chr(random.randint(65, 90))
    else:
        temp = random.randint(0, 9)
    checkcode += str(temp)
print(checkcode)

string字符模块

import string  # 导入字符串模块

print(string.ascii_letters)  # 返回：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

print(string.ascii_lowercase)  # 返回：abcdefghijklmnopqrstuvwxyz

print(string.ascii_uppercase)  # 返回：ABCDEFGHIJKLMNOPQRSTUVWXYZ

print(string.digits)  # 返回：0123456789

print(string.hexdigits)  # 返回16进制：0123456789abcdefABCDEF

print(string.octdigits)  # 返回8进制整数：01234567

shutil

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

例子1：shutil.copyfileobj()

将文件内容拷贝到另一个文件中吗，可以拷贝部分内容：

import shutil
f = open(‘test.xml‘,‘r‘,encoding=‘utf-8‘)
 f1 = open(‘test_new.xml‘,‘w‘,encoding=‘utf-8‘)
shutil.copyfileobj(f,f1) 
# shutil.copyfileobj()方法需要打开文件才能拷贝

例子2：shutil.copyfile()

拷贝文件

import shutil
shutil.copyfile(‘test.xml‘,‘test_new_1.xml‘)

例子3：

shutil.copymode(stc,dst)

import shutil
# shutil.copymode(stc,dst)  # 仅拷贝权限，内容、组用户均不变
# src源文件，dst目标
shutil.copymode(‘test.xml‘, ‘test_new_1.xml‘)

例子4：shutil.copy(stc,dst)

# 拷贝文件和权限

import shutil

# 拷贝文件和权限
# shutil.copy(stc,dst)
shutil.copy(‘test.xml‘, ‘test_new_1.xml‘)

例子5：shutil.copy2() 拷贝文件和状态信息

import shutil
# shutil.copy2() 拷贝文件和状态信息
shutil.copystat(‘test.xml‘, ‘test_new_1.xml‘)

例子6：shutil.copystat() 拷贝文件和状态信息

import shutil
# shutil.copystat() 拷贝文件和状态信息
shutil.copystat(‘test.xml‘, ‘test_new_1.xml‘)

例子7：shutil.copy2(src, dst)

import shutil
# shutil.copy2(src, dst)
# 拷贝文件和状态信息
shutil.copy2(‘test.xml‘, ‘test_new_1.xml‘)

例子8：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对象

# 将D:\python_progream\python_s15\day6 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("start", format=‘zip‘, root_dir=‘D:\python_progream\python_s15\day6‘)

结果：

zipfile模块

zip压缩，shutil对压缩包的处理是调用zipfile和taifile模块来进行的

zipfile代码

import zipfile

# 压缩
z = zipfile.ZipFile(‘testabc.zip‘, ‘w‘)
z.write(‘xml_mode.py‘)
z.write(‘timelog.log‘)
z.close()

# 解压
z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
z.extractall()
z.close()
#
# zipfile 压缩解压

tarfile代码

import tarfile

# 压缩
tar = tarfile.open(‘your.tar‘,‘w‘)
tar.add(‘/Users/xiaofeng/PycharmProjects/bbs2.zip‘, arcname=‘bbs2.zip‘)
tar.add(‘/Users/xiaofeng/PycharmProjects/cmdb.zip‘, arcname=‘cmdb.zip‘)
tar.close()

# 解压
tar = tarfile.open(‘xxx.tar‘,‘r‘)
tar.extractall()  # 可设置解压地址
tar.close()

tarfile 压缩解压

shelve模块

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

要使用shelve模块，必须要导入模块:import shelve

import shelve

f = shelve.open(‘shelve_test‘) #打开一个文件

def stu(name, age):
    print(‘stu‘,name, age)
t2 = (1, 2, 3, 4)
name = ["aaa", "rain", "test"]
f["test"] = name  # 持久化列表
f["t2"] = t2    # 持久化元组
f["func"] = stu  # 持久化函数

f.close()

shleve读取

import shelve

def stu(name, age):
    print(‘stu‘, name, age)
    return 0
f = shelve.open(‘shelve_test‘)
print(f["test"])   # 返回[‘aaa‘, ‘rain‘, ‘test‘]
print(f["test"][1])  # 返回：rain
print(f[‘t2‘])     # 返回：(1, 2, 3, 4)
print(f[‘t2‘][2])  # 返回：3
print(f["func"](‘xao‘, 22))   # 返回：stu xao 22

xml处理模块

xml是实现不同语言或程序之间进行数据交换协议，跟json差不多，但是json使用起来简单，不过，古时候，在json还没有诞生的年代，大家只能用xml，只进很多传统公司还在用xml

xml格式如下，就是通过<>节点来区别数据结构的：

<?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>

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

如果要操作xml格式的文件

首先需要引入xml相关模块

import xml.etree.ElementTree as ET
tree = ET.parse("test.xml")
root = tree.getroot()
print(root.tag)   # tag首行
# for child in root:
#     print(child.tag, child.attrib)
#     for i in child:
#         print(i.tag, i.text)    # text打印值

# 返回值：
‘‘‘
data
country {‘name‘: ‘Liechtenstein‘}
rank 2
year 2008
gdppc 141100
neighbor None
neighbor None
country {‘name‘: ‘Singapore‘}
rank 5
year 2011
gdppc 59900
neighbor None
country {‘name‘: ‘Panama‘}
rank 69
year 2011
gdppc 13600
neighbor None
neighbor None
‘‘‘

# 只遍历year节点
# for node in root.iter(‘year‘):
#     print(node.tag, node.text)
# 返回值：
‘‘‘
year 2008
year 2011
year 2011
‘‘‘

#  修改
# 遍历所有年并修改年的值+1
for node in root.iter(‘year‘):
    new_year = int(node.text) + 1  # 所有的年的值加1
    node.text = str(new_year)   # 将new_year中的数字转换为字符串
    node.set("updated", "yes")  # 所有的年添加属性
tree.write("test1.xml")

# 删除
# 删除node
for country in root.findall(‘country‘):  # findall查找所有
    rank = int(country.find(‘rank‘).text)  # 将rank的值付给rank，并转换为整数
    if rank > 50:
        root.remove(country)    # 移除一个country标签
tree.write(‘test2.xml‘)

# 创建一个xml文件
new_xml = ET.Element("dev")  # 创建根标签，dev为根标签的名字
name = ET.SubElement(new_xml, "name", attrib={"enrolled":"yes"}) # 创建子标签，子标签的名字为name
# attrib指定属性
# 返回值
age = ET.SubElement(name, "age", attrib={"enrolled":"yes"}) # 设置name的子标签age,并设置属性
sex = ET.SubElement(name, "sex")  # 设置子标签中的子标签
sex.text = ‘33‘   # 设置sex的值
et = ET.ElementTree(new_xml)
et.write("test3.xml", encoding="utf-8",xml_declaration=True)
# 返回值：<?xml version=‘1.0‘ encoding=‘utf-8‘?>
# ET.dump(test3.xml) #打印生成的格式

生成的文件

<?xml version=‘1.0‘ encoding=‘utf-8‘?>

<dev> 

    <name enrolled="yes">

        <age enrolled="yes" /> 

        <sex>33</sex>

    </name>

</dev>

configparser模块

用于生成常见的配置文档，当前名称在python3版本中变更为configparser，在2版本中首字母是大写。

configparser生成的常见配置文件如下：

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
 
[bitbucket.org]
User = hg
 
[topsecret.server.com]
Port = 50022
ForwardX11 = no

如果想用python生成一个这样的文档怎么做：

import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
                      ‘Compression‘: ‘yes‘,
                     ‘CompressionLevel‘: ‘9‘}
config[‘xuanchuan.org‘] = {}
config[‘xuanchuan.org‘][‘user‘] = ‘hg‘
config[‘top.server.com‘] = {}
top = config[‘top.server.com‘]
top[‘Host Port‘] = ‘56666‘
top[‘ForwardX11‘] = ‘no‘
config["DEFAULT"][‘ForwardX11‘] = ‘yes‘
with open(‘config.ini‘,‘w‘) as f:
    config.write(f)

粘贴结果：

[DEFAULT]
compressionlevel = 9
serveraliveinterval = 45
compression = yes
forwardx11 = yes

[xuanchuan.org]
user = hg

[top.server.com]
host port = 56666
forwardx11 = no

config.ini文件操作：

# 读取config.ini文件
import configparser
config = configparser.ConfigParser()
config.sections()

print(config.read(‘config.ini‘))  # 返回值[‘config.ini‘]
print(config.sections())   # 返回:[‘xuanchuan.org‘, ‘top.server.com‘]，默认[DEFAULT]不读取
print(config["DEFAULT"][‘forwardx11‘])  # 返回值：yes
print(config[‘top.server.com‘][‘Host Port‘])  # 返回值：56666,此处key是不区分大小写的

# 遍历config.ini文件
for key in config[‘top.server.conf‘]:
    print(key)

# 改‘
config[‘top.server.com‘][‘Host Port‘] = ‘222‘
print(config[‘top.server.com‘][‘Host Port‘])
with open(‘config1.ini‘, ‘w‘) as f:
    config.write(f)

hashlib模块

用于加密的模块，3.x里代替了md5模块和sha模块，主要提供sha1,sha224,sha256,sha384,sha512,MD5算法

import hashlib
m = hashlib.md5()
m.update(b‘hello‘)
# print(m.digest())  # 二进制格式的hash
print(m.hexdigest())  # 16禁止格式的hash
# 返回值：5d41402abc4b2a76b9719d911017c592
###md5算法
m.update(b‘admin‘)
print(m.hexdigest())
# 返回值：dbba06b11d94596b7169d83fed72e61b

# # sha1算法
sha_1 = hashlib.sha1()
sha_1.update(b"admin")
print(sha_1.hexdigest())
# 返回值：d033e22ae348aeb5660fc2140aec35850c4da997

# ##sha224算法
sha_224 = hashlib.sha224()
sha_224.update(b"admin")
print(sha_224.hexdigest())
# 返回值：58acb7acccce58ffa8b953b12b5a7702bd42dae441c1ad85057fa70b

# ## sha256算法
sha_256 = hashlib.sha256()
sha_256.update(b"admin")
print(sha_256.hexdigest())
# 返回值：8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918

# ## sha384算法
sha_384 = hashlib.sha384()
sha_384.update(b"admin")
print(sha_384.hexdigest())
# 返回值：9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782

# ## sha512算法
sha_512 = hashlib.sha512()
sha_512.update(b"admin")
print(sha_512.hexdigest())
# 返回值：c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec

hmac模块

加严算法

import hmac   # 引入模块，用于消息传输，类似于QQ消息
h = hmac.new(b‘alber‘)
h.update(b"hello")
print(h.hexdigest())
# 返回值：1b6752f035a051eb026c3824de78a714
# 或者
h = hmac.new(b‘alber‘,b‘hello‘)
print(h.hexdigest())
# 返回值：1b6752f035a051eb026c3824de78a714

logging模块

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

最简单的用法：

此处需要粘贴代码

下面看下这几个日志级别分别代表什么含义：

如果想把日志写到文件也很简答：

import logging
logging.basicConfig(filename=‘log.log‘,level=logging.DEBUG) #默认是追加模式a
logging.debug("this is debug")
logging.info("this is info")
logging.warning("user[alber] attempet warning")
logging.critical("mysql server is down")

日志文件：

DEBUG:root:this is debug
INFO:root:this is info
WARNING:root:user[alber] attempet warning
CRITICAL:root:mysql server is down

日志格式format=

例子：

import logging
logging.basicConfig(filename=‘log.log‘,level=logging.DEBUG) #默认是追加模式a
logging.debug("this is debug")
logging.info("this is info")
logging.warning("user[alber] attempet warning")
logging.critical("mysql server is down")

# 返回值：log.log文件

logging.basicConfig(filename=‘log.log‘, level=logging.DEBUG,
                    format=‘%(asctime)s  %(levelname)s:%(message)s‘,
                    datefmt=‘%Y-%m-%d %I:%M:%S %p‘)  # 默认是追加模式a
logging.debug("this is debug")
logging.info("this is info")
logging.warning("user[alber] attempet warning")
logging.critical("mysql server is down")

logger = logging.getLogger("nginx")  # 指定程序名
logger.setLevel(logging.DEBUG)   #设定程序的日志级别

日志文件：

2016-11-14 05:34:02 PM  WARNING: user[alber] attempet warning

2016-11-14 05:34:02 PM  CRITICAL: mysql server is down

2016-11-14 05:34:17 PM  DEBUG:this is debug

2016-11-14 05:34:17 PM  INFO:this is info

2016-11-14 05:34:17 PM  WARNING:user[alber] attempet warning

2016-11-14 05:34:17 PM  CRITICAL:mysql server is down

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

python使用logging模块记涉及四个主要类，使用官方文档的概述最为合适：

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

handler将（logger创建）日志记录发送到合适的目的输出

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

formatter决定记录日志的最终输出格式

logger

每个程序在输出信息之前偶要获得一个logger。logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的logger:

log=logging.getlogger("char.gui")

而核心模块可以这样

log=logging.getlogger("kerenel")

logger.setLevel(level):指定日志最低级别,低于level的级别将被忽略，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(level):指定被处理的信息级别，低于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
logger = logging.getLogger("nginx")  # 指定程序名
logger.setLevel(logging.DEBUG)   #设定程序的日志级别

# 指定log的显示方式
ch = logging.StreamHandler()  # 显示器屏幕方式输入
ch.setLevel(logging.DEBUG)    # 显示器屏幕输入的日志级别

fh = logging.FileHandler(‘access.log‘)  # 显示器文件输出,access.log是日志文件名字
fh.setLevel(logging.WARNING)  # 显示器文件输出的日志级别

# 指定日志格式
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

ch.setFormatter(formatter)
fh.setFormatter(formatter)

logger.addHandler(ch)
logger.addHandler(fh)

logger.debug("this is debug")
logger.info("this is info")
logger.warning("user[alber] attempet warning")
logger.critical("mysql server is down")

日志文件：

2016-11-14 18:22:45,612 - nginx - WARNING - user[alber] attempet warning
2016-11-14 18:22:45,613 - nginx - CRITICAL - mysql server is down

日志切割例子：

import logging
from logging import handlers

logger = logging.getLogger("nginx")

log_file = "timelog.log"

# 以大小切割
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
# maxBytes，多少字节切割，backupCount,保留的分数

# 以时间切割
fh = handlers.TimedRotatingFileHandler(filename=log_file,
                                       when="S", interval=5, backupCount=3)
# when= ‘S‘ 指定单位为秒 interval= 5 表示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")

re模块

常用的正则表达式模块

最常用的匹配语法

re.match从头开始匹配

re.search 配额包含

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

re.splitall 以匹配到的字符当作列表分割符

re.sub 匹配字符串并替换

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

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

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

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

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

例子：

day--6_python常用模块

标签：art   lib   pytho   核心模块   sys   hmm   this   自己的   mat   

原文地址：http://www.cnblogs.com/alber/p/6075018.html