# 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 logginglogging.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 sysprint(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 logging1，创建logger
log1 = logging.getLogger('Owen')
log2 = logging.getLogger('Zero')
r_log = logging2，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 reprint(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 reurl = '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!!!