1、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>
2、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‘]
3、hashlib模块
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
hashlib模块代替了Python2中的md5和sham模块,使用这个模块一般分为3步
1.创建一个哈希对象,使用哈希算法命名的构造函数或通用构造函数hashlib.new(name[, data])
2.使用哈希对象调用update()方法填充这个对象
3.调用digest() 或 hexdigest()方法来获取摘要(加密结果)
注:
1.update()方法需要接收的参数是一个字节对象(字节字符串,如:b"Hello,World!")
2.常用的一些算法主要有: SHA1, SHA224, SHA256, SHA384, SHA512, MD5等算法
3.SHA1算法比较早,是不能抵抗暴力破解的
>>> import tab >>> import hashlib #md5 >>> m5 = hashlib.md5() >>> m5.update(b‘hello‘) >>> print(m5.digest()) #二进制格式hash b‘][email protected]*\xbcK*v\xb9q\x9d\x91\x10\x17\xc5\x92‘ >>> print(m5.hexdigest()) #十六进制格式hash 5d41402abc4b2a76b9719d911017c592 #sha1 >>> sh1 = hashlib.sha1() >>> sh1.update(b‘python‘) >>> print(sh1.hexdigest()) 4235227b51436ad86d07c7cf5d69bda2644984de >>> print(sh1.digest()) b‘B5"{QCj\xd8m\x07\xc7\xcf]i\xbd\xa2dI\x84\xde‘ #sha256 >>> sh2 = hashlib.sha256() >>> sh2.update(b‘python‘) >>> print(sh2.hexdigest()) 11a4a60b518bf24989d481468076e5d5982884626aed9faeb35b8576fcd223e1 #sha512 >>> sh5 = hashlib.sha512() >>> sh5.update(b‘python‘) >>> print(sh5.hexdigest()) ecc579811643b170cbd88fd0d0e323d1e1acc7cef8f73483a70abea01a89afa8015295f617f27447ba05e928e47a0b3a46dc79e72f99d1333856e23eeff97d8b
4、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) 0 >>> 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) 0
2）check_call方法
执行命令时如果执行状态码为0，则返回0，否则抛出异常
>>>import subprocess >>> subprocess.check_call(‘pwd‘) /root 0 >>> 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 0
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) #返回状态码 0 >>> 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") 9 >>> a.stdin.write(b"print(2)\n") 9 >>> a.stdin.write(b"print(3)\n") 9 >>> 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()) [[email protected] ~]$ 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‘
5、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
logging.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被忽略
5)将日志同时输出到文件和屏幕
1 #!/usr/bin/env python 2 #coding:utf8 3 4 import logging 5 #创建一个logger对象 6 logger = logging.getLogger() 7 logger.setLevel(logging.DEBUG) 8 9 #定义日志输出格式 10 formatter = logging.Formatter(‘%(asctime)s %(thread)d %(threadName)s %(process)d[line:%(lineno)d] %(levelname)s %(message)s‘) 11 12 #创建屏幕输出对象并设置级别 13 console = logging.StreamHandler() 14 console.setLevel(logging.INFO) 15 16 #创建文件输出对象并设置级别 17 file = logging.FileHandler(‘all_acc.log‘) 18 file.setLevel(logging.ERROR) 19 20 #定义对象的日志输出格式 21 file.setFormatter(formatter) 22 console.setFormatter(formatter) 23 24 #添加日志到文件和屏幕 25 logger.addHandler(console) 26 logger.addHandler(file) 27 28 #输入日志 29 logging.debug(‘this is debug message‘) 30 logging.info(‘this is info message‘) 31 logging.warning(‘this is warning message‘) 32 logging.error(‘this is error message‘) 33 logging.critical(‘this is critical message‘) 34 35 #OUTPUT: 36 #console: 37 2017-12-17 21:42:28,356 6056 MainThread 1088[line:30] INFO this is info message 38 2017-12-17 21:42:28,356 6056 MainThread 1088[line:31] WARNING this is warning message 39 2017-12-17 21:42:28,356 6056 MainThread 1088[line:32] ERROR this is error message 40 2017-12-17 21:42:28,356 6056 MainThread 1088[line:33] CRITICAL this is critical message 41 #file 42 2017-12-17 21:41:17,199 9000 MainThread 8448[line:33] CRITICAL this is critical message 43 2017-12-17 21:42:28,356 6056 MainThread 1088[line:32] ERROR this is error message 44 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()