python常用模块（二）

---

1.ConfigParser模块

用于生成和修改配置文档，在python3.x中变更为configparser

 1 [DEFAULT]
 2 ServerAliveInterval = 45
 3 Compression = yes
 4 CompressionLevel = 9
 5 ForwardX11 = yes
 6
 7 [bitbucket.org]
 8 User = hg
 9
10 [topsecret.server.com]
11 Port = 50022
12 ForwardX11 = no

常见conf格式

 import configparser

 config = configparser.ConfigParser()
 config["DEFAULT"] = {'ServerAliveInterval': '',
                       'Compression': 'yes',
                      'CompressionLevel': ''}

 config['bitbucket.org'] = {}
 config['bitbucket.org']['User'] = 'hg'
 config['topsecret.server.com'] = {}
 topsecret = config['topsecret.server.com']
 topsecret['Host Port'] = ''     # mutates the parser
 topsecret['ForwardX11'] = 'no'  # same here
 config['DEFAULT']['ForwardX11'] = 'yes'
 with open('example.ini', 'w') as configfile:
    config.write(configfile)

 #读取
 >>> import configparser
 >>> config = configparser.ConfigParser()
 >>> config.sections()
 []
 >>> config.read('example.ini')
 ['example.ini']
 >>> config.sections()
 ['bitbucket.org', 'topsecret.server.com']
 >>> 'bitbucket.org' in config
 True
 >>> 'bytebong.com' in config
 False
 >>> config['bitbucket.org']['User']
 'hg'
 >>> config['DEFAULT']['Compression']
 'yes'
 >>> topsecret = config['topsecret.server.com']
 >>> topsecret['ForwardX11']
 'no'
 >>> topsecret['Port']
 ''
 >>> for key in config['bitbucket.org']: print(key)
 ...
 user
 compressionlevel
 serveraliveinterval
 compression
 forwardx11
 >>> config['bitbucket.org']['ForwardX11']
 'yes'

 #增删改查
 [section1]
 k1 = v1
 k2:v2

 [section2]
 k1 = v1

 import ConfigParser

 config = ConfigParser.ConfigParser()
 config.read('i.cfg')

 # ########## 读 ##########
 #secs = config.sections()
 #print secs
 #options = config.options('group2')
 #print options

 #item_list = config.items('group2')
 #print item_list

 #val = config.get('group1','key')
 #val = config.getint('group1','key')

 # ########## 改写 ##########
 #sec = config.remove_section('group1')
 #config.write(open('i.cfg', "w"))

 #sec = config.has_section('wupeiqi')
 #sec = config.add_section('wupeiqi')
 #config.write(open('i.cfg', "w"))

 #config.set('group2','k1',11111)
 #config.write(open('i.cfg', "w"))

 #config.remove_option('group2','age')
 #config.write(open('i.cfg', "w"))

使用模块生成

2.hashlib模块

用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

 import hashlib

 -----md5-----
 md_five = hashlib.md5()
 md_five.update(b'Hello World')            #加密

 print(md_five.digest())                         #二进制hash
 print(md_five.hexdigest())                   #十六进制hash

 '''
 def digest(self, *args, **kwargs): # real signature unknown
     """ Return the digest value as a string of binary data. """
     pass

 def hexdigest(self, *args, **kwargs): # real signature unknown
     """ Return the digest value as a string of hexadecimal digits. """
     pass

 '''
 ----sha1-----
 md_five = hashlib.sha1()
 md_five.update(b'Hello World')

 print(md_five.hexdigest())

 -----sha256-----
 md_five = hashlib.sha256()
 md_five.update(b'Hello World')

 print(md_five.hexdigest())

 -----sha384-----
 md_five = hashlib.sha384()
 md_five.update(b'Hello World')

 print(md_five.hexdigest())

 -----sha512-----
 md_five = hashlib.sha512()
 md_five.update(b'Hello World')

 print(md_five.hexdigest())

 #还有一个，这个就是相当于双层加密，大家应该都知道撞库啊，那么用了这个你解掉一层还有一层，是不是非常的牛X！

 #HMAC：散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；
 一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密后的值 跟 发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。

 #怎么用呢？？？
 import hmac

 hm = hmac.new(b'Hello World!','你好世界!'.encode(encoding="utf-8"))
 print(hm.digest())
 print(hm.hexdigest())

3.subprocess模块

　　这个模块跟os模块有点类似，也是可以和操作系统进行交互

　　我们这里举个例子

　　

import os

os.system("dir")
#这里会直接打印到屏幕上，也就是直接输出结果，那我想储存到一个变量里可以吗？
a = os.system("dir")
a
>>>0
#为什么输出的是0呢？os.system()只能输出命令结果到屏幕，赋值则返回的是命令执行结果，0为成功，失败则为非0而不是1

#那么我想保存到一个变量里就要用os.popen()
os.popen("dir"),read

　　subprocess是从3.x的新模块，比os更好用，接下来我们就举一些例子

import subprocess

#run
subprocess.run("df -h",shell = True)
#命令正常则执行0，命令错误会报错

#call
subprocess.call("df -h",shell = True)
#命令正常则执行并返回状态0，命令错误会报错并返回状态非0

#check_call
subprocess.echk_call("df -h",shell = True)
#同上

#getstatusoutput
subprocess.getstatusoutput('mkdir -p /Q/Q/Q')
>>>(0, '')
#接收命令，以元组的方式返回，第一个为执行状态，第二个为执行结果

#getoutput
#跟上面比没有执行状态

#check_output
subprocess.check_output("ls -l",shell = True)
#直接返回结果,以二进制方式返回

#上面的这些底层封装的都是subprocess.Popen
例子：
a = subprocess.Popen("pwd",shell = True,stdout = subprocess.PIPE)
a.stdout.read()

#stdin:标准输入
#stdout:标准输出
#stderr:标准错误

#poll
a = subprocess.Popen("sleep 10;echo 'hehe'",shell = True,stdout=subprocess.PIPE)
print(a.poll())
>>>None
print(a.poll())
>>>0
#查询执行状态，未执行完返回None，执行完返回0，执行失败返回非0，有一个类似的是wait()

#terminate:杀掉所启动进程
#communicate:等待任务结束

可用参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
  所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
• shell：同上
• cwd：用于设置子进程的当前目录
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
• startupinfo与createionflags只在windows下有效
  将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
• 输入进行某环境，依赖再输入，如：python

4.logging模块

#做运维的肯定要记录日志，不管是服务的报警还是记录日常的错误以及一些其他信息，日志都是不可或缺的.在python中有一个logging模块使专门用来干这个的，可以用logging模块来记录各种格式的日志，熟悉日志程序的都知道，日志有五个级别，分别是debug(), info(), warning(), error() and critical(),让我们看看5个级别都如何使用

 import logging

 logging.warning("Hello World!")
 logging.debug("Hello World!")
 logging.info("Hello World!")
 logging.error("Hello World!")
 logging.critical("Hello World!")
 >>>WARNING:root:Hello World!
 ERROR:root:Hello World!
 CRITICAL:root:Hello World!

 #诶，这里为什么只打印除了"warning","error","critical"这三个级别呢？

 #日志肯定是可以写到文件里的,so
 logging.basicConfig(filename="cacti.log",level=logging.DEBUG)  #level是日志级别
 #这样就写到文件里了，再写就是追加不会覆盖，设置日志级别，只会把比设置的日志级别高的日志写到日志中，比如设置的是error,那么debug就不会出现在日志中

 #那么做运维的就会说了“你TM的时间呢，没有时间我排个毛线的错”，说得好，所以呢：

 logging.basicConfig(filename="cacti.log",level=logging.ERROR,format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
 logging.error("Hello error")
 >>>11/23/2017 02:45:46 PM Hello error

#以下是其他格式

日志格式

%(name)s	Logger的名字
%(levelno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d	输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s	字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d	线程ID。可能没有
%(threadName)s	线程名。可能没有
%(process)d	进程ID。可能没有
%(message)s	用户输出的消息

通过上面的东西呢，我们知道了日志可以输出到屏幕上也可以输出到文件里，那么我想同时输出到文件中和屏幕上呢.那么我们就需要学习其他姿势

logging模块记录日志主要分为四个类，请看下面

1.logger：用户可直接调用

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

2.handler：将(logger)创建的日志信息发送到指定的输出位置

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

3.filter：可以用来过滤日志信息（一般用不到）

4.formatter：就跟上面提到的fomat一样，用于决定输出格式

#这俩不难，就那么几个用法，就不多说了，接下来我们填一下坑，刚才说到如何同时屏幕输出和文件输出

 import logging
 logger = logging.getLogger("log")                      #定义一个logger
 logger.setLevel(logging.DEBUG)                         #定义logger日志最小级别

 delog = logging.StreamHandler()                       #定义屏幕输出handler
 delog.setLevel(logging.DEBUG)

 errlog = logging.FileHandler("error.txt")           #定义文件输出
 errlog.setLevel(logging.ERROR)

 delog_format = logging.Formatter("%(asctime)s %(lineno)d %(message)s")   #定义屏幕输出格式
 errlog_format = logging.Formatter("%(asctime)s %(message)s")               #定义文件输出格式
 delog.setFormatter(delog_format)                                              #给delog增加格式
 errlog.setFormatter(errlog_format)                                            #给errlog增加格式

 logger.addHandler(delog)
 logger.addHandler(errlog)                                                     #给logger增加handler

 logger.warning("Hello World")

 >>>2017-11-10 22:12:10,480 19 Hello World

 #到这里大家会发现，只有屏幕输出了，为什么文件没有输出呢，因为我们定义的屏幕输出handler的最小级别为error，输出的级别是warning，所以没有输出，利用这个呢我们就可以将一些重大错误输出到文件且报警，而一些类似debug,warning的呢就可以输出到屏幕

#运维平常要看很多日志，可是如果把每一条记录进去，就会造成一个超大的文件，所以会定期删除日志，那么python有一个日志文件截断的功能

 import logging
 from logging import handlers
 logger = logging.getLogger("log")                      #定义一个logger
 logger.setLevel(logging.DEBUG)                         #定义logger日志最小级别

 errlog = handlers.RotatingFileHandler(filename="error.log",maxBytes=10,backupCount=3)
 #定义文件输出,到达10个字节则自动将error.log改名为error.log.1,有了.1则变成.2然后在重新创建一个error.log,但是呢最多备份3个
 errlog.setLevel(logging.ERROR)

 errlog_format = logging.Formatter("%(asctime)s %(message)s")               #定义文件输出格式
 errlog.setFormatter(errlog_format)                                            #给errlog增加格式

 logger.addHandler(errlog)                                                     #给logger增加handler

 logger.error("Hello World")
 logger.error("Hello World")
 logger.error("Hello World"
 #这样你就会发现你多了几个文件*.log.1,*.log.2,*.log.3

 #上面呢是按文件大小来截断，还有一个按时间来截断

 import logging,time
 from logging import handlers
 logger = logging.getLogger("log")                      #定义一个logger
 logger.setLevel(logging.DEBUG)                         #定义logger日志最小级别

 errlog = handlers.TimedRotatingFileHandler(filename="error.log",when="S",interval=1,backupCount=3,encoding="utf-8")          #定义文件输出,文件名，时间单位为秒,1秒备份一次，最多三次
 errlog.setLevel(logging.ERROR)

 errlog_format = logging.Formatter("%(asctime)s %(message)s")               #定义文件输出格式
 errlog.setFormatter(errlog_format)                                            #给errlog增加格式

 logger.addHandler(errlog)                                                     #给logger增加handler

 logger.error("你好世界1")
 time.sleep(2)
 logger.error("你好世界2")
 time.sleep(2)
 logger.error("你好世界3")
 time.sleep(2)
 logger.error("你好世界4")
 time.sleep(2)
 logger.error("你好世界5")
 #多了三个带时间格式的error.log.2017...

5.re正则表达式模块

熟悉linux的知道很多用来匹配的语句，比如grep,awk,sed等，那么python中也有一个re也可以做到

举一些常用的匹配字符：

 "."  # 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
 re.search(".{10}","name:Daniel age:18")
 >>><_sre.SRE_Match object; span=(0, 10), match='name:Danie'>

 "^"  #匹配字符开头，若指定flags MULTILINE,这种也可以匹配上
 (r"^a","\nabc\neee",flags=re.MULTILINE)
 re.search("^name","name:Daniel age:18")
 >>><_sre.SRE_Match object; span=(0, 4), match='name'>

 "$"  # 匹配字符结尾，或re.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
 re.search("18$","name:Daniel age:18")
 >>><_sre.SRE_Match object; span=(16, 18), match=''>

 "*"  #匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
 >>>re.findall("ab*","abbb2abb2ab2")
 ['abbb', 'abb', 'ab']

 "+"    #匹配前一个字符1次或多次
 >>>re.findall("a+","abbb2abb2ab2")
 ['a', 'a', 'a']

 "?"  #匹配前一个字符1次或0次
 >>>re.findall("a?","abbb2abb2ab2")
 ['a', '', '', '', '', 'a', '', '', '', 'a', '', '', '']

 "{n}"  #匹配前一个字符n次
 re.findall("ab{3}","abbb2abb2ab2")
 ['abbb']

 "{n,m}"   #匹配前一个字符n到m次
 re.findall("ab{1,3}","abbb2abb2ab2")
 ['abbb', 'abb', 'ab']

 "|"    #匹配|左或|右的字符
 re.findall("AB|ab","ABabbb2abb2ab2")
 ['AB', 'ab', 'ab', 'ab']

 '(```)'  #分组匹配
  re.findall("(\d+)(a|b)","ABabbb2abb2ab2")
 >>>[('', 'a'), ('', 'a')]
 re.search("(?P<name>[A-z]{1,6})(?P<age>[0-9]{2})","Daniel18").groupdict()
 >>>{'name': 'Daniel', 'age': ''}

 "\A" #从头开始匹配
 re.findall("\AAB","ABabbb2abb2ab2")
 >>>['AB']

 '\Z'    #匹配字符结尾，同$
 re.findall("2\Z","ABabbb2abb2ab2")
 >>>['']

 "\d"   #匹配数字
 re.findall("\d","ABabbb2abb2ab2")
 ['', '', '']

 "\D"  #匹配非数字
 re.findall("\D","ABabbb2abb2ab2")
 >>>['A', 'B', 'a', 'b', 'b', 'b', 'a', 'b', 'b', 'a', 'b']

 "\w"   #匹配[A-Za-z0-9]
 re.findall("\w","ABabbb2abb2ab2")
 >>>['A', 'B', 'a', 'b', 'b', 'b', '', 'a', 'b', 'b', '', 'a', 'b', '']

 "\W"   #匹配非[A-Za-z0-9]
 re.findall("\W","ABabbb2abb2ab2$!##@")
 >>>['$', '!', '#', '#', '@']

 's'     匹配空白字符、\t、\n、\r ,
 re.search("\s+","1\n2\t3\n4\n5\6").group()
 >>>'\n'

大家从上面可以看到re.findall,re.search，这些是什么意思呢？还有没有别的呢？

 re.match 从头开始匹配
 re.match("a+","sa")                           #这里就匹配不到
 re.match("a+","asa")
 >>><_sre.SRE_Match object; span=(0, 1), match='a'>  #只匹配开头有的

 re.search 匹配包含
 re.search("a+","sa")
 >>><_sre.SRE_Match object; span=(1, 2), match='a'>      #匹配所有的，一般我们都用这个

 re.findall 把所有匹配到的字符放到以列表中的元素返回
 re.findall("a+","asaa")
 >>>['a', 'aa']                          #返回所匹配到的元素

 re.split 以匹配到的字符当做列表分隔符
  re.split("\d+","a1b2c3d4e5")
 ['a', 'b', 'c', 'd', 'e', '']                 #把数字都给分割

 re.sub      匹配字符并替换
 re.sub("\d","~","a1b2c3d4e5f6")
 'a~b~c~d~e~f~'                  #将数字替换成~

反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

re.split("\\\\",r"usr\local\python")
>>>['usr', 'local', 'python']  

re.split("\\\\",r"usr\\local\python")
>>>['usr', '', 'local', 'python']

re.split("\\/",r"usr\\local\python")
>>>['usr\\\\local\\python']

re.split("\/",r"/usr\\local\python")
>>>['', 'usr\\\\local\\python']

#四个\匹配一个\

到这里你会问了还有吗，还有一点点你需要稍微知道的，当然忘掉也无所谓

 re.I(re.IGNORECASE): 忽略大小写
 re.findall("a+","abAbAbab",flags=re.I)
 >>>['a', 'A', 'A', 'a']

 M(MULTILINE): 多行模式，改变'^'和'$'的行为
 re.findall("^a","abc\nabc\nabc",flags=re.M)
 >>>['a', 'a', 'a']               #匹配多行

 re.findall("c$","abc\nabc\nabc",flags=re.M)
 >>>['c', 'c', 'c']

 S(DOTALL):改变"."的行为
 re.findall(".","abc\nabc\nabc")
 >>> ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] #"."原本是匹配不到'\n'

 re.findall(".","abc\nabc\nabc",flags=re.S)
 >>> ['a', 'b', 'c', '\n', 'a', 'b', 'c', '\n', 'a', 'b', 'c']  #现在就匹配到

---