Python常用模块二

一.time & datetime 

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

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

三.shutil模块

shutil模块提供了大量的文件的高级操作。特别针对文件拷贝和删除，主要功能为目录和文件操作以及压缩操作。对单个文件的操作也可参见os模块。

(1) 拷贝

>>> import shutil
>>> shutil.chown('test.txt',user='mysql',group='mysql') #改变文件的属主和属组
>>> shutil.copy('test.txt','test_copy.txt') #拷贝文件
>>> shutil.copy2('test.txt','test_copy2.txt') #拷贝文件并复制所有统计信息，如修改时间等。
>>> shutil.copyfile('test_ln.txt','test_copyfile.txt') #如果是链接文件，将复制新文件，不复制链接

>>> dstf = open('test_copyfileobj.txt','r+')
>>> srcf = open('test.txt','r')
>>> shutil.copyfileobj(srcf,dstf,length=2)  #按长度拷贝文件对象

>>> shutil.copymode('test.txt','test_copymode.txt')  #拷贝文件的权限到目标文件上

>>> shutil.copystat('test.txt','test_copymode.txt')  #拷贝文件的访问和修改时间，其他不受影响
#shutil.copytree(src, dst, symlinks=False, ignore=None) 递归的去拷贝文件夹
#shutil.rmtree(path[, ignore_errors[, onerror]])  递归的去删除文件
#shutil.move(src, dst)  递归的去移动文件，它类似mv命令，其实就是重命名。

（2）压缩与解压缩

make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
                 dry_run=0, owner=None, group=None, logger=None)
创建压缩包并返回文件路径：
base_name:压缩包的文件名，也可以是压缩包的路径，只是文件名时，保存到当前目录，否则保存到指定路径
format:压缩包种类，‘zip’,'tar','bztar','gztar'
root_dir:要压缩的文件夹路径（默认当前目录）
owner:用户，默认当前用户
group:组，默认当前组
logger:用于记录日志，通常是logging.Logger对象

>>>import shutil
#将/root目录下的所有文件压缩到media目录下取名为www,压缩格式为tar
>>> ret = shutil.make_archive("/media/www",'tar',root_dir='/root')

#将文件已tar格式压缩到当前目录下
 ret = shutil.make_archive("ipython55",'tar',root_dir='/root/ipython-5.5.0')

shutil 对压缩包的处理是通过调用ZipFile 和 TarFile两个模块来进行的。

>>> import zipfile
#压缩
>>> z = zipfile.ZipFile('xin.tar.gz','w')   #创建名为xin.tar.gz的压缩文件
>>> z.write('test.txt')   #写入文件到压缩文件中
>>> z.write('log.txt')
>>> z.close()   #关闭文件
#解压缩
>>> z = zipfile.ZipFile('xin.tar.gz','r')   #打开压缩文件
>>> z.extractall(path='/python/day7')  #解压到指定路径下
>>> z.close()


>>> import tarfile
#压缩
>>> tar = tarfile.open('/usr/targzfile.tar.gz','w')  #指定目录创建压缩文件
>>> tar.add('/python/day7/test1.py',arcname='test1.py')  #添加文件到压缩文件中
>>> tar.add('/python/day7/test1.py',arcname='test2.py')
>>> tar.close()

#解压缩
>>> tar = tarfile.open('/usr/targzfile.tar.gz','r')
>>> tar.extractall(path='/pyhton/day8')
>>> tar.close()

四.xml模块

XML 指可扩展标记语言（eXtensible Markup Language），标准通用标记语言的子集，是一种用于标记电子文件使其具有结构性的标记语言。

XML 被设计用来传输和存储数据。

XML是一套定义语义标记的规则，这些标记将文档分成许多部件并对这些部件加以标识。

它也是元标记语言，即定义了用于定义其他与特定领域有关的、语义的、结构化的标记语言的句法语言。

python对XML的解析：

常见的XML编程接口有DOM和SAX，这两种接口处理XML文件的方式不同，当然使用场合也不同。

python有三种方法解析XML，SAX，DOM，以及ElementTree:

使用xml.etree.ElementTree模块来解析XML文件，ElementTree模块中提供了两个类用来完成这个目的：

ElementTree表示整个XML文件（一个树形结构）

Element表示树种的一个元素（结点）

示例xml文件：

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

首先需要导入ElementTree模块：import xml.etree.ElementTree as ET

然后使用ET下的方法parse解析XML文档:ET.parse()

>>> import tab
>>> import xml.etree.ElementTree as ET   #导入模块
>>> tree = ET.parse("xmltest.xml")  #解析xml文档
>>> root = tree.getroot()   #获取根节点
>>> print(root.tag)   #打印节点
collection
>>> print(root[1][1].tag,root[1][1].text)  #通过索引解析根的子节点和数值
format DVD
#取出整个xml文档的内容
>>> for child in root:   #循环根节点
...   print(child.tag,child.attrib)  #打印节点和属性
...   for i in child:   #再循环内层节点
...     print("---",i.tag,i.text)  #打印节点和数值
... 
#输出内容：
movie {'title': 'Enemy Behind'}
--- type War, Thriller
--- format DVD
--- year 2003
--- rating PG
--- stars 10
--- description Talk about a US-Japan war
movie {'title': 'Transformers'}
--- type Anime, Science Fiction
--- format DVD
--- year 1989
--- rating R
--- stars 8
--- description A schientific fiction
movie {'title': 'Trigun'}
--- type Anime, Action
--- format DVD
--- episodes 4
--- rating PG
--- stars 10
--- description Vash the Stampede!
movie {'title': 'Ishtar'}
--- type Comedy
--- format VHS
--- rating PG
--- stars 2
--- description Viewable boredom

#只遍历type节点
>>> for i in root.iter('type'):  #iter检索节点名
...   print(i.tag,i.text)
... 
type War, Thriller
type Anime, Science Fiction
type Anime, Action
type Comedy

修改和添加属性，删除节点：

>>> import tab
>>> import xml.etree.ElementTree as ET
>>> tree = ET.parse("xmltest.xml")
>>> root = tree.getroot()

>>> root[1][2].text = "2017"  #通过索引修改某个节点的值
>>> tree.write('xmltest.xml')  #将修改写入文档中
#循环修改索引的year节点数值
>>> for i in root.iter('year'):
...   new_year = int(i.text)+1
...   i.text = str(new_year)
...   i.set("updated","yes")  #为每个year节点添加属性
... 
>>> tree.write("xmltest.xml")

#删除某个节点
>>> for i in root.findall('stars'):   #查询所有stars节点并删除
...   root.remove(i)

创建xml文档：

#!/usr/bin/env python
#coding:utf8

import xml.etree.ElementTree as ET

new_xml = ET.Element('namelist')  #创建根节点
name = ET.SubElement(new_xml,"root",attrib={'enrolled':'yes'})   #根节点下创建子节点并设置属性
age = ET.SubElement(name,"head",attrib={"cheched":"no"}) #root节点下创建节点，配置属性
sex = ET.SubElement(name,"sex")  #root下创建节点
sex.text = '88'   #设置节点值
name2 = ET.SubElement(new_xml,"root",attrib={"enrolled":"no"})
age2 = ET.SubElement(name2,'age2')
age2.text = '99'

et = ET.Element(new_xml)   #生成xml文件对象
#et.write("test_1.xml",encoding="utf-8",xml_declaration=True)
ET.dump(new_xml)   #打印生成格式

#output：
<namelist>
    <root enrolled="yes">
        <head cheched="no" />
        <sex>88</sex>
    </root>
    <root enrolled="no">
        <age2>99</age2>
    </root>
</namelist>

 五.ConfigParser模块

ConfigParser 是用来读取配置文件的包。配置文件的格式如下：中括号“[ ]”内包含的为section。section 下面为类似于key-value 的配置内容。

使用ConfigParser首先需要初始化实例，并读取配置文件，下面以MySQL的配置文件为例：

[mysqld]
innodb_buffer_pool_size = 128M
join_buffer_size = 128M
sort_buffer_size = 2M
read_rnd_buffer_size = 2M
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock

symbolic-links=0
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 

[mysqld_safe]
log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid

import configparser

config = configparser.ConfigParser()  #初始化实例
config.read('my.cnf',encoding='utf-8')  #读取配置文件
#读取模块名到列表中，也就是[]中的内容
print(config.sections())
#output
['mysqld', 'mysqld_safe']

#读取指定sections内的所有key
print('se_keys:',config.options('mysqld'))
#output:
se_keys: ['innodb_buffer_pool_size', 'join_buffer_size', 'sort_buffer_size', 'read_rnd_buffer_size', 'datadir', 'socket', 'symbolic-links', 'sql_mode']

#获取指定sections的配置信息
print(config.items('mysqld'))
#output：
[('innodb_buffer_pool_size', '128M'), ('join_buffer_size', '128M'), ('sort_buffer_size', '2M'), ('read_rnd_buffer_size', '2M'), ('datadir', '/var/lib/mysql'), ('socket', '/var/lib/mysql/mysql.sock'), ('symbolic-links', '0'), ('sql_mode', 'NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES')]

#在指定的sections中通过key找出value
print(config.get('mysqld','datadir'))

#output：
/var/lib/mysql

#设置某个key的值
config.set('mysqld','datadir','/usr/local/lib/mysql')
config.write(open('my.cnf','w'))   #回写到文件中
print(config.get('mysqld','datadir'))

#output：
/usr/local/lib/mysql

#添加一个section，需要回写到文件中
config.add_section('mysql')
config.set('mysql','user','root')
config.set('mysql','port','3306')
config.set('mysql','passwd','123')
config.write(open('my.cnf','w'))
print(config.items('mysql'))

#output：
[('user', 'root'), ('port', '3306'), ('passwd', '123')]

#移除section或option
config.remove_option('mysql','passwd')
print(config.items('mysql'))

#output：
[('user', 'root'), ('port', '3306')]

config.remove_section('mysql')
config.write(open('my.cnf','w'))
print(config.sections())

#output：
['mysqld', 'mysqld_safe']

六.subprocess模块

运行python的时候，我们都是在创建并运行一个进程，linux中一个进程可以fork一个子进程，并让这个子进程exec另外一个程序。在python中，我们通过标准库中的subprocess包来fork一个子进程，并且运行一个外部的程序。subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所欲我们可以根据需要来从中选取一个使用。另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

1）call方法

执行命令时，返回状态码，shell=True允许shell命令字符串形式

>>> import subprocess
>>> subprocess.call(['ifconfig','eth0']) #多选项时使用[]隔开
eth0      Link encap:Ethernet  HWaddr 00:0C:29:78:0E:5A  
          inet addr:192.168.146.129  Bcast:192.168.146.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fe78:e5a/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:637524 errors:0 dropped:0 overruns:0 frame:0
          TX packets:180621 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:131549223 (125.4 MiB)  TX bytes:21560909 (20.5 MiB)
>>> subprocess.call('ifconfig eth0',shell=True) #指定shell为True时将使用shell原生格式执行。
eth0      Link encap:Ethernet  HWaddr 00:0C:29:78:0E:5A  
          inet addr:192.168.146.129  Bcast:192.168.146.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fe78:e5a/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:644202 errors:0 dropped:0 overruns:0 frame:0
          TX packets:182941 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:132048205 (125.9 MiB)  TX bytes:21810181 (20.7 MiB)

2）check_call方法

执行命令时如果执行状态码为0，则返回0，否则抛出异常

>>>import subprocess
>>> subprocess.check_call('pwd')
/root
>>> subprocess.check_call(['df','-Th'])
Filesystem     Type   Size  Used Avail Use% Mounted on
/dev/sda3      ext4    97G  3.1G   89G   4% /
tmpfs          tmpfs  495M     0  495M   0% /dev/shm
/dev/sda1      ext4   190M   27M  153M  16% /boot

3）check_output

#执行命令，并返回结果，注意是返回结果，不是打印

>>>import subprocess
>>> subprocess.check_output('pwd')
b'/root
'
>>> s = subprocess.check_output('pwd')
>>> s
b'/root
'

4)getstatusoutput()

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果

>>> import subprocess
>>> subprocess.getstatusoutput('pwd')
(0, '/root')

5)getoutput()

#接收字符串格式命令，并返回结果

>>> import subprocess
>>> subprocess.getoutput(['df','-Th'])
'Filesystem     1K-blocks    Used Available Use% Mounted on
/dev/sda3      100813224 3173844  92511652   4% /
tmpfs             506144       0    506144   0% /dev/shm
/dev/sda1         194241   27607    156394  16% /boot'

6)run（）

使用subprocess时建议使用run()函数去处理所有它可以处理的情况，因为高级用法可以直接使用底层POPEN接口。

run（）函数是Python 3.5中新添加的。

使用方法：

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False)

>>> import subprocess
>>> subprocess.run(['ls','/'])  #返回结果
bin   etc   lib64    media1    proc    root     srv  usr
boot  home  lost+found    mnt    pyhton    sbin     sys  var
dev   lib   media    opt    python    selinux  tmp
CompletedProcess(args=['ls', '/'], returncode=0)

>>> subprocess.run(['ls','/'],stdout=subprocess.PIPE) #命令返回不会输出
CompletedProcess(args=['ls', '/'], returncode=0, stdout=b'bin
boot
dev
etc
home
lib
lib64
lost+found
media
media1
mnt
opt
proc
pyhton
python
root
sbin
selinux
srv
sys
tmp
usr
var
')
>>> a = subprocess.run(['ls','/'],stdout=subprocess.PIPE)
>>> print(a.stdout)  #对返回值进行输出操作
b'bin
boot
dev
etc
home
lib
lib64
lost+found
media
media1
mnt
opt
proc
pyhton
python
root
sbin
selinux
srv
sys
tmp
usr
var
'
>>> print(a.args)   #返回参数
['ls', '/']
>>> print(a.returncode)  #返回状态码
>>> print(a.stderr)  #返回错误输出
None

7)Popen()

#上面那些方法，底层都是封装的subprocess.Popen

参数包括：

• args: 可以是字符串或者序列类型（如：list, tuple）。默认的，要执行的程序应该是序列的第一个字段，如果是单个字符串，它的解析依赖于平台。在unix中，如果args是一个字符串，那么这个字符串解释成被执行程序的名字或路径，然而，这种情况只能用在不需要参数的程序。
• bufsieze: 指定缓冲。0表示无缓冲，1表示缓冲，任何其他的整数值表示缓冲大小，负数值表示使用系统默认缓冲，通常表示完全缓冲。默认值为0即没有缓冲。
• stdin, stdout, stderr：分别表示程序的标准输入，输出，错误句柄
• preexec_fn : 只在unix平台有效，用于指定一个可执行对象，它将在子进程中运行之前被调用
• close_fds : 在windows平台下，如果close_fds被设置为true，则新创建的子进程将不会继承父进程的输入，输出，错误管道。所以不能将close_fds设置为true同时重定向子进程的标准输入，输出与错误。
• shell : 默认值为False, 声明了是否使用shell来执行程序，如果shell=True,它将args看做一个字符串，而不是一个序列。在unix系统中，且shell=True, shell默认使用/bin/sh。
• cwd : 用于设置子进程的当前目录。当它不为None时，子程序在执行前，它的当前路径会被替换成cwd的值。这个路径并不会被添加到可执行程序的搜索路径，所以cwd不能是相对路径。
• env : 用于指定子进程的环境变量。如果env=None,子进程的环境变量将从父进程中继承。当它不为None时，它是新进程的环境变量的映射。可以用它来代替当前进程的环境。
• universal_newlines : 不同系统的换行符不同， 文件对象stdout和stderr都被以文本文件的方式打开，指定True为同意使用
• startupinfo 与 createionflags只在windows下生效。将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

>>> import subprocess
>>> subprocess.Popen(['mkdir','test_sub.txt']) #在当前目录下创建文件夹
>>> st = subprocess.Popen(['uname','-r']) #只会打印结果
>>> 2.6.32-504.el6.x86_64

>>> st   #返回的是一个对象
<subprocess.Popen object at 0x7f3baeceae48>
#使用cwd指定目录创建目录
>>> subprocess.Popen('mkdir t3',shell=True,cwd='/python')
<subprocess.Popen object at 0x7f3baecea2b0>

#打开一个python子进程，并通过父进程与子进程交互

>>> import subprocess
>>> a = subprocess.Popen(['python35'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

>>> a.stdin.write("print(1)
")  #需要输入字节对象，否则会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: a bytes-like object is required, not 'str'
>>> a.stdin.write(b"print(1)
")
>>> a.stdin.write(b"print(2)
")
>>> a.stdin.write(b"print(3)
")
>>> out_li = a.communicate()  #关闭管道
>>> print(out_li)   #打印结果
(b'1
2
3
', b'')

自动密码输入实例：

#!/usr/bin/env python35
#coding:utf8

import subprocess,sys
def mypass():
  mypass = 'zhang.com'
  return mypass

echo = subprocess.Popen(['echo',mypass()],stdout=subprocess.PIPE,)
#sudo = subprocess.Popen(['sudo','-S','iptables','-L'],stdin=echo.stdout,stdout=subprocess.PIPE,)

sudo = subprocess.Popen(sys.argv[1],shell=True,stdin=echo.stdout,stdout=subprocess.PIPE,)
end_of_pipe = sudo.stdout
print('output：',end_of_pipe.read())


[zhang@python ~]$ python35 sub_sudo.py "sudo -S iptables -L"     #使用脚本直接带参数输入命令
[sudo] password for zhang: output： b'Chain INPUT (policy ACCEPT)
target     prot opt source               destination         

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         
'

七.logging模块

Python的logging模块提供了通用的日志系统，可以方便第三方模块或者是应用使用。这个模块提供不同的日志级别，并可以采用不同的方式记录日志，比如文件，HTTP GET/POST，SMTP，Socket等，甚至可以自己实现具体的日志记录方式。

logging框架中主要由四个部分组成：

• Loggers: 提供应用直接调用的接口
• Handlers: 决定将日志记录发送至正确的目的地
• Filters: 提供更精细的决定哪些日志输出的能力，简单点说就是决定哪些输出哪些不输出
• Formatters: 制定最终输出的格式。

1）logger对象

logger是不直接实例化的，但是我们可以通过模块级别的函数logging.getLogger(name)来调用。如果多次通过同一个名字调用getLogger()将只能得到对同一个对象的引用。

每个程序在输出信息之前都要获得一个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()：可以设置的日志级别

import logging

logging.info('this is info message')
logging.warning('this is warning message')
logging.debug('this is debug message')

#output
WARNING:root:this is warning message

#默认情况下，logging将日志打印到屏幕，日志级别为WARNING；
#日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > #DEBUG > NOTSET，当然也可以自己定义日志级别。

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

#日志切割示例：

#!/usr/bin/env python
#coding:utf8

import logging
from logging import handlers
#创建一个logger对象
logger = logging.getLogger(__name__)
#日志文件名
log_file = 'timelog.log'
#配置自动日志切割backupCount指定回滚日志次数
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=5)
#配置日志格式
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
#指定日志格式
fh.setFormatter(formatter)
#指定发送日志Handler
logger.addHandler(fh)

#生成日志
logger.warning('test1')
logger.warning('test2')
logger.warning('test3')
logger.warning('test4')
logger.warning('test5')
logger.warning('test6')
logger.warning('test7')
logger.warning('test8')

3)Filters

(提供更精细的决定哪些日志输出的能力，简单点说就是决定哪些输出哪些不输出)

设置级别 logger.setLevel(logging.DEBUG),Logging中有NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL这几种级别，日志会记录设置级别以上的日志

DEBUG：详细的信息,通常只出现在诊断问题上
INFO：　 确认一切按预期运行
WARNING：一个迹象表明,一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”)。这个软件还能按预期工作。
ERROR：   更严重的问题,软件没能执行一些功能
CRITICAL：一个严重的错误,这表明程序本身可能无法继续运行

这5个等级，也分别对应5种打日志的方法： debug 、info 、warning 、error 、critical。默认的是WARNING，当在WARNING或之上时才被跟踪。

4)Formatters

制定最终输出的格式。

通过logging.basicConfig函数对日志的输出格式及方式做相关配置

import logging

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S',
                    filemode='w',filename='access.log')

logging.debug('this is debug message')
logging.info('this is debug message')
logging.warning('this is debug message')


#output
2017-12-17 16:58:47 formatter_f.py[line:13] DEBUG this is debug message
2017-12-17 16:58:47 formatter_f.py[line:14] INFO this is debug message
2017-12-17 16:58:47 formatter_f.py[line:15] WARNING this is debug message

ogging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:

%(name)s:logger的名字
 %(levelno)s: 打印日志级别的数值
 %(levelname)s: 打印日志级别名称
 %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
 %(filename)s: 打印当前执行程序名
 %(funcName)s: 打印日志的当前函数
 %(lineno)d: 打印日志的当前行号
 %(asctime)s: 打印日志的时间
 %(thread)d: 打印线程ID
 %(threadName)s: 打印线程名称
 %(process)d: 打印进程ID
 %(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
level: 设置日志级别，默认为logging.WARNING
stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略

#!/usr/bin/env python
#coding:utf8

import logging
#创建一个logger对象
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

#定义日志输出格式
formatter = logging.Formatter('%(asctime)s %(thread)d %(threadName)s %(process)d[line:%(lineno)d] %(levelname)s %(message)s')

#创建屏幕输出对象并设置级别
console = logging.StreamHandler()
console.setLevel(logging.INFO)

#创建文件输出对象并设置级别
file = logging.FileHandler('all_acc.log')
file.setLevel(logging.ERROR)

#定义对象的日志输出格式
file.setFormatter(formatter)
console.setFormatter(formatter)

#添加日志到文件和屏幕
logger.addHandler(console)
logger.addHandler(file)

#输入日志
logging.debug('this is debug message')
logging.info('this is info message')
logging.warning('this is warning message')
logging.error('this is error message')
logging.critical('this is critical message')

#OUTPUT:
#console:
2017-12-17 21:42:28,356 6056 MainThread 1088[line:30] INFO this is info message
2017-12-17 21:42:28,356 6056 MainThread 1088[line:31] WARNING this is warning message
2017-12-17 21:42:28,356 6056 MainThread 1088[line:32] ERROR this is error message
2017-12-17 21:42:28,356 6056 MainThread 1088[line:33] CRITICAL this is critical message
#file
2017-12-17 21:41:17,199 9000 MainThread 8448[line:33] CRITICAL this is critical message
2017-12-17 21:42:28,356 6056 MainThread 1088[line:32] ERROR this is error message
2017-12-17 21:42:28,356 6056 MainThread 1088[line:33] CRITICAL this is critical message

#!/usr/bin/env python
#coding:utf8

import os
import logging.config

# 定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

logfile_dir = os.path.dirname(os.path.abspath(__file__))
# log文件的目录
#print(logfile_dir)
logfile_name = 'all2.log'  # log文件名
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

logging config