今日所学内容

　　　　一、loggin 日志

　　　　二、re 正则表达式

一、logging 日志模块

　　操作日志的模块

日志：日常的流水，将程序运行过程中的状态或数据进行记录，一般都是记录到日志文件中在正常的项目中，项目运行的一些打印信息，采用looging打印到文件中，这个过程就称之为 记录日志

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

logging 四大成员

1.新建打印者
　　logger = logging.getLogger("Owen")

2.创建句柄：输出的位置
　　stream_handler = logging.StreamHandler()　　　　　　# 打印在控制台
　　a_file_handler = logging.FileHandler('a.log')　　　 # 保存在文件 a.log 中　
　　b_file_handler = logging.FileHandler('b.log')　　　# 保存在文件 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)　　　　# 在控制台用 fmt1 打印
　　a_file_handler.setFormatter(fmt1)　　　　# 在 a.log 文件中采用 fmt1 格式存储
　　b_file_handler.setFormatter(fmt2)　　　　# 在 b.log 文件中采用 fmt2 格式存储

　　logger.critical('msg')

多输出者

　　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()　　　　　　　　　　　# 打印在控制台
　　# h1 = logging.FileHandler('a.log')　　　　　　　 # 保存在文件 a.log 中　

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

配置文件的使用

1.配置  (o_开头的是可以自定义的名字，其它的是固定格式)

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

二、re 正则表达式

正则：是有语法的字符串，用来匹配目标字符串的

将目标字符串中的所有符合的数字找出

　　data = '123abc呵呵'

　　res = re.findall(r'\d', data)   # \d 就代表数字

　　print(res)  　　　　　　　　　　# ['1', '2', '3']

单个字符

*re.I 不区分大小写的匹配（a|b a或b单个字符）
　　print(re.findall(r'a', 'abc123嘿嘿abcABC', flags=re.I)) 　　 # ['a', 'a', 'A']print(re.findall(r'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']

*所有小写大写数字单个字符　　[a-z]|[A-Z]|[0-9] = [A-Za-z0-9]
　　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 以为的所有单个字符　　　　　　re.S会让.能匹配所有单个字符
　　print(re.findall(r'.', '*\_+=\n \r\t')) 　　 # ['*', '\\', '_', '+', '=', ' ', '\r', '\t']

　　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

多个字符

明确个数的重复

*{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到无数个
　　print(re.findall(r'ab{2,}', 'ababbabbbabbbb'))  # ['abb', 'abbb', 'abbbb']
　　　　ab{2,}最少匹配abb, 贪婪匹配 abbb 能被匹配为 abb 和 abbb，优先匹配多的

*{,n} 匹配0到n个
　　print(re.findall(r'ab{,2}', 'aababbabbbabbbb'))  # ['a', 'ab', 'abb', 'abb', 'abb']
　　　　ab{,2} 优先匹配abb，然后ab，最后a

*{n,m} 匹配n到m个
　　print(re.findall(r'ab{1,3}', 'aababbabbbabbbb'))  # ['ab', 'abb', 'abbb', 'abbb']

　　　　 ab{1,3} 优先匹配 abbb，再考虑abb, ab

特殊符号的重复

*‘*’： 匹配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']

正则匹配步骤

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

多行匹配

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

s ='''131039946521354269485318649586321　　　　　　　　　　# 匹配手机号19548624152'''print(re.findall(r'^1+[3,5,8,]+[0-9]{9}$', s, re.M))　　　　==> ['13103994652', '13542694853', '18649586321']

分组

　　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

拆分 re.split 与替换 re.sub

　　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!!!' 　　　　　　　　　　　　　　　　　　　　
　　print(re.sub('(day) (a) (good)', r'today is \2 \3 \3 \1', s))

　　　　==> 'today is a good good day'