python20 logging日志模块 re正则模块

佚名 5年前 (2019-05-09) 随笔 1320人围观抢沙发百度已收录

复习

1.random随机数 2.序列化： json--一种语言，序列化，用作传输 pickle--序列化，用作存储 shelve：及时存取的序列化模块 3。加密： hashlib加密#参数可有可无 hmac加密#必须有参数 4.shutill:可以操作权限的处理文件模块。#封装好的便捷算法详解 # 1.random: random() 小数（0，1） randint() 整数（0,10] randrange()整数[0,10] choice() 单列集合随机选一个 sample()单列集合随机选n个 shuffle()随机打散单列集合 #2. 序列化：对象需要持久化存储或传送对象 => 字符串
# json: 用于传输支持dict,list,int,float,null,str,boll
# -- 1.支持{} [] int float bool str null
# -- 2.是{字典}与[列表]的嵌套组合，最外层只能由一个根：要么所有数据由{}起始包裹，要么由[]起始包裹，就是单一1支持的类型数据
# -- 3.字符串必须由""包裹 # pickle: 用于存储，支持所有数据类型，采用二进制进行操作
# 序列化： dumps将对象直接序列化成字符串 dump将对象序列化成的字符串存储到文件中
# 反序列化：load将字符串反序列化成对象 loads将文件读流反序列化成对象 # shelve: 采用字典形式进行序列化与反序列化 shv_dic = shelve.open('序列化文件')
# 序列化
shv_dic[key] = value
# 反序列化
shv_dic[key]
# open('序列化文件'， writeback=True) 可以是序列化的值为可变类型，更新其值，能实时同步到文件
# shutil：操作文件与文件夹的模块
# 3.加密：碰撞解密
# hashlib：lock_obj = hashlib.md5('创建对象时的数据可有可无') # hmac: lock_obj = hmac.new('必须提前给数据') # 更新加密的数据：lock_obj.update('二进制的数据'.encode('utf-8'))
# 获取加密结果：lock_obj.hexdigest() ``` #4.shutill:可以操作权限的处理文件模块。#封装好的便捷算法 #基于路径的文件复制：shutill.copyfile(source_file,target_file) #基于流的文件复制：with open('source_file','rb')as r,open('target_file','wb'):    shutill.copyfileobj(r,w).
#递归删除目标目录：shutill.rmtree('target_folder')
#文件移动：shutill.move('old_file','new_file')
#文件压缩：shutill.make_archive('file_name','format','archive_path') #文件解压：shutill.unpack_archieve(''unpack_file','unpack_name','format') 今日内容 1.logging日志模块 2.re正则模块 引导：来由 ## 标准三流
import sys #标准输入流
# sys.stdin：input的底层
res = sys.stdin.readline() #标准输出流
# sys.stdout：print的底层
sys.stdout.write('输出的信息\n') #标准错误流
# sys.stderr：异常及logging默认打印方式的底层
sys.stderr.write('输出的信息\n')
``` 1.logging模块
# 1)操作日志的模块
# 日志：日常的流水，将程序运行过程中的状态或数据进行记录，一般都是记录到日志文件中
# 在正常的项目中，项目运行的一些打印信息，采用looging打印到文件中，这个过程就称之为记录日志 #2)为什么要建立日志:优化程序，更好地服务于上帝 #3）怎么使用？ print('打印信息') import logging logging.debug('debug msg')#走马观花 logging.info('info msg')#普通 logging.wanning('warning msg')#警告信息 # logging.warn('warning msg')#弃之不用，仍可查 logging.error('error msy')#出错信息 logging.critical('critical msg')#致命错误信息 # logging.fatal('critical msg'))#致命错误信息 #4)logging的基本配置：
（1）输出的方式 （2）输出的格式（3）输出的位置 import logging # logging为默认打印者，名字叫root，配置采用以下方式
h1 = logging.StreamHandler()
h2 = logging.FileHandler('d.log')
logging.basicConfig(
    # filename='my.log',
    # filemode='w',
    # stream=sys.stderr, # 往控制台打印采用具体的输出流
    format='%(asctime)s [%(levelname)s]- %(name)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S',
    level=logging.DEBUG, # 10, 代表DEBUG及DEBUG级别以上都能输出
    handlers=[h1, h2]
) logging.debug("debug")
logging.info("info")
logging.warning("warning")
logging.error("error")
logging.critical("critical")
``` 5)loggin四大成员 # 1.新建打印者
logger = logging.getLogger("Owen") # 2.创建句柄：输出的位置
stream_handler = logging.StreamHandler()
a_file_handler = logging.FileHandler('a.log')
b_file_handler = logging.FileHandler('b.log') # 3.打印者绑定句柄
logger.addHandler(stream_handler)
logger.addHandler(a_file_handler)
logger.addHandler(b_file_handler) # 4.设置格式
fmt1 = logging.Formatter('%(asctime)s - %(msg)s')
fmt2 = logging.Formatter('%(asctime)s [%(name)s] - %(msg)s') # 5.为句柄绑定输出格式
stream_handler.setFormatter(fmt1)
a_file_handler.setFormatter(fmt1)
b_file_handler.setFormatter(fmt2) logger.critical('msg')
``` 6)多logging共存多输出者
import logging
# 1.创建logger
log1 = logging.getLogger('Owen')
log2 = logging.getLogger('Zero')
r_log = logging # 2.logger设置级别
log1.setLevel(logging.DEBUG) # 3.设置句柄
h1 = logging.StreamHandler() # 4.设置句柄级别：
# 1）系统句柄默认级别warning，
# 2）自定义的句柄级别默认同logger，也可以在logger基础上在加以限制
h1.setLevel(logging.DEBUG) # 5.logger添加句柄
log1.addHandler(h1) # log1可以打印DEBUG以上的信息，但往不同位置打印，采用不同句柄的二次级别限制
h2 = logging.FileHandler('c.log')
h2.setLevel(logging.WARNING)
log1.addHandler(h2)
log1.debug('debug')
log1.info('info')
log1.warning('warning')
log1.error('error')
log1.critical('critical') log2.critical('00000') r_log.critical('00000')
``` 总结：logging 配置文件的使用
# 1.配置
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {    #设置格式
        'o_fmt1': {
            'format': '%(name)s:%(asctime)s - %(message)s'
        },
        'o_fmt2': {
            'format': '%(name)s:%(asctime)s [%(levelname)s] - %(message)s'
        }
    },
    'filters': {},    #类（过滤器）
    'handlers': { #句柄
        'o_cmd': {
'level': 'DEBUG',
   类 'class': 'logging.StreamHandler',
格式'formatter': 'o_fmt1'
        },
        'o_file': {
            'level': 'WARNING',
            'class': 'logging.handlers.RotatingFileHandler',
            'formatter': 'o_fmt2',
            'filename': r'F:\python8期\课堂内容\day20\代码\part4\logging.log', # 日志文件
            'maxBytes': 1024*1024*5, # 日志大小 5M
            'backupCount': 5, #日志文件最大个数
            'encoding': 'utf-8', # 日志文件的编码
        }
    },
    'loggers': {
        'o_owen': {
            'level': 'DEBUG',
            'handlers': ['o_cmd', 'o_file']
        },
        'o_zero': {
            'level': 'DEBUG',
            'handlers': ['o_file']
        }
    }
} # 2.加载配置
import logging.config
logging.config.dictConfig(LOGGING_DIC)
# 3.使用
log = logging.getLogger('o_owen')
log.warning('123')
``` 2 re模块 1）概念 # 正则：是有语法的字符串，用来匹配目标字符串的 # 将目标字符串中的所以数字找出
data = '123abc呵呵' res = re.findall(r'\d', data) # \d就代表数字
print(res) # ['1', '2', '3']
``` 2）re语法单个字符 # re.I不区分大小写的匹配
print(re.findall(r'a', 'abc123嘿嘿abcABC', flags=re.I)) # ['a', 'a', 'A'] # a|b a或b单个字符
print(re.findall(r'a|b', 'abc123嘿嘿abcABC', flags=re.I)) # ['a', 'b', 'a', 'b', 'A', 'B'] # [a,b] a或,或b单个字符
print(re.findall(r'[a,b]', 'abc,123嘿嘿abcABC', flags=re.I)) # ['a', 'b', ',', 'a', 'b', 'A', 'B'] # [^ab]非a及非b的所有单个字符
print(re.findall(r'[^ab]', 'abc,123嘿嘿abcABC')) # ['c', ',', '1', '2', '3', '嘿', '嘿', 'c', 'A', 'B', 'C'] # [a-z]所有单个小写字母   [A-Z]所有单个大写字母   [0-9]所有单个数字
print(re.findall(r'[a-z]', 'abc,123嘿嘿abcABC')) # ['a', 'b', 'c', 'a', 'b', 'c']
print(re.findall(r'[0-9]', 'abc,123嘿嘿abcABC')) # ['1', '2', '3'] # 所有小写大写数字单个字符
print(re.findall(r'[a-z]|[A-Z]|[0-9]', 'abc,123嘿嘿abcABC')) # ['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C'] print(re.findall(r'[A-Za-z0-9]', 'abc,123嘿嘿[abcABC')) # ['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C'] # .会匹配除\n以为的所有单个字符
print(re.findall(r'.', '*\_+=\n \r\t')) # ['*', '\\', '_', '+', '=', ' ', '\r', '\t'] # re.S会让.能匹配所有单个字符
print(re.findall(r'.', '*\_+=\n \r\t', flags=re.S)) # ['*', '\\', '_', '+', '=', '\n', ' ', '\r', '\t'] # \d单个数字 == [0-9]
print(re.findall(r'\d', 'abc,123嘿嘿[abcABC')) # ['1', '2', '3']
# \w == [A-Za-z0-9_] 将常见的汉字就理解为单个字母 print(re.findall(r'\w', 'abc,123嘿[_')) # ['a', 'b', 'c', '1', '2', '3', '嘿', '_']
# \s == [\f\n\r\t\v ] 单个空：空格、制表符、换页符等 print(re.findall(r'\s', '\f\n\r\t\v ')) # ['\x0c', '\n', '\r', '\t', '\x0b', ' '] # \D就是\d的对立面：非数字的所有单个字符 \W就是\w的对立面 \S就是\s的对立面
print(re.findall(r'\D', 'abc,123嘿[_')) # ['a', 'b', 'c', ',', '嘿', '[', '_']
# 单个汉字 [\u4e00-\u9fa5]
print(re.findall(r'[\u4e00-\u9fa5]', 'abc,123嘿[_')) # ['嘿'] # 建议使用 [0-9] [A-Za-z0-9_] [\f\n\r\t\v ] [^0-9] [\u4e00-\u9fa5]
# 不建议使用 \d   \w   \s    \D   \w
``` 3)正则匹配步骤
import re
# 1.将r'\\'的正则语法字符串转换成正则对象 '\', 用来匹配 '\' 字符的
# 2.拿着转换后的正则对象，来匹配目标字符串
print(re.findall(r'\\', r'a\d\p\\')) # ['\\', '\\', '\\', '\\']
re_obj = re.compile(r'\n') # 转换成匹配换行符的正则对象
res = re_obj.findall('\n')
print(res) # ['\n'] re_obj = re.compile(r'\\d') # 转换成匹配 \d 的正则对象
res = re_obj.findall('\d')
print(res) # ['\\d'] re_obj = re.compile(r'\d') # 转换成匹配数字的正则对象
res = re_obj.findall('\d') # \d不是数字
print(res) # [] re_obj = re.compile(r'\\n') # 转换成匹配 \n 的正则对象
res = re_obj.findall('\n') # 代表换行，不能被匹配
print(res) # []
res = re_obj.findall(r'\n') # 就代表\n，能被匹配
print(res) # ['\\n']
``` 4)多个字符 # 明确个数的重复
# {n}
print(re.findall(r'a', 'aaabbb')) # ['a', 'a', 'a']
print(re.findall(r'a{2}', 'aaabbb')) # ['aa']
print(re.findall(r'ab', 'aabbababab')) # ['ab', 'ab', 'ab', 'ab']
print(re.findall(r'a{2}b{2}', 'aabbababab')) # ['aabb']
print(re.findall(r'ab{2}', 'aabbababab')) # ['abb'] # {n,} 匹配n到无数个，题中最少匹配abb, 贪婪匹配 abbb 能被匹配为 abb 和 abbb，优先匹配多的
print(re.findall(r'ab{2,}', 'ababbabbbabbbb')) # ['abb', 'abbb', 'abbbb'] # {,n} 匹配0到n个，ab{,2} 优先匹配abb，没有ab也行，如果还没有a也将就
print(re.findall(r'ab{,2}', 'aababbabbbabbbb')) # ['a', 'ab', 'abb', 'abb', 'abb'] # {n,m} 匹配n到m个，ab{1,3} 优先匹配 abbb，再考虑abb, ab
print(re.findall(r'ab{1,3}', 'aababbabbbabbbb')) # ['ab', 'abb', 'abbb', 'abbb'] # 特殊符号的重复
# *: 匹配0到无数个
print(re.findall(r'ab*', 'aababbabbbabbbb')) # ['a', 'ab', 'abb', 'abbb', 'abbbb']
# +: 匹配1到无数个
print(re.findall(r'ab+', 'aababbabbbabbbb')) # ['ab', 'abb', 'abbb', 'abbbb']
# ?: 匹配0到1个
print(re.findall(r'ab?', 'aababbabbbabbbb')) # ['a', 'ab', 'ab', 'ab', 'ab']
# 需求：匹配所有单词
print(re.findall(r'[a-z]+', 'abc def hello print')) # ['abc', 'def', 'hello', 'print']
print(re.findall(r'[a-z]+\b', 'abc def hello print')) # ['abc', 'def', 'hello', 'print'] # \b代表单词边界，用空格(字符串的结尾也包括)作为匹配规则
print(re.findall(r'[a-z]*c', 'abc def hello print acb zc')) # ['abc', 'ac', 'zc']
print(re.findall(r'[a-z]*c\b', 'abc def hello print acb zc')) # ['abc', 'zc']
``` 5）多行匹配
import re
s = """http://www.baidu.com
https://sina.com.cn
https://youku.com
haam
abchttp://www.oldboy.com
"""
# ^代表以什么开头，$代表以什么结尾，必须结合flags=re.M来完成多行匹配
print(re.findall(r'^http.+com$', s, re.M)) # ['http://www.baidu.com', 'https://youku.com'] ``` 6）分组匹配——非常重要 import re url = 'https://www.baidu.com, http://www.youku.com'
# 需求：拿到url的域名的 baidu , youku
print(re.findall(r'www.([a-z]+).com', url)) # ['baidu', 'youku'] # ()代表分组
# findall匹配，如果匹配规则用有分组语法，只存放分组结果
print(re.findall(r'(www).([a-z]+).com', url)) # [('www', 'baidu'), ('www', 'youku')] # 分组的编号：分组的顺序编号按照左括号的前后顺序
print(re.findall(r'(((w)ww).([a-z]+).com)', url)) # [('www.baidu.com', 'www', 'w', 'baidu'), ('www.youku.com', 'www', 'w', 'youku')]
# findall是全文匹配，可以从任意位置开始，匹配多次
# match非全文匹配，必须从头开始匹配，只能匹配一次 # 专门处理分组的方法：分组，分组编号，有名分组，取消分组
# 取消分组: 必须写()，但是()为分组语法，我们只是想通过()将一些数据作为整体，所以()必须，再取消分组即可
# (?:) 取消分组只是作为整体   (?P<名字>) 有名分组
url = 'www.baidu.com,www.youku.com'
res = re.match(r'((?:www).(?P<name>[a-z]+).com)', url)
# print(res) # <_sre.SRE_Match object; span=(0, 13), match='www.baidu.com'>
print(res.group(1)) # www.baidu.com
print(res.group(2)) # baidu
print(res.group('name')) # baidu
``` 7）正则的其他方法拆分与替换
import re s = 'a b ac def'
print(s.split(' ')) # ['a', 'b', 'ac', 'def'] # 正则拆分
s = 'a b,ac@def'
print(re.split(r'[ ,@]', s)) # ['a', 'b', 'ac', 'def']
s = 'python abc python'
print(re.sub('python', 'Python', s)) # Python abc Python
print(re.sub('python', 'Python', s, count=1)) # Python abc python
# 结合分组可以完成信息的重组与替换
s = 'day a good!!!' # 'a good good day'
print(re.sub('(day) (a) (good)', r'today is \2 \3 \3 \1', s))
```