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 遇到正则表达式中的分组时，?: 取消分组优先显示