一.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(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