Python_Day6_Pyhotn常用模块学习

本节大纲：

  1. 模块介绍
  2. time &datetime模块
  3. random
  4. os
  5. sys
  6. shutil
  7. json & picle
  8. shelve
  9. xml处理
  10. yaml处理
  11. configparser
  12. hashlib
  13. subprocess
  14. logging模块
  15. re正则表达式

 

模块，实现了某个功能的代码集合。 

类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

  • 自定义模块
  • 内置标准模块（又称标准库）
  • 开源模块

自定义模块 和开源模块的使用参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html

 

time & datetime模块

import time
import datetime

print(time.process_time())#返回处理器时间
print(time.altzone)
print(time.asctime())#返回时间格式Sun Nov 13 12:08:23 2016
print(time.localtime())#返回本地时间的struct time对象格式
print(time.asctime(time.localtime()))
#返回时间格式"Fri Aug 19 11:14:16 2016",


 # 日期字符串 转成  时间戳
print('**************************************')
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('**************************************')
#将时间戳转为字符串格式
print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式

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

 

random模块





import random


print random.random()


print random.randint(1,2)


print random.randrange(1,10)






生成随机验证码：
import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode +=str(temp)
print(checkcode)



OS模块　


提供对操作系统进行调用的接口:




os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径


os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd


os.curdir  返回当前目录: ('.')


os.pardir  获取当前目录的父目录字符串名：('..')


os.makedirs('dirname1/dirname2')    可生成多层递归目录


os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推


os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname


os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname


os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印


os.remove()  删除一个文件


os.rename("oldname","newname")  重命名文件/目录


os.stat('path/filename')  获取文件/目录信息


os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"


os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"


os.pathsep    输出用于分割文件路径的字符串


os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'


os.system("bash command")  运行shell命令，直接显示


os.environ  获取系统环境变量


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(path)  如果path存在，返回True；如果path不存在，返回False


os.path.isabs(path)  如果path是绝对路径，返回True


os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False


os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False


os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略


os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间


os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间


 




sys模块








sys.argv        命令行参数List，第一个元素是程序本身路径


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


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


sys.maxint        最大的Int值


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


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


sys.stdout.write('please:')


val = sys.stdin.readline()[:-1]


 




shutil 模块










自定义模块




Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：


导入模块：






import module


from module.xx.xx import xx


from module.xx.xx import xx as rename   


from module.xx.xx import *


 




导入模块其实就是告诉Python解释器去解释那个py文件


    

  • 导入一个py文件，解释器解释该py文件
    • 

  • 导入一个包，解释器解释该包下的 __init__.py 文件
    • 



那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path








import sys


print sys.path


  


结果：


['/Users/wupeiqi/PycharmProjects/calculator/p1/pp1', '/usr/local/lib/python2.7/site-packages/setuptools-15.2-py2.7.egg', '/usr/local/lib/python2.7/site-packages/distribute-0.6.28-py2.7.egg', '/usr/local/lib/python2.7/site-packages/MySQL_python-1.2.4b4-py2.7-macosx-10.10-x86_64.egg', '/usr/local/lib/python2.7/site-packages/xlutils-1.7.1-py2.7.egg', '/usr/local/lib/python2.7/site-packages/xlwt-1.0.0-py2.7.egg', '/usr/local/lib/python2.7/site-packages/xlrd-0.9.3-py2.7.egg', '/usr/local/lib/python2.7/site-packages/tornado-4.1-py2.7-macosx-10.10-x86_64.egg', '/usr/local/lib/python2.7/site-packages/backports.ssl_match_hostname-3.4.0.2-py2.7.egg', '/usr/local/lib/python2.7/site-packages/certifi-2015.4.28-py2.7.egg', '/usr/local/lib/python2.7/site-packages/pyOpenSSL-0.15.1-py2.7.egg', '/usr/local/lib/python2.7/site-packages/six-1.9.0-py2.7.egg', '/usr/local/lib/python2.7/site-packages/cryptography-0.9.1-py2.7-macosx-10.10-x86_64.egg', '/usr/local/lib/python2.7/site-packages/cffi-1.1.1-py2.7-macosx-10.10-x86_64.egg', '/usr/local/lib/python2.7/site-packages/ipaddress-1.0.7-py2.7.egg', '/usr/local/lib/python2.7/site-packages/enum34-1.0.4-py2.7.egg', '/usr/local/lib/python2.7/site-packages/pyasn1-0.1.7-py2.7.egg', '/usr/local/lib/python2.7/site-packages/idna-2.0-py2.7.egg', '/usr/local/lib/python2.7/site-packages/pycparser-2.13-py2.7.egg', '/usr/local/lib/python2.7/site-packages/Django-1.7.8-py2.7.egg', '/usr/local/lib/python2.7/site-packages/paramiko-1.10.1-py2.7.egg', '/usr/local/lib/python2.7/site-packages/gevent-1.0.2-py2.7-macosx-10.10-x86_64.egg', '/usr/local/lib/python2.7/site-packages/greenlet-0.4.7-py2.7-macosx-10.10-x86_64.egg', '/Users/wupeiqi/PycharmProjects/calculator', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python27.zip', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-darwin', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/plat-mac/lib-scriptpackages', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-tk', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-old', '/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/site-packages', '/Library/Python/2.7/site-packages']


 


如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。
通过os模块可以获取各种目录，例如：






import sys
import os

pre_path = os.path.abspath('../')
sys.path.append(pre_path)


开源模块
下载安装有两种方式：


yum 
pip
apt-get
...


下载源码
解压源码
进入目录
编译源码    python setup.py build
安装源码    python setup.py install

注：在使用源码安装时，需要使用到gcc编译和python开发环境，所以，需要先执行：




yum install gcc


yum install python-devel


或


apt-get python-dev




安装成功后，模块会自动安装到 sys.path 中的某个目录中，如：




/usr/lib/python2.7/site-packages/


    导入模块


    模块 paramiko

paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。


1、下载安装


　　




# pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto


 


# 下载安装 pycrypto


wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz


tar -xvf pycrypto-2.6.1.tar.gz


cd pycrypto-2.6.1


python setup.py build


python setup.py install


 


# 进入python环境，导入Crypto检查是否安装成功


 


# 下载安装 paramiko


wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz


tar -xvf paramiko-1.10.1.tar.gz


cd paramiko-1.10.1


python setup.py build


python setup.py install


 


# 进入python环境，导入paramiko检查是否安装成功


　　使用模块




#!/usr/bin/env python
#coding:utf-8

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.108', 22, 'alex', '123')
stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close();










import paramiko

private_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(private_key_path)

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('主机名 ', 端口, '用户名', key)

stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close()



import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test.py','/tmp/test.py') 
t.close()


import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test.py','/tmp/test2.py')
t.close()


import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test3.py','/tmp/test3.py') 

t.close()

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test3.py','/tmp/test4.py') 

t.close()



json & pickle 模块


用于序列化的两个模块


    

  • json，用于字符串 和 python数据类型间进行转换
    • 

  • pickle，用于python特有的类型 和 python的数据类型间进行转换
    • 



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


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




import json
data ={
    'name':'alex',
    'age':25,
    'sex':'M'
}
#
# f =open('data.txt','w',encoding='utf-8')
#
# json.dump(data,f)
# f.close()

f_r =open('data.txt','r',encoding='utf-8')
data = json.load(f_r)
f_r.close()
print(data['age'])


shelve 模块


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





import shelve


 


d = shelve.open('shelve_test') #打开一个文件 


 


class Test(object):


    def __init__(self,n):


        self.n = n


 


 


t = Test(123)  


t2 = Test(123334)


 


name = ["alex","rain","test"] 


d["test"] = name #持久化列表


d["t1"] = t      #持久化类


d["t2"] = t2


 


d.close()




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:




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('\t',i.tag,i.attrib,i.text)

#只遍历year节点
#root.iter('country').__next__()

for node in root.iter('year'):
    print(type(node))
    print(node.tag,node.text)
#修改、删除xml文档内容
tree = ET.parse('xmltest2')
root = tree.getroot()
#修改节点
for node in root.iter('year'):
    new_year = int(node.text) +1
    node.set("updated","yes")

tree.write("xmltest2.xml")
# 删除node
for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        root.remove(country)

tree.write('output.xml')

# 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")
# sex.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)  # 打印生成的格式 








PyYAML模块


Python也可以很容易的处理ymal文档格式，只不过需要安装一个模块，参考文档：http://pyyaml.org/wiki/PyYAMLDocumentation 



ConfigParser模块




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




来看一个好多软件的常见文档格式如下




[DEFAULT]


ServerAliveInterval = 45


Compression = yes


CompressionLevel = 9


ForwardX11 = yes


 


[bitbucket.org]


User = hg


 


[topsecret.server.com]


Port = 50022


ForwardX11 = no


 






import configparser
config = configparser.ConfigParser()
# config["DEFAULT"] = {'ServerAliveInterval':'45',
#                      'Compression':'yes',
#                      'CompressionLevel':'9'}
#
# config['bitbucket.org'] = {}
# config['bitbucket.org']['user']='HG'
#
# config['top.server.com'] ={}
# top = config['top.server.com']
# top['Host port'] = '50022'
# top['ForwardX11'] ='yes'
#
# config['DEFAULT']['ForwardX11'] = 'yes'
#
# with open('example.ini','w') as configfile:
#     config.write(configfile)


config.read('example.ini')
#['example.ini']
print(config.sections())#不显示DEFAULT信息
#['bitbucket.org', 'top.server.com']
sectionname = config.sections()[1]
print(config[sectionname]['host port'])
#打印key，包含DEFAULT
for key in config[sectionname]:
    print(key)

# ########## 读 ##########
# secs = config.sections()
# print secs
# options = config.options('group2')
# print options

# item_list = config.items('group2')
# print item_list

# val = config.get('group1','key')
# val = config.getint('group1','key')

# ########## 改写 ##########
# sec = config.remove_section('group1')
# config.write(open('i.cfg', "w"))

# sec = config.has_section('wupeiqi')
# sec = config.add_section('wupeiqi')
# config.write(open('i.cfg', "w"))


# config.set('group2','k1',11111)
# config.write(open('i.cfg', "w"))

# config.remove_option('group2','age')
# config.write(open('i.cfg', "w"))






 


 


hashlib模块

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

# import hashlib
# m = hashlib.md5()
# m.update(b'jeb.li')
# print(m.hexdigest())

import hmac
h1 = hmac.new(b'jeb.li')
print('jeb.li hmac with out salt:')
print(h1.hexdigest())
h2= hmac.new(b'jeb.li')

h2.update(b'hello')
print(h2.hexdigest())
print('jeb.li hmac with salt(hello):')
print(h2.hexdigest())




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






import hmac


h = hmac.new('wueiqi')


h.update('hellowo') 


print h.hexdigest()


更多关于md5,sha1,sha256等介绍的文章看这里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html


 




logging模块　


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


import logging
from logging import handlers
#无format版
# logging.basicConfig(filename='access.log',level=logging.INFO)
#加常见format版
# logging.basicConfig(filename='access.log',level=logging.INFO,
#                     format='%(asctime)s %(message)s',
#                     datefmt='%m/%d/%Y %I:%M:%S %p')
#加强format版
# logging.basicConfig(filename='access.log',level=logging.INFO,
#                     format='%(asctime)s %(message)s %(filename)s %(lineno)d',
#                     datefmt='%m/%d/%Y %I:%M:%S %p >>:')
#创建logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)
#创建控制台handler，设置日志级别debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
#创建文件handler，设置日志级别warning
#文件自动截断，按文件大小
fh = handlers.RotatingFileHandler(filename='access.log',maxBytes=10,backupCount=3,encoding='utf-8')
# fh = logging.FileHandler('access.log',encoding='utf-8')
fh.setLevel(logging.WARNING)
#创建formatter
fh_formatter = logging.Formatter('%(asctime)s %(filename)s %(lineno)d -%(levelname)s %(message)s ')
ch_formatter = logging.Formatter('%(asctime)s -%(levelname)s %(message)s ')

#加载不同handeler的formatter
ch.setFormatter(ch_formatter)
fh.setFormatter(fh_formatter)
#文件自动截断,按时间
# fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)

#注册不同的handler至logger
logger.addHandler(ch)
logger.addHandler(fh)


#应用程序代码：
logger.info('So should this')
logger.debug('This message should go to the log file')
logger.warning("user [alex] attempted wrong password more than 3 times")
logger.error("sercice starts with error")
logger.critical("server is down")










日志格式








%(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




用户输出的消息










 






 





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




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

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")


 






 






 


 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


 


 


'\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'}


 






re.match    从头开始匹配


re.search    匹配包含


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


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


re.sub     匹配字符并替换 










 


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


 


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






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


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


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






































 






		

		
posted @ 
2016-11-19 09:50 
Jeb 
阅读(1588) 
评论(0) 
编辑 
收藏 
举报