一，复习
# random: random() randint() choice() sample()
# 序列化：对象需要持久化存储或传送 对象 => 字符串
# json: 用于传输
# -- 1.支持{} [] int float bool str null
# -- 2.是{}与[]的嵌套组合，最外层只能有一个根：要么所有数据由{}起始包裹，要么由[]起始包裹，就是单一1支持的类型数据
# -- 3.字符串必须由""包裹
# pickle: 用于存储，支持所有数据类型，采用二进制进行操作
# 序列化：dump dumps
# 反序列化：load loads
# shelve: 采用字典形式进行序列化与反序列化
shv_dic = shelve.open('序列化文件')
# 序列化
shv_dic[key] = value
# 反序列化
shv_dic[key]
# open('序列化文件'， writeback=True) 可以是序列化的值为可变类型，更新其值，能实时同步到文件
# shutil：操作文件与文件夹的模块
# 加密：碰撞解密
# hashlib：lock_obj = hashlib.md5('创建对象时的数据可有可无')
# hmac: lock_obj = hmac.new('必须提前给数据')
# 更新加密的数据：lock_obj.update('二进制的数据'.encode('utf-8'))
# 获取加密结果：lock_obj.hexdigest()
二，logging模块
'''
日志：日常的流水=》日志文件，将程序运行过程中的状态或数据操作进行记录，且记录到日志文件中
为什么要记录日志：优化程序，更好的服务于上帝
# logging模块：
1，一共分为五个打印级别
2，级别本身没有代表信息重要性的区别，只是包含级别信息，可以约定日志的重要性
'''''
import logging
logging.debug('debug msg')
logging.info('info msg')
logging.warning('warning msg') #WARNING:root:warning msg
# logging模块.warn('warning msg') #已经没用了
logging.error('error msg') #ERROR:root:error msg
logging.critical('critical msg') #CRITICAL:root:critical msg
# logging模块.fatal('critical msg') #CRITICAL:root:critical msg
三，标准三流
import sys
print(sys.stdout) #<_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>
'''
标准输出流 sys.stdout：print()的底层实现'''
sys.stdout.write('123\n')
sys.stdout.write('呵呵\n')
print('哈哈',end='')
print()
import logging
'''标准错误流 sys.stderr：异常及logging默认打印方式的底层'''
logging.critical('msg')
print(sys.stderr) #<_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>
sys.stderr.write('输出的信息\n')
'''标准输入流 sys.stdin：input 的底层'''
print(sys.stdin) #<_io.TextIOWrapper name='<stdin>' mode='r' encoding='UTF-8'>
res = sys.stdin.readline()
print(res)
res = sys.stdin.read(3)
print(res)
res = input()
print(res)
四，四大成员
import logging
'''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(fmt2)
a_file_handler.setFormatter(fmt1)
b_file_handler.setFormatter(fmt2)
logger.critical('msg')
五，logging基本配置
import logging
import sys
'''logging配置：格式化输出 1：输出的方式 2，输出的格式 3,输出的位置'''
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.配置
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'D:\Python_Project\ClassRoom\day20\logging模块\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_cmd', 'o_file']
}
}
}
# 2.加载配置
import logging.config
logging.config.dictConfig(LOGGING_DIC)
# 3.使用
log = logging.getLogger('o_owen')
log.warning('')
六，多logger共存
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，设置句柄级别：
——系统句柄默认级别warning
——自定义的句柄级别默认同logger，也可以在logger基础上再加以限制
'''
'''log1可以打印DEBUG以上的信息，但往不同位置打印，采用不同句柄的二次级别限制'''
h1.setLevel(logging.DEBUG)
h2 = logging.FileHandler('c.log')
h2.setLevel(logging.WARNING)
'''5，logger添加句柄'''
log1.addHandler(h2)
log1.addHandler(h1)
log1.debug('debug')
log1.info('info')
log1.warning('warning')
log1.error('error')
log1.critical('critical')
log2.critical('')
r_log.critical('')
七，re 模块：
'''
re：就是正则，是有语法规则的字符串，用来匹配目标字符串的
'''''
import re
data = 'https://www.baidu.com'
'''
需求：判断该数据是否是合法的url链接
合法的url应该满足：以https:// | http:// 开头 且以 com | cn结尾
字符串匹配:根据你的规定书写字符串与目标字符串进行配对，如果配对称成功，代表目标字符串满足需求
正则表达式：是一个可以同时制定多个规则的字符串
'''
res = re.findall('https://www.baidu.com',data)
print(data)
'''将目标字符串中的所有数字找出'''
data = '123abc哈哈66'
res = re.findall(r'\d',data) #\d就代表数字 ['1', '2', '3', '6', '6']
print(res)
'''找字母'''
res = re.findall('[a-z]',data) #['a', 'b', 'c']
print(res)
八，正则语法：
'''单个字符'''''
import re
#re.I 不区分大小写的匹配
print(re.findall(r'a','123abc哈哈ABC',flags=re.I)) #['a', 'A']
#a|b a或b单个字符
print(re.findall(r'a|b','123abc哈哈ABC',flags=re.I)) #['a', 'b', 'A', 'B']
#[a,b] a或，或b 单个字符
print(re.findall(r'[a,b]','123a,bc哈哈ABC',flags=re.I)) #['a', ',', 'b', 'A', 'B']
#[^ab] 非a及非b的所有单个字符
print(re.findall(r'[^ab]','123a,bc哈ABC',flags=re.I)) #['1', '2', '3', ',', 'c', '哈', 'C']
#[a-z] 所有单个小写字母 [A-Z]所以单个大写字母 [0-9]所有单个数字
print(re.findall(r'[a-z]','123a,bc哈ABC')) #['a', 'b', 'c']
print(re.findall(r'[0-9]','123a,bc哈ABC')) #['1', '2', '3']
#所有小写大写数字单个字符
print(re.findall(r'[a-z]|[A-Z]|[0-9]','123a,bc哈ABC')) #['1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C']
print(re.findall(r'[a-zA-Z0-9]','123a,bc哈ABC')) #['1', '2', '3', 'a', 'b', 'c', 'A', 'B', 'C']
# \d 单个数字 == [0-9]
print(re.findall(r'\d','123a,bc哈ABC')) #['1', '2', '3']
# \w == [A-Za-z0-9] 常见的汉字理解为单个字母
print(re.findall(r'\w','123a,bc哈ABC')) #['1', '2', '3', 'a', 'b', 'c', '哈', 'A', 'B', 'C']
# \s 单个空：空格，制表符，换页符等
# print('\f\n\t\r\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','123a,bc哈ABC')) #['a', ',', 'b', 'c', '哈', 'A', 'B', 'C']
#单个汉字
print(re.findall(r'[\u4e00-\u9fa5]','123a,bc哈ABC')) #['哈']
九，正则匹配步骤：
import re
print(re.findall(r'\\','a\d\p\\')) #['\\', '\\', '\\']
print(re.findall(r'\\',r'a\d\p\\')) #['\\', '\\', '\\', '\\']
print(re.findall(r'\n','\n')) #['\n']
print(re.findall(r'\d','\d')) #[]
print(re.findall(r'\\d','\d')) #['\\d']
#底层实现
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') #转换成匹配数字的正则对象
res = re_obj.findall('\n') #代表换行，不能被匹配
print(res) #[]
res = re_obj.findall(r'\n') #就代表\n，能被匹配
print(res) #['\\n']
十，多个字符：
import re
#.会匹配\n以外的所有单个字符
print(re.findall(r'.','*\_+=\n\t\r')) #['*', '\\', '_', '+', '=', '\t', '\r']
# re.S会让.匹配所有单个字符
print(re.findall(r'.', '*\_+=\n \r\t', re.S)) #['*', '\\', '_', '+', '=', '\n', ' ', '\r', '\t']
#明确个数的重复
#{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,贪婪匹配，能被匹配多个 ,优先匹配多的
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}', 'ababbabbbabbbb')) #['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']
#匹配以c结尾的
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']
# 问题点：分组，一会解决
print(re.findall(r'(?:ab){2}', 'aabbababab')) # ['abab']
十一，多行匹配：
import re
s = """http://www.baidu.com
https://sina.com.cn
https://youku.com
haam
abchttp://www.oldboy.com
"""
q = """http://www.baidu.com
https://sina.com.cn
https://youku.com
haam
abchttp://www.oldboy.com
"""
#将url都匹配出来=》分组
print(re.findall(r'(?:http://|https://).+(?:com|cn)',s))
#['http://www.baidu.com', 'https://sina.com.cn', 'https://youku.com', 'http://www.oldboy.com']
# ^代表以什么开头，$代表以什么结尾，必须结合flags=re.M来完成匹配
print(re.findall(r'^http.+com$',q,flags=re.M)) #['http://www.baidu.com', 'https://youku.com']
十二，分组匹配：
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', 'w', 'baidu'), ('www', 'w', 'youku')]
#findall是全文匹配，可以从任意位置开始，匹配多次
#match非全文匹配，必须从头开始匹配，只能匹配一次
'''
专门处理分组的方法：分组，分组编号，有名分组，取消分组
取消分组：必须写()，但是()为分组语法，我们只是想通过()将一些数据作为整体，所以()必须，在取消分组即可
(?:)：取消分组只是作为整体 (?p<name>)：有名分组
'''
url = 'www.baidu.com,www.youku.com'
res = re.match(r'((?:www).(?P<name>[a-z]+).com)',url)
print(res) #<re.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
十三，贪婪与非贪婪：
import re
'''
贪婪模式：尽可能多的匹配
{n,}
{,n}
{n,m}
*
+
?
'''
'''
非贪婪模式：尽可能少的匹配
{n,}?
{,n}?
{n,m}?
*?
+?
??
'''
print(re.findall(r'ab{0,}', 'aababbabbb')) #['a', 'ab', 'abb', 'abbb']
print(re.findall(r'ab{0,}?', 'aababbabbb')) #['a', 'a', 'a', 'a']
print(re.findall(r'ab{,3}', 'aababbabbb')) #['a', 'ab', 'abb', 'abbb']
print(re.findall(r'ab{,3}?', 'aababbabbb')) #['a', 'a', 'a', 'a']
print(re.findall(r'ab{1,3}', 'aababbabbb')) #['ab', 'abb', 'abbb']
print(re.findall(r'ab{1,3}?', 'aababbabbb')) #['ab', 'ab', 'ab']
print(re.findall(r'ab*', 'aababbabbb')) #['a', 'ab', 'abb', 'abbb']
print(re.findall(r'ab*?', 'aababbabbb')) #['a', 'a', 'a', 'a']
print(re.findall(r'ab+', 'aababbabbb')) #['ab', 'abb', 'abbb']
print(re.findall(r'ab+?', 'aababbabbb')) #['ab', 'ab', 'ab']
print(re.findall(r'ab?', 'aababbabbb')) #['a', 'ab', 'ab', 'ab']
print(re.findall(r'ab??', 'aababbabbb')) #['a', 'a', 'a', 'a']
s = '<a>s</a><a>sdf</a><a></a>'
print(re.findall(r'<.*>',s)) #['<a>s</a><a>sdf</a><a></a>']
print(re.findall(r'<.*?>',s)) #['<a>', '</a>', '<a>', '</a>', '<a>', '</a>']
print(re.findall(r'</.*?>',s)) #['</a>', '</a>', '</a>']
print(re.findall(r'<.*?>',s)) #['<a>', '</a>', '<a>', '</a>', '<a>', '</a>']
十四，其他方法：
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'tody is \2 \3 \3 \1',s)) #tody is a good good day!!!