day20 （logging ，re 模块）

# 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模块：
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')

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

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

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

r_log.critical('000000')

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

#字符串拆分
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!!!