python re模块与正则

1. re模块

1.1 转义符

正则表达式中的转义符在python的字符串中也刚好有转移的作用，但是正则表达式中的转义符和字符串中的转义符并没关系，且还容易有冲突。

为了避免这种冲突，我们所有的正则都以在工具中的测试结果为结果，然后只需要在正则和待匹配的字符串外面都加r即可

print('\\\\n')   # \\n
print('\\n')     # \n
print(r'\\n')    # \\n
print(r'\n')     # \n

1.2re模块的方法

1.2.1 re.findall()

findall 会匹配字符串中所有符合规则的项,并返回一个列表,如果未匹配到,则返回空列表。

import re
ret = re.findall('\d+','alex83')
print(ret)

1.2.2 re.search()

search 会从头到尾从带匹配匹配字符串中取出第一个符合条件的项，如果匹配到了，返回一个对象，用group取值；如果没匹配到，返回None，不能用group取值。

import re
ret = re.search('\d+','alex83')
print(ret)  # 如果能匹配上返回一个对象，如果不能匹配上返回None
if ret:
    print(ret.group()) # 如果是对象，那么这个对象内部实现了group，所以可以取值
                       # 如果是None，那么这个对象不可能实现了group方法，所以报错

1.2.3 re.match()

match 会从头匹配字符串中取出从第一个字符开始是否符合规则,如果符合，就返回对象，用group取值;如果不符合，就返回None.

match = search + ^正则

import re
ret = re.match('\d','alex83') == re.match('^\d','alex83')
print(ret)

1.2.4 进阶方法

• 1.时间复杂度 效率 compile

  在同一个正则表达式重复使用多次的时候使用能够减少时间的开销

• 2.空间复杂度 内存占用率 finditer

  在查询的结果超过1个的情况下，能够有效的节省内存，降低空间复杂度，从而也降低了时间复杂度

• 3.用户体验

1.2.5 re.finditer()

import re
ret = re.findall('\d','safhl02urhefy023908'*20000000)  # 时间复杂度、空间复杂度都非常高
print(ret)
ret = re.finditer('\d','safhl02urhefy023908'*20000000)  # ret是迭代器
for i in ret:    # 迭代出来的每一项都是一个对象
    print(i.group())  # 通过group取值即可

1.2.6 re.compile()

import re
ret = re.compile('\d3')  # 先配置好正则
print(ret)
r1 = ret.search('alex83')  # 可以直接调用
print(r1)
ret.findall('wusir74')
ret = re.compile('\d+')
r3 = ret.finditer('taibai40')
for i in r3:
    print(i.group())
\d 正则表达式  ——> 字符串
    \d  str
        循环str，找到所有的数字

1.2.7 re.split() 切割

import re
ret = re.split('\d+','alex83wusir74taibai')
print(ret)  # ['alex', 'wusir', 'taibai']
ret = re.split('\d(\d)','alex83wusir74taibai')  # 默认自动保留分组中的内容(被切割掉的内容)
print(ret)  # ['alex', '3', 'wusir', '4', 'taibai']

1.2.8 re.sub() / re.subn() 替换

import re
ret = re.sub('\d','D','alex83wusir74taibai',1)
print(ret)  # alexD3wusir74taibai
ret = re.sub('\d','D','alex83wusir74taibai',3)  # 3表示替换掉几个
print(ret)  # alexDDwusirD4taibai
ret = re.subn('\d','D','alex83wusir74taibai')  # subn 直接全部替换的
print(ret)  # ('alexDDwusirDDtaibai', 4)  # 得到一个元组，并把一共替换掉几个作为元组的一个元素

1.3 分组的概念和re模块

1.3.1 分组命名

s1 = '<h1>wahaha</h1>'
s2 = '<a>wahaha ya wahaha</a>'
# s1 -> h1  wahaha
# s2 -> a   wahaha ya wahaha
import re
# 方法一
ret = re.search('<(\w+)>(.*?)</\w+>',s1)
print(ret)
print(ret.group(0))   # group参数默认为0 表示取整个正则匹配的结果
print(ret.group(1))   # 取第一个分组中的内容
print(ret.group(2))   # 取第二个分组中的内容
# 方法二（分组命名）
ret = re.search('<(?P<tag>\w+)>(?P<cont>.*?)</\w+>',s1)
print(ret)
print(ret.group('tag'))   # 取tag分组中的内容
print(ret.group('cont'))   # 取cont分组中的内容

分组命名：

(?P<名字>正则表达式)

1.3.2 引用分组

引用分组 (?P=组名) 这个组中的内容必须完全和之前已经存在的组匹配到的内容一模一样

s1 = '<h1>wahaha</h1>'
s2 = '<a>wahaha ya wahaha</a>'
ret = re.search('<(?P<tag>\w+)>.*?</(?P=tag)>',s1)  # 用于约束前后<>内的内容一致
print(ret.group('tag'))  # h1
# \1:转义1，表示分组中的
s1 = '<h1>wahaha</h1>'
s2 = '<a>wahaha ya wahaha</a>'
ret = re.search(r'<(\w+)>.*?</\1>',s1)
print(ret.group(1))  # h1

findall 遇到分组

findall 遇到正则表达式中的分组，会优先显示分组中的内容

import re
ret = re.findall('\d(\d)','aa1alex83')
# findall遇到正则表达式中的分组，会优先显示分组中的内容
print(ret)
ret = re.findall('\d+(?:\.\d+)?','1.234+2')  # ?: 取消分组优先显示
print(ret)

分组和 findall

• 默认findall 优先显示分组内的内容
• 取消分组优先显示 (?:正则)

# 例题
  # 有的时候我们想匹配的内容包含在不相匹配的内容当中，这个时候只需要把不想匹配的先匹配出来，再通过手段去掉
import re
ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret)
ret.remove('')
print(ret)

split 遇到分组：会保留分组中本来应该被切割掉的内容

1.4 生成器的send方法

def func():
    print(123)
    n = yield 'aaa'
    print('-->',n)
    yield 'bbb'
g = func()
print(g)
n = next(g)
print(n)
print('-'*20)
next(g)   # g.send('uysdfhfoiusyg')与next(g)的作用一样

1.5 小总结

正则 ？都能做什么？

• 1. ？表示匹配0次或1次 表示可有可无 但是有只能有一个 比如小数点
  2. 用于非贪婪匹配：.*?x 匹配任意的内容任意多次遇到x就立即停止
  3. 分组命名： (?P<名字>正则表达式)
  4. 引用分组： (?P=组名)
  5. findall 遇到正则表达式中的分组时，?: 取消分组优先显示