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 = ""  #通过索引修改某个节点的值
 >>> 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 = ''   #设置节点值
 name2 = ET.SubElement(new_xml,"root",attrib={"enrolled":"no"})
 age2 = ET.SubElement(name2,'age2')
 age2.text = ''

 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', ''), ('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','')
 config.set('mysql','passwd','')
 config.write(open('my.cnf','w'))
 print(config.items('mysql'))

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

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

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

 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\n'
 >>> s = subprocess.check_output('pwd')
 >>> s
 b'/root\n'

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\n/dev/sda3      100813224 3173844  92511652   4% /\ntmpfs             506144       0    506144   0% /dev/shm\n/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\nboot\ndev\netc\nhome\nlib\nlib64\nlost+found\nmedia\nmedia1\nmnt\nopt\nproc\npyhton\npython\nroot\nsbin\nselinux\nsrv\nsys\ntmp\nusr\nvar\n')
 >>> a = subprocess.run(['ls','/'],stdout=subprocess.PIPE)
 >>> print(a.stdout)  #对返回值进行输出操作
 b'bin\nboot\ndev\netc\nhome\nlib\nlib64\nlost+found\nmedia\nmedia1\nmnt\nopt\nproc\npyhton\npython\nroot\nsbin\nselinux\nsrv\nsys\ntmp\nusr\nvar\n'
 >>> 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为同意使用\n
• 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)\n")  #需要输入字节对象，否则会报错
 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)\n")
 >>> a.stdin.write(b"print(2)\n")
 >>> a.stdin.write(b"print(3)\n")
 >>> out_li = a.communicate()  #关闭管道
 >>> print(out_li)   #打印结果
 (b'1\n2\n3\n', 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)\ntarget     prot opt source               destination         \n\nChain FORWARD (policy ACCEPT)\ntarget     prot opt source               destination         \n\nChain OUTPUT (policy ACCEPT)\ntarget     prot opt source               destination         \n'

七.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