16.re模块，序列化与反序列化，time与datetime模块，random模块

• 引子

• re模块

• json&pickle模块

• time与datetime模块

• random模块

---

• re模块

• 什么是正则？

正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

注意：re模块不是内置的，是属于标准库的，创建模块不要与标准库模块名重名，容易发生冲突

常用匹配模式（元字符）

常用匹配模式的具体用法:

improt re

print(re.findall("abc","abcxxaabcxabcyyyabc"))
# abcxxaabcxabcyyyabc
# abc-->abc-abc-->abc   # 依次匹配,吃掉属于它的范畴
# ['abc','abc','abc','abc']


# w 匹配字母数字加下划线
print(re.findall("w","hello_123 * -+"))
# ['h', 'e', 'l', 'l', 'o', '_', '1', '2', '3']
print(re.findall("awb","a1b a_b a+b a-b aab aaaaaab")) # 
# ['a1b', 'a_b', 'aab', 'aab']

# W 匹配非字母数字加下划线                                 
print(re.findall("W","hello_123 * -+"))
# [' ', '*', ' ', '-', ' ', '+']
                                             
# s 匹配任意空白字符
print(re.findall("s","a b  
	c123"))
# [' ', ' ', ' ', '
', '	']

# S 匹配任意非空白字符
print(re.findall("S","a b  
	c123"))
# ['a', 'b', 'c', '1', '2', '3']

# d 匹配任意数字 等同于（0-9）
print(re.findall("d","a b  
	c123"))
# ['1', '2', '3']

# D 匹配任意非数字
print(re.findall("D","a b  
	c123"))
# ['a', ' ', 'b', ' ', ' ', '
', '	', 'c']

# ^ 匹配字符串开头
print(re.findall("^awb","a1b a_b a+b a-b aab aaaaaab"))
# ['a1b']  # ^ 代表从头开始匹配，找到就结束                    

# $ 匹配字符串的末尾
print(re.findall("awb$","a1b a_b a+b a-b aab aaaaaab"))
# ['aab']  # $代表从末尾开始匹配，找到就结束                               
print(re.findall('^egon$',"egon"))
# ['egon'] 

# A 匹配字符串开始   匹配字符串结尾
print(re.findall('Aegon',"egon"))
# ['egon'] 


# A和 与 ^和$ 的区别   
print(re.findall('^egon$',"""
egon
123egon
egon123
egon
""",re.M))
# ['egon', 'egon']

print(re.findall('Aegon',"""
egon
123egon
egon123
egon
""",re.M))
# []          # A   是会忽略 re.Multiline 选项


# 
匹配换行符 	匹配制表符  # 
 	 都是空
print(re.findall('
',"a
b
c"))
# ['
', '
']

print(re.findall('	',"a	b
c"))
# ['	']

print(re.findall('
',"""
a
b
c
"""))
# ['
', '
', '
', '
']


# .匹配任意字符，除了换行符
print(re.findall('a.c',"a1c a2c aAc a
c aaaac"))
# ['a1c', 'a2c', 'aAc', 'aac']

# .匹配，当re.DOTALL标记被指定时，可以匹配包括换行符的任意字符
print(re.findall('a.c',"a1c a2c aAc a
c aaaac",re.DOTALL))
# ['a1c', 'a2c', 'aAc', 'a
c', 'aac']

# []用来表示一组字符串，单独列出
print(re.findall('a[1+]c',"a1c a+c aAc a
c aaaac",re.DOTALL))
# ['a1c', 'a+c']
print(re.findall('a[0-9]c',"a1c a9c a10c aAc a
c aaaac",re.DOTALL))# 匹配0-9的范围
# ['a1c', 'a9c']
print(re.findall('a[a-z]c',"a1c a9c a10c aAc a
c aaaac",re.DOTALL))
# ['aac']
print(re.findall('a[A-Z]c',"a1c a9c a10c aAc a
c aaaac",re.DOTALL))
# ['aAc']

print(re.findall('a[-+*/]c',"a+c a-c a*c a/c a1c a9c aAc"))
# ['a+c', 'a-c', 'a*c', 'a/c']

print(re.findall('a[-+*/]c',"a+c a-c a*c a/c a1c a9c aAc"))
# ['a+c', 'a-c', 'a*c', 'a/c']

print(re.findall('a[^-+*/]c',"a+c a-c a*c a/c a1c a9c aAc"))
# ['a1c', 'a9c', 'aAc']

# ?：左边那一个字符出现0次或者1次
print(re.findall('ab?',"b a abbbbbbbb ab"))
# ['a', 'ab', 'ab']                                 
print(re.findall('ab{0,1}',"b a abbbbbbbb ab"))
# ['a', 'ab', 'ab']

# *：左边那一个字符出现0次或者无穷次
print(re.findall('ab*',"b a abbbbbbbb ab"))
# ['a', 'abbbbbbbb', 'ab']                             
print(re.findall('ab{0,}',"b a abbbbbbbb ab"))
# ['a', 'abbbbbbbb', 'ab']

# +：左边那一个字符出现1次或者无穷次
print(re.findall('ab+',"b a abbbbbbbb ab"))
# ['abbbbbbbb', 'ab']                        
print(re.findall('ab{1,}',"b a abbbbbbbb ab"))
# ['abbbbbbbb', 'ab']


# {n,m}：左边那一个字符出现n次或m次
print(re.findall('ab{2,4}',"b a abbbbbbbb ab"))
# ['abbbb']                              
print(re.findall('ab{2,4}',"b a abb abbb abbbbbbbb ab"))
# ['abb', 'abbb', 'abbbb']

print(re.findall('a.*?c',"a123dsfc+-12313xdfsfdc"))
# ['a123dsfc']                       


print(re.findall("href='(.+?)'","<a href='https://www.baidu.com.cn'>'我特么是百度啊'</a><a href='https://www.sina.com.cn'>'我特么是新浪啊'</a>"))
# ['https://www.baidu.com.cn', 'https://www.sina.com.cn']                              


print(re.findall('a.*?b','a123b ab'))
# ['a123b', 'ab']
print(re.findall('a.+?b','a123b ab'))
# ['a123b']
print(re.findall('company|companies','Too many companies have gone bankrupt, and the next one is my company'))
# ['companies', 'company']                                                                                            
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
# ['companies', 'company']


print(re.findall("a\\c",'ac a1c a2c'))
# ['a\c']
print(re.findall(r"a\c",'ac a1c a2c'))
# ['a\c']


print(re.findall('d+(?:.d+)?','abc11dad33.4adaxx2111asd3.4'))
# ['11', '33.4', '2111', '3.4']

res = re.search('egonxxx','123 egon egon xxx egon')
print(res.group())
res = re.match('egon','egon egon xxx egon')
print(res)

print(re.sub('^(w+)(.*?s)(w+)(.*?s)(w+)$',r'52341','lxx is sb'))


print(re.sub('^w+','LXXXXXXXXXXXXXXXXXX','lxx is sb'))


pattern = re.compile("egon",re.M)
print(pattern.findall("egon xxx egon"))
print(pattern.search("asdfasdfsadfegonasdfon"))

---

• json&pickle模块

  什么是序列化？为什么要序列化？

  序列化就是把内存当中的数据转成一种其它格式，这种格式可以存到文件里去

  反序列化就是从文件里读出一种格式，可以把这种格式反解成内存当中的数据类型

  1、持久保存状态需知一个程序的执行就在处理一系列状态的变化，'状态'会以各种各样有结构的数据类型的形

  式被保存在内存中。内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关

  于这个程序的之前一段时间的数据（有结构）都被清空了。在断电或重启程序之前将程序当前内存中所有的数

  据都保存下来（存档），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

  2、跨平台数据交互序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，

  如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平

  台数据交互。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

• json

import json
# 序列化
dic = {'name':"egon","xxx":True,"yyy":None,"zzz":1.3}
dic_json = json.dumps(dic)
# print(dic_json,type(dic_json))
with open('a.json',mode='wt',encoding='utf-8') as f:
   f.write(dic_json)

json.dump(dic,open('a.json',mode='wt',encoding='utf-8'))

# 反序列化
with open('a.json',mode='rt',encoding='utf-8') as f:
   res = f.read()
   dic = json.loads(res)
   print(dic["xxx"])

dic = json.load(open('a.json',mode='rt',encoding='utf-8'))
print(dic['xxx'])


res = json.dumps((1,2,3))
print(res)

dic = json.loads("{'k':true}")
print(dic)

json.dumps({1,2,3,4,5})

json与python内置数据类型的区别

• pickle

  Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

import pickle

res = pickle.dumps({1,2,3,4,5})

pickle.dump({1,2,3,4,5},open('b.pkl',mode='wb'))

s = pickle.load(open('b.pkl',mode='rb'))
print(s,type(s))

• 猴子补丁

# 一.什么是猴子补丁?
      属性在运行时的动态替换，叫做猴子补丁（Monkey Patch）。
      
    猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下：
　　1，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音
	  和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
　　2，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about
	  (顽皮的)，所以叫做Monkey Patch。


# 二. 猴子补丁的功能(一切皆对象)
　　1.拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
# 三.monkey patch的应用场景
	如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高，
    但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能
    会想到这么做
# import ujson as json  # 但是这么做的需要每个文件都重新导入一下，维护成本依然很高
					    # 此时我们就可以用到猴子补丁了

       
import json
import ujson # pip3 install ujson

def monkey_patch_json():
    json.dump = ujson.dump
    json.dumps = ujson.dumps
    json.load = ujson.load
    json.loads = ujson.loads

monkey_patch_json()

---

• 时间模块

• time模块

• 在Python中，通常有这几种方式来表示时间：

  • 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
  • 格式化的时间字符串(Format String)
  • 结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

# 时间分为三种格式（三种格式时化间是可以互相转换的）
# 1、时间戳  
print(time.time())
# 1609942223.1627667

# 2、格式化的字符串
print(time.strftime('%Y-%m-%H'))
# 2021-01-22

# 3、结构化的时间
res = time.localtime() # 东八区，中国时间
print(res)
# time.struct_time(tm_year=2021, tm_mon=1, tm_mday=6, tm_hour=22, tm_min=12, tm_sec=33,
#                           年      月     这个月的第几天    小时        分钟        秒
# tm_wday=2, tm_yday=6, tm_isdst=0)
# 0开始排星期  一年的第几天   冬令时

res2 = time.gmtime()  # 世界标准时间
print(res2)
# time.struct_time(tm_year=2021, tm_mon=1, tm_mday=6, tm_hour=14, tm_min=12, tm_sec=33, 
# tm_wday=2, tm_yday=6, tm_isdst=0)

print(res.tm_year)  # 单独获取时间的某一部分 哪一年
print(res.tm_mday)  # 单独获取时间的某一部分 哪一天


# 三种格式化之间的互相转换
print(time.localtime(33331313))  # 时间戳转结构化的时间
print(time.gmtime(33331313))     # 时间戳转成世界标准时间

print(time.mktime(time.localtime())) # 结构化的时间转时间戳

res = time.strftime("%Y-%m",time.localtime()) # 结构化时间转格式化时间
print(res)

print(time.strptime("2017-11-11 11:11:11","%Y-%m-%d %H:%M:%S")) # 格式化时间转结构化时间


print(time.asctime())  # 以这种时间格式排列显示时间，常见于linux，unix操作系统
# Wed Jan  6 22:29:01 2021

• datetime模块

import datetime

print(datetime.datetime.now())  # 现在时间
# 2021-01-06 22:33:44.950552

print(datetime.datetime.now() + datetime.timedelta(days=3.5)) # 三天半后的时间
# 2021-01-10 10:33:44.950552

print(datetime.datetime.now() - datetime.timedelta(days=3.5)) # 三天半前的时间
# 2021-01-03 10:33:44.950552

# 特点：可以参与时间运算

---

• random模块

import random

print(random.choice([1,2,"axx",3.1]))  # 每次随机只取一个
print(random.sample([1,2,"axx",3.1],2)) # 每次随机取两个拼成列表，可以指定取几个

print(random.uniform(1,3)) # 大于1小于3的小数，如1.070310748976216，随机取

item=[1,3,5,7,9]
random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"
print(item)


print(ord('A'))   # 65  # ord这个功能会参照ASCII码表把大写字母转成数字
print(ord('Z'))   # 90  
print(chr(65))    # A   # chr这个功能会参照ASCII码表把数字转成大写字母



# 生成随机验证码功能，数字加大写字母
def make_code(size=4):
    res = ''
    for i in range(size):
        num = str(random.randint(0,9))
        s = chr(random.randint(65,90))
        res += random.choice([num,s])
    return res


print(make_code(6))