python3之xml&ConfigParser&hashlib&Subprocess&logging模块

时间：2022-04-09 09:00:51

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 = ""  #通过索引修改某个节点的值

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

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=

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']

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']A@*\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()函数去处理所有它可以处理的情况，因为高级用法可以直接使用底层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)  #返回状态码

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

[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'

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)将日志同时输出到文件和屏幕

 #!/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

相关文章