关于python:Python中正则表达式模块详解

正则表达式

用来解决字符串，对字符串进行检索和替换，另外正则在 python 爬虫的利用也是相当宽泛！

特点

• 灵活性、逻辑性和功能性十分强
• 能够迅速地用极简略的形式达到字符串的简单管制

正则语法

`# 1、数字和字母都示意它自身, . 示意匹配除了换行以外的任意字符，. 示意匹配 .
# 2、很多字母后面增加  会有非凡含意
    - n: 换行
    - t：制表符
    - d: 匹配数字，等价 [0-9]
    - D: 非数字，等价于 [^0-9]
    - w: 示意数字、字母以及下划线，中文，等价于 [0-9a-zA-Z_]
    - W：示意 w 取反
    - s: 示意任意的非打印字符 (空格、换行、制表符)
    - S: 示意非空白字符
# 3、绝大多数标点都有非凡含意
    - ()：用来示意一个分组, 如果须要示意括号，须要应用 
    - []: 匹配范畴，[0-9] 示意 0~9 范畴中的一个,[0-9a-zA-Z]
    - |: 示意或者的意思 re.search(r'f(x|y|z)m','pdsfxm')   匹配 fxm
    - {},{2,},{,3},{1,3}: 用来限定后面元素呈现的次数  re.search(r'go{2}d'，'good')
    - *: 示意后面的元素呈现的次数为 0 次及以上，等价于 {0,}
    - +: 示意后面的元素呈现的次数为 1 次及以上，等价于 {1,}
    - ^: 以指定的内容结尾，或者取反的意思
    - $: 以指定的内容结尾
# 4、? 的两种用法
    - 规定后面元素呈现的次数最多只能呈现 1 次，等价于 {,1}
    - 将贪心模式转换为非贪心模式（重点）` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22

re 模块的介绍

XM 返佣 https://www.fx61.com/brokerli…

该模块是 python 中专门用于解决正则的默认，提供了相干的办法

罕用办法

• match、search 只查问一次
• finditer 查找到所有的匹配数据放到一个可迭代对象中
• findall 把查找到的所有字符串后果放到一个列表中
• fullmatch 齐全匹配，字符串须要满足正则表达式

Match 类的应用

调用 re.match，re.search 或者对 re.finditer 的遍历返回的对象都是 re.Match 对象

Match 类的属性和办法

• pos、endpos 被查找字符串的起始和终端地位
• span() 匹配到的下标地位（元组）
• group 分组的概念

`import re

m = re.search(r'c.*z', 'abcdefgz')
print(m.pos)  # 0
print(m.endpos)  # 8
print(m.span())  # (2, 8)
# 应用 group 获取获取到匹配的字符串
print(m.group()) # cdefgz

# group 示意正则表达式的分组
# 1、在正则表达式里应用（）示意一个分组
# 2、如果没有分组，默认只有一组
# 3、分组的下标从 0 开始

# 这里有 4 个分组 
m1 = re.search(r'(1.*)(2.*)(3.*4)', 'a1bcd2efgh3ij4k')
print(m1.group())  # 默认就是第 0 组  1bcd2efgh3ij4
print(m1.group(0))  # 第 0 组就是把整个正则表达式当做一个整体  1bcd2efgh3ij4
print(m1.group(1))  # 1bcd
print(m1.group(2))  # 2efgh
print(m1.group(3))  # 3ij4

#  groups() 将分组以元组的模式返回
print(m1.groups())  # ('1bcd', '2efgh', '3ij4')

# (?P<name> 表达式) 给分组取个名字
m2 = re.search(r'(?P<one>1.*)(?P<two>2.*)(?P<three>3.*4)', 'a1bcd2efgh3ij4k')
print(m2.groupdict())  # {'one': '1bcd', 'two': '2efgh', 'three': '3ij4'}` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22
*   23
*   24
*   25
*   26
*   27
*   28

• compile

  在 re 模块，能够应用 re. 办法调用函数，还能够调用 re.compile 失去一个对象

`import re

# 这两种写法没有区别
m = re.search(r'm.*a', '111m22222a')
print(m)  # <re.Match object; span=(3, 10), match='m22222a'>

m2 = re.compile(r'm.*a')
result = m2.search('111m22222a')
print(result) # <re.Match object; span=(3, 10), match='m22222a'>` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10

正则修饰符

正则修饰符是对表达式进行润饰

• re.I 使匹配对大小写不敏感
• re.M 多行匹配，影响 ^ 和 $
• re.S 使 . 匹配包含换行在内的所有字符

`import re

# . 示意除了换行以外的任意字符
x = re.search(r'm.*a', 'abcdmonxxxa')
print(x)  # None

# re.S 匹配换行
y = re.search(r'm.*a', 'abcdmonxxxa', re.S)  # 让 . 匹配换行
print(y)

a = re.search(r'x', 'helloXyz')
print(a)  # None
# re.I 疏忽大小写
b = re.search(r'x', 'helloXyz', re.I)
print(b)  # <re.Match object; span=(5, 6), match='X'>

# re.M 让 $ 匹配到换行
m = re.findall(r'w+$', 'i am boyn you are girln he is man')
print(m)  # ['man']
n = re.findall(r'w+$', 'i am boyn you are girln he is man', re.M)
print(n) # ['boy', 'girl', 'man']` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22
*   23

正则替换

sub

`import re

# 把数字替换成 x
m = re.sub(r'd', 'x', 'hello123wor123ld')
print(m)  # helloxxxworxxxld

n = re.sub(r'd+', 'x', 'hello123wor123ld')
print(n) # helloxworxld

# 需要: 将 p 中内容的数字乘 2
p = 'hello50good34'
def test(x):
    y = int(x.group(0))
    y *= 2
    return str(y)  # 这里只能以字符串的模式返回

print(re.sub(r'd+', test, p)) # hello100good68` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19

贪心模式与非贪心模式

在正则表达式里，默认采纳的是贪心模式，尽可能匹配多的字符串

在贪心模式前面增加？，可将贪心模式转化为非贪心模式

import re

m = re.search(r'm.*a', 'abcm123a456a')
print(m)  # m123a456a, 这里为什么不是 m123a 呢？因为这里默认应用的贪心模式
n = re.search(r'm.*?a', 'abcm123a456a')
print(n)  # m123a    应用? 将贪心模式转化为非贪心模式

# ?
print(re.match(r'aa(d+)', 'aa123bb456').group(1))  # 123
print(re.match(r'aa(d+?)', 'aa123bb456').group(1))  # 1
print(re.match(r'aa(d+?)', 'aa123bb456').group(0))  # aa1

# 尽管说是尽可能少的匹配，但也要满足匹配呀
print(re.match(r'aaa(d+)ddd', 'aaa2333ddd').group(0))  # aaa2333ddd
print(re.match(r'aaa(d+?)ddd', 'aaa2333ddd').group(1))  # 2333

print(re.match(r'aaa(d+).*', 'aaa2333ddd').group(0))  # aaa2333ddd
print(re.match(r'aaa(d+?).*', 'aaa2333ddd').group(1))  # 2