标签：中间   程序   eee   shuffle   mamicode   模块   amp   load   %x   

一、re模块

1、正则的概念：

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

2、常用匹配模式(元字符)

import re
\w与\W
print(re.findall("\w","hello_123 * -+")) # 小\w匹配字母数字下划线
print(re.findall("\W","hello_123 * -+")) # 大\W匹配非字母数字下划线
print(re.findall("a\wb","a1b a_b a+b a-b aab aaaaaab"))  
\s与\S
print(re.findall("\s","a b  \n\tc123"))   # 小\s取空格符
print(re.findall("\S","a_b+ * b  \n\tc123"))  # 大\S取非空格符
\d与\D
print(re.findall("\d","a b  \n\tc123"))    # 只匹配数字
print(re.findall("\D","a b  \n\tc123"))    # 取非数字
^与$
print(re.findall("^a\wb","a1b a_b a+b a-b aab aaaaaab")) # ^匹配第一个
print(re.findall("a\wb$","a1b a_b a+b a-b aab aaaaaab")) #  $匹配最后一个
print(re.findall(‘^egon$‘,"egon"))    # 第一个和最后一个
\A与\Z
print(re.findall(‘\Ahe‘,‘hello egon 123‘))   # \A==>^匹配第一个
print(re.findall(‘123\Z‘,‘hello egon 123‘))   #\Z==>$ 匹配最后一个
^== 指定匹配必须出现在字符串的开头或行的开头。
\A ==指定匹配必须出现在字符串的开头（忽略 Multiline 选项）。
$ ==指定匹配必须出现在以下位置：字符串结尾、字符串结尾的 \n 之前或行的结尾。
\Z ==指定匹配必须出现在字符串的结尾或字符串结尾的 \n 之前（忽略 Multiline 选项）。
print(re.findall(‘^egon$‘,"""
egon
123egon
egon123
egon
""",re.M))   # 取^$,re.M是可以换行取值
print(re.findall(‘\Aegon\Z‘,"""
egon
123egon
egon123
egon
""",re.M))      # 用\A\Z不能换行匹配
\n与\t
print(re.findall(r‘\n‘,‘hello e\ngon \n123‘)) #  取[‘\n‘]
print(re.findall(r‘\t‘,‘hello eg\non\t123‘)) #   取[‘\t‘]
其他
print(re.findall(‘a.c‘,"a1c a2c aAc a\nc aaaac"))  #除了换行符以外的任意字符
print(re.findall(‘a.c‘,"a1c a2c aAc a\nc aaaac",re.DOTALL))  #匹配任意字符
print(re.findall(‘a[1+]c‘,"a1c a+c aAc a\nc aaaac",re.DOTALL))  #指定匹配1或+
print(re.findall(‘a[0-9]c‘,"a1c a9c a10c aAc a\nc aaaac",re.DOTALL)) #指定0-9范围
print(re.findall(‘a[a-z]c‘,"a1c a9c a10c aAc a\nc aaaac",re.DOTALL)) #指定a-z小写字母范围
print(re.findall(‘a[A-Z]c‘,"a1c a9c a10c aAc a\nc aaaac",re.DOTALL)) #指定A-Z大写字母范围
print(re.findall(‘a[-+*/]c‘,"a+c a-c a*c a/c a1c a9c aAc")) #指定+-*/，-不能放中间，-代表范围
print(re.findall(‘a[^-+*/]c‘,"a+c a-c a*c a/c a1c a9c aAc")) # 取反，除了+-*/。都可以取

?：左边那一个字符出现0次或者1次
print(re.findall(‘ab?‘,"b a abbbbbbbb ab"))
print(re.findall(‘ab{0,1}‘,"b a abbbbbbbb ab"))
*：左边那一个字符出现0次或者无穷次
print(re.findall(‘ab*‘,"b a abbbbbbbb ab"))
print(re.findall(‘ab{0,}‘,"b a abbbbbbbb ab"))
+：左边那一个字符出现1次或者无穷次
print(re.findall(‘ab+‘,"b a abbbbbbbb ab"))
print(re.findall(‘ab{1,}‘,"b a abbbbbbbb ab"))
{n,m}：左边那一个字符出现n次或m次
print(re.findall(‘ab{2,4}‘,"b a abbbbbbbb ab"))
print(re.findall(‘ab{2,4}‘,"b a abb abbb abbbbbbbb ab"))

# ===========================re模块提供的方法介绍===========================
import re
#1
print(re.findall(‘e‘,‘alex make love‘) )   #[‘e‘, ‘e‘, ‘e‘],返回所有满足匹配条件的结果,放在列表里
#2
print(re.search(‘e‘,‘alex make love‘).group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
#3
print(re.match(‘e‘,‘alex make love‘))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
#4
print(re.split(‘[ab]‘,‘abcd‘))     #[‘‘, ‘‘, ‘cd‘]，先按‘a‘分割得到‘‘和‘bcd‘,再对‘‘和‘bcd‘分别按‘b‘分割
#5
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘)) #===> Alex mAke love，不指定n，默认替换所有
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,1)) #===> Alex make love
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,2)) #===> Alex mAke love
print(‘===>‘,re.sub(‘^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$‘,r‘\5\2\3\4\1‘,‘alex make love‘)) #===> love make alex
print(‘===>‘,re.subn(‘a‘,‘A‘,‘alex make love‘)) #===> (‘Alex mAke love‘, 2),结果带有总共替换的个数
#6
obj=re.compile(‘\d{2}‘)
print(obj.search(‘abc123eeee‘).group()) #12
print(obj.findall(‘abc123eeee‘)) #[‘12‘],重用了obj

二、json&pickle模块

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

为什么要序列化？

^ 持久保存状态

^ 跨平台数据交互

json

1、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‘)) #文件序列化一行搞定  

2、json反序列化

import json
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‘])    # 文件读反序列化 一行搞定

3、dumps

res = json.dumps((1,2,3))
print(res)
#json 没有元组，会转换成列表[1,2,3]

4、loads

dic = json.loads(‘{"k":true}‘)
print(dic)
# 手写的json格式转换成字典用loads  手写时千万不能用单引号，会报错

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

集合类型不能序列化，从而引发了pickle 模式

import pickle
res = pickle.dumps({1,2,3,4,5})
print(res)  # 是二进制类型

pickle.dump({1,2,3,4,5},open(‘b.pkl‘,mode=‘wb‘)) #用b模式序列化

s = pickle.load(open(‘b.pkl‘,mode=‘rb‘)) #用b模式反序列化
print(s,type(s))

三、猴子补丁

属性在运行时的动态替换，叫做猴子补丁（Monkey Patch）

猴子补丁的核心就是用自己的代码替换所用模块的源代码

猴子补丁的功能(一切皆对象)
拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)

monkey patch的应用场景
如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高，
但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能
会想到这么做
import ujson as json，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了
只需要在入口处加上
, 只需要在入口加上:

import json
import ujson

def monkey_patch_json():
    json.__name__ = ‘ujson‘
    json.dumps = ujson.dumps
    json.loads = ujson.loads

monkey_patch_json() # 之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果

四、时间模块 time 与 datetime

时间分为三种格式：

1、时间戳

print(time.time())  #表示的是从1970年1月1日00:00:00开始按秒计算的偏移量,返回的是float类型

2、格式化的时间字符串

print(time.strftime("%Y-%m-%d %X"))  #格式化的时间字符串:‘2021-01-06 20:24:13‘

3、 结构化的时间，元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

print(time.localtime())  #本地时区的struct_time
print(time.gmtime())    #UTC时区的struct_time

datetime 模块

时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #时间替换

五、random模块

import random

print(random.random())#(0,1)----float    大于0且小于1之间的小数

print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数

print(random.choice([1,‘23‘,[4,5]]))#1或者23或者[4,5]

print(random.sample([1,‘23‘,[4,5]],2))#列表元素任意2个组合

print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716


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

生成随机验证码

import random
def make_code(n):
    res=‘‘
    for i in range(n):
        s1=chr(random.randint(65,90))
        s2=str(random.randint(0,9))
        res+=random.choice([s1,s2])
    return res

print(make_code(9))

模块：re，json，pickle，time ， datetime，random，猴子补丁

标签：中间   程序   eee   shuffle   mamicode   模块   amp   load   %x   

原文地址：https://www.cnblogs.com/caodan01/p/14243362.html