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

# 三种执行命令的方法

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

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

'.'     默认匹配除\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']