python中常用模块详解二

log模块的讲解

 Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：

 logger提供了应用程序可以直接使用的接口API；
 handler将(logger创建的)日志记录发送到合适的目的输出；
 formatter决定日志记录的最终输出格式
 filter提供了细度设备来决定输出哪条日志记录；

 logger
 每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，
 比如聊天工具的图形界面模块可以这样获得它的Logger：LOG=logging.getLogger(”chat.gui”)

 还可以绑定handler和filters
 Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
 Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
 Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
 每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
 logging.StreamHandler 使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。
 logging.FileHandler 和StreamHandler 类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件
 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]]])  maxBytes最大长度 backupCount保留的文件个数
 logging.handlers.TimedRotatingFileHandler
 这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，
 而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，
 不过新的文件不是附加数字，而是当前时间。
 它的函数是：TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
                                         when=“S” 秒计算 interveal间隔 backupCount保留的文件个数
 S 秒   M 分   H 小时   D天   W  每星期（interval==0时代表星期一）midnight 每天凌晨
 formatter 组件
 日志的formatter是个独立的组件，可以跟handler组合
 fh = logging.FileHandler("access.log")
 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 fh.setFormatter(formatter) #把formmater绑定到fh上
 如果你想对日志内容进行过滤，就可自定义一个filter
 class IgnoreBackupLogFilter(logging.Filter):
     """忽略带db backup 的日志"""
     def filter(self, record): #固定写法
         return   "db backup" not in record.getMessage()

 # 注意filter函数会返加True or False，logger根据此值决定是否输出此日志

 # 然后把这个filter添加到logger中
 # logger.addFilter(IgnoreBackupLogFilter())

说明解析

　

import logging
from logging import handlers

# 设置一个输出到屏幕上的handler
log_p_handler = logging.StreamHandler()
# 定义一个输入文件的handler
log_f_handler = logging.FileHandler("xx.log", encoding="utf8")
# 这个是那日志截断的例子，按照长度截断
log_f_handler_1 = handlers.RotatingFileHandler("xxx.log", maxBytes=10, backupCount=2, encoding="utf8")
log_f_handler_1.setLevel(logging.WARNING)
log_f_handler.setLevel(logging.WARNING)  # 给出入到文件的handler定义一个日志级别
log_p_handler.setLevel(logging.INFO)  # 给出入到屏幕的handler定义一个日志级别
fm_p = logging.Formatter("%(asctime)s-%(levelname)s->%(message)s", datefmt="%Y-%m-%d %I:%M:%S")  # 定义两个格式
fm_f = logging.Formatter("%(asctime)s-%(filename)s-%(levelname)s->%(message)s", datefmt="%Y-%m-%d %I:%M:%S")
# 把格式分别加到 对用的handler中
log_f_handler.setFormatter(fm_f)
log_f_handler_1.setFormatter(fm_f)
log_p_handler.setFormatter(fm_p)
log = logging.getLogger("test")  # 生成一个log接口
# 将自己定义的handler 加到log中
log.addHandler(log_p_handler)
log.addHandler(log_f_handler)
log.addHandler(log_f_handler_1)
# 设置log全局的日志级别  如果不设置  则默认WARNING级别
log.setLevel(logging.INFO)
log.info("info log")
log.warning("warn log")
log.debug("debug log")

　　

subproess模块提供统一的模块来实现对系统命令或脚本的调用

# 三种执行命令的方法
# subprocess.run(*popenargs, input=None, timeout=None, check=False, **kwargs) #官方推荐
# subprocess.call(*popenargs, timeout=None, **kwargs) #跟上面实现的内容差不多，另一种写法
# #subprocess.Popen() #上面各种方法的底层封装
# run的标准写法
import subprocess

subprocess.run(['df', '-h'], stderr=subprocess.PIPE, stdout=subprocess.PIPE, check=True)
# 参数解析：['df','-h'] 列表 执行命令 subprocess 会拼接起来  stdout 标准输出=PIPE管道符 check  检查TRUE则报错
# 此外还可以跟shell=TRUE  这样就可以直接写命令 ：
subprocess.run('df -h|grep disk1', shell=True)  # shell=True的意思是这条命令直接交给系统去执行，不需要python负责解析
# 执行命令，返回命令执行状态 ， 0 or 非0
retcode = subprocess.call(["ls", "-l"])
# 执行命令，如果命令结果为0，就正常返回，否则抛异常
subprocess.check_call(["ls", "-l"])
# 0
# 接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果
subprocess.getstatusoutput('ls /bin/ls')
# (0, '/bin/ls')
# 接收字符串格式命令，并返回结果
subprocess.getoutput('ls /bin/ls')
# '/bin/ls'
# 执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
res = subprocess.check_output(['ls', '-l'])
# res= b'total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n'

# Popen   不会等待命令执行返回结果 而是返回一个句柄 a调用poll()方法可以检测a的指定状态
a = subprocess.Popen('sleep 10', shell=True, stdout=subprocess.PIPE)
#这里还有其他方法  就不一一赘述了
# a.wait()  a.kill()  a.pid()
# a.send_signal()  a.terminate()

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

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

m=hashlib.md5()
m.update(bytes("我", encoding="utf8"))
m.update(b'it is me ')
print("二进制", m.digest())
print("十六进制", m.hexdigest())
#以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
print("".center(50,"*"))
m1=hashlib.md5(bytes("生成时加密",encoding="utf8"))
m1.update(bytes("我", encoding="utf8"))
m1.update(b'it is me ')
print("二进制", m.digest())
print("十六进制", m.hexdigest())

 re模块：正则表达式就是字符串的匹配规则，在多数编程语言里都有相应的支持，python里对应的模块是re

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
# '^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
# '$'     匹配字符结尾， 若指定flags MULTILINE ,re.search('foo.$','foo1\nfoo2\n',re.MULTILINE).group() 会匹配到foo1
# '*'     匹配*号前的字符0次或多次， re.search('a*','aaaabac')  结果'aaaa'
# '+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
# '?'     匹配前一个字符1次或0次 ,re.search('b?','alex').group() 匹配b 0次
# '{m}'   匹配前一个字符m次 ,re.search('b{3}','alexbbbs').group()  匹配到'bbb'
# '{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
# '|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
# '(...)' 分组匹配， re.search("(abc){2}a(123|45)", "abcabca456c").group() 结果为'abcabca45'
#
#
# '\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的，相当于re.match('abc',"alexabc") 或^
# '\Z'    匹配字符结尾，同$
# '\d'    匹配数字0-9
# '\D'    匹配非数字
# '\w'    匹配[A-Za-z0-9]
# '\W'    匹配非[A-Za-z0-9]
# 's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
#
# '(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")
#  结果{'province': '3714', 'city': '81', 'birthday': '1993'}

模式详解

import re

s = 'ab23cd121rf'

res=re.match("[0-9]",s) #从头开始匹配  匹配一个就结束
print(res)
res = re.search("[0-9]{2}", s)  # 从全部的字符匹配  匹配一个就结束
print(res)  # 对象 取里面的值则为group  没有则报错，那结果之前需要判断
if res:
    print(res.group())
else:
    print("none!")
print(re.findall("[0-9]", s))  # 匹配所有 符合 就 把它放在列表
print(re.search(".", "aaa"))  # 从开头一直找 找到 任意字符返回
print(re.search("^a", "aaa"))  # 相当于match('a')
print(re.search("^ab", "abaab"))  # 相当于match('a')
print(re.search("ab+$", "abaabb"))  # 从最后开始找。以abb(多个b)结尾的
print(re.search("[a|A]lex","alexAlex"))   #自己的理解就是拿着alex
 #或 Alex在字符里面找  找到一个满足就可以
print(re.search("[a|A]lex","aaAlex"))
s = '120980199612098769'
#必须是字符匹配
print(re.search("(\d{6})(\d{4})(\d{4})",s).groups())
#分组匹配的装逼
print(re.search("(?P<province>\d{6})(?P<year>\d{4})(?P<mothon>\d{4})", s).groupdict())
f = open("联系方式.txt", encoding="gbk")
data = f.read()
print(data)
f.close()

res = re.findall("(1\d{10})", data)  # 手机号码
print(res)
s = "alex22jack22rain33"
print(re.split("\d", s))  # 按照一种格式分割
print(re.split("\d+", s))
s1 = "alex22jack22rain33#mock-oldboy"
print(re.split("\d+|#|-", s1))

# 所给字符全部匹配成功则返回字符否则为0
# print(re.fullmatch('\w+@\w+\.(com|cn|edu)',"alex@oldboyedu.cn"))
# 模糊找到需要匹配的字符替换
print(re.sub("[\d+|#|-]", "_", s1))

s = '9-2*5/3+7/3*99/4*2998+10*568/14'
# print(re.split('[\*\-/+]',s))   #转义需要\ 来表达
print(re.split('[\*\-/+]', s, maxsplit=2))  # 转义需要\ 来表达 maxsplit 匹配前几个之后停止匹配
# ['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']