[re模块、json&pickle模块]

[re模块、json&pickle模块]

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("a\wb","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  \n\tc123"))
# [' ', ' ', ' ', '\n', '\t']

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

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

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

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

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

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

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

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

# \n匹配换行符 \t匹配制表符  # \n \t 都是空
print(re.findall('\n',"a\nb\nc"))
# ['\n', '\n']

print(re.findall('\t',"a\tb\nc"))
# ['\t']

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

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

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

# []用来表示一组字符串，单独列出
print(re.findall('a[1+]c',"a1c a+c aAc a\nc aaaac",re.DOTALL))
# ['a1c', 'a+c']
print(re.findall('a[0-9]c',"a1c a9c a10c aAc a\nc aaaac",re.DOTALL))# 匹配0-9的范围
# ['a1c', 'a9c']
print(re.findall('a[a-z]c',"a1c a9c a10c aAc a\nc aaaac",re.DOTALL))
# ['aac']
print(re.findall('a[A-Z]c',"a1c a9c a10c aAc a\nc 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",'a\c a1c a2c'))
# ['a\\c']
print(re.findall(r"a\\c",'a\c 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'\5\2\3\4\1','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()