正则表达式.md · 江旭川/笔记

### **re模块的常用方法**

```python
# re.match() 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))  # 不在起始位置匹配

运行结果

(0, 3)
None

# re.search() 扫描整个字符串并返回第一个成功的匹配(只返回一个匹配)

print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())  # 不在起始位置匹配

运行结果

(0, 3)
(11, 14)

''' re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None;而  
re.search匹配整个字符串，直到找到一个匹配 '''

# 函数用法

re.match(pattern, string, flags=0)
re.search(pattern, string, flags=0)
'''
pattern 表示匹配的正则表达式
string 表示要匹配的字符串
flags 表示标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表		达式修饰符 - 可选标志

所有的flags如下：

re.I 使匹配对大小写不敏感
re.L 做本地化识别（locale-aware）匹配
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

'''
```

```python
# Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
#函数语法
re.sub(pattern, repl, string, count=0, flags=0)
'''
参数：

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配
'''

phone = "2004-959-559 # 这是一个国外电话号码"

# 删除字符串中的 Python注释
print(re.sub(r'#.*','',phone))

# 删除非数字(-)的字符串
print(re.sub(r'\D','', phone))

运行结果

2004-959-559 
2004959559

```

```python
# re.compile()函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

'''简单来说就是产生一个正则的对象，里面的属性是正则匹配的规则，可以通过这个对象调用match（）和search（）这两个方法，这两个方法里面的属性是要进行正则的内容'''

'''

group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
span([group]) 方法返回 (start(group), end(group))

'''

content = 'abc1234567890def'

pattern = re.compile(r'\d+')  # 用于匹配至少一个数字
print(pattern.search(content).group())

m = pattern.match('one12twothree34four', 2, 10)  # 从'e'的位置(2,10)开始匹配，没有匹配
print(m)

m2 = pattern.match('one12twothree34four', 3, 10)  # 从'1'的位置(3,10)开始匹配，正好匹配
print(m2.start())

运行结果

1234567890
None
3

```

```python
'''findall()在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。

'''

obj = re.compile(r'\d+') #匹配至少一个数字
content = '123456abc7890'
result = obj.findall(content)
content2 = 'abcasdkjkals789'
result2 = obj.findall(content2)
print(result)
print(result2)

运行结果
['123456', '7890']
['789']
```

```python
# re.finditer（），和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
'''
用法：
re.finditer(pattern, string, flags=0)
如果要打印的话，要写一个循环，把迭代器里的元素迭代出来
'''
it = re.finditer(r"\d+","12a32bc43jf3")  # 匹配至少一个数字
for item in it:
    print(item.group())
    
结果：
12
32
43
3

```

```python
# re.split（）方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下

'''
re.split(pattern, string[, maxsplit=0, flags=0])
pattern 匹配的正则表达式
string 要匹配的字符串。
maxsplit 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
'''

result = re.split(r'\D+','123 123 456')
print(result)

结果：
['123', '123', '456']
```

### **常见的正则的特殊元字符使用方法**

```python
# https://regex101.com/ 验证正则的网站
# 正则的特殊元字符 . * + ? \ [ ] ^ $ { } | ( )

# . 表示要匹配除了换行符之外的任何单个字符
content = '''苹果是绿色的
橙子是橙色的
香蕉是黄色的
乌鸦是黑色的'''

a = re.compile(r'.色')
result = a.findall(content)

for item in result:            
    print(item)          # 把列表里的元素遍历出来
    
结果

绿色
橙色
黄色
黑色

# * 表示匹配前面的子表达式任意次，包括0次
content = '''
绿色的
绿色色色色色色的
绿
'''
a = re.compile(r'绿色*')
result = a.findall(content)
for item in result:
    print(item)
    
结果

绿色
绿色色色色色色
绿

# .*代表匹配所有字符

# + 表示匹配前面的子表达式一次或多次，不包括0次,它与*号不同的是*号是可以包括0次的。

content = '''
绿色的
绿色色色色色色的
绿
'''

a = re.compile(r'绿色+')
result = a.findall(content)
for item in result:
    print(item)
    
结果

绿色
绿色色色色色色

# ? 表示匹配前面的子表达式0次或1次

content = '''
绿色的
绿色色色色色色的
绿
'''
a = re.compile(r'绿色?')
result = a.findall(content)
for item in result:
    print(item)
    
结果

绿色
绿色
绿

# {}表示 前面的字符匹配 指定的次数

content = '''
绿色的
绿色色色色色色的
绿色色色色
绿色色色
'''
a = re.compile(r'绿色{3,}')
result = a.findall(content)
for item in result:
    print(item)

结果

绿色色色色色色
绿色色色色
绿色色色

# 贪婪模式
我们要把下面的字符串中的所有html标签都提取出来
source = '<html><head><title>Title</title>'
预期的结果是
<html>
<head>
<title>
</title>
正则表达式是
a = re.compile(r'<.*>')

写出以下代码
content = '<html><head><title>Title</title>'

a = re.compile(r'<.*>')

print(a.findall(content))
用上面的正则表达式匹配得到的结果是

['<html><head><title>Title</title>']

这是因为在正则表达式中， ‘*’, ‘+’, ‘?’ 都是贪婪地，使用他们时，会尽可能多的匹配内容，
所以， <.*> 中的 星号（表示任意次数的重复），一直匹配到了 字符串最后的 </title> 里面的e。

# 非贪婪模式
为了不贪婪匹配得到我们想要的结果，我们可以采用非贪婪模式，就是在.*后面加上？，即<.*?>

写出以下代码

content = '<html><head><title>Title</title>'
a = re.compile(r'<.*?>')
result = a.findall(content)

for item in result:
    print(item)
    
结果

# 反斜杠后面接一些字符，表示匹配 某种类型 的一个字符。

** ^在[]里面代表非，比如[^\d]代表非数字 **

\d 匹配0-9之间任意一个数字字符，等价于表达式 [0-9]

\D 匹配任意一个不是0-9之间的数字字符，等价于表达式 [^0-9]

\s 匹配任意一个空白字符，包括 空格、tab、换行符等，等价于表达式 [\t\n\r\f\v]

\S 匹配任意一个非空白字符，等价于表达式 [^ \t\n\r\f\v]

\w 匹配任意一个文字字符，包括大小写字母、数字、下划线，等价于表达式 [a-zA-Z0-9_]

缺省情况也包括 Unicode文字字符，如果指定 ASCII 码标记，则只包括ASCII字母

\W 匹配任意一个非文字字符，等价于表达式 [^a-zA-Z0-9_]

# []表示要匹配 指定的几个字符之一 。

比如pytho[n3]表示可以匹配到python或者pytho3

content = '''
adj 11111111111
abc 123abc11113
cde 18932213131
kbc kn123123131
'''

a = re.compile(r'1[\d]{10}')  # 指定匹配的规则是匹配电话号码
result = a.findall(content)

print('content中符合电话号码的规则的是')
for item in result:
    print(item)

结果

content中符合电话号码的规则的是
11111111111
18932213131

# 起始、结尾位置 和 单行、多行模式

^ 表示匹配文本的 开头 位置。

正则表达式可以设定 单行模式 和 多行模式

如果是 单行模式 ，表示匹配 整个文本 的开头位置。
content = '''010-苹果
020-香蕉
030-西瓜
040-哈密瓜
'''
a = re.compile(r'^\d+')
result = a.findall(content)
for item in result:
    print(item)

结果

010

如果是 多行模式 ，表示匹配 文本每行 的开头位置。
content = '''010-苹果
020-香蕉
030-西瓜
040-哈密瓜
'''
a = re.compile(r'^\d+',re.M)
result = a.findall(content)
for item in result:
    print(item)

结果

010
020
030
040

$ 表示匹配文本的 结尾 位置。

如果是 单行模式 ，表示匹配 整个文本 的结尾位置。
content = '''010-苹果 6元
020-香蕉 7元
030-西瓜 8元
040-哈密瓜 9元
'''

a = re.compile(r'\d元$')
result = a.findall(content)
for item in result:
    print(item)
    
结果

9元

如果是 多行模式 ，表示匹配 文本每行 的结尾位置。
content = '''010-苹果 6元
020-香蕉 7元
030-西瓜 8元
040-哈密瓜 9元
'''

a = re.compile(r'\d元$',re.M)
result = a.findall(content)
for item in result:
    print(item)

结果

6元
7元
8元
9元

# 竖线表示 匹配 其中之一 。
''' 
特别要注意的是， 竖线在正则表达式的优先级是最低的， 这就意味着，竖线隔开的部分是一个整体
比如 绿色|橙 表示 要匹配是 绿色 或者 橙 ，
而不是 绿色 或者 绿橙
'''
content = '''
红色橙色
绿色橙色
'''
a = re.compile(r'红|橙色')
result = a.findall(content)
for item in result:
    print(item)
    
结果

红
橙色
橙色

# （）称之为 正则表达式的 组选择,作用是用来提取文本中你想提取的东西

content = '''
草莓，草莓是红色的
香蕉，香蕉是黄色的
西瓜，西瓜是绿色的
'''

a = re.compile(r'(.*)，(.*)是')  # 匹配逗号左右两边水果的名字
result = a.findall(content)

for item in result:
    print(item)
    
结果

('草莓', '草莓')
('香蕉', '香蕉')
('西瓜', '西瓜')

当有多个分组的时候，我们可以使用 (?P<分组名>...) 这样的格式，给每个分组命名。

content = '''张三，手机号码15945678901
李四，手机号码13945677701
王二，手机号码13845666901'''

a = re.compile(r'(?P<name>.*)，.*码(?P<phone>\d+)')
result = a.finditer(content)  # 使用迭代器进行匹配

for item in result:
    print(item.group('name'))
    print(item.group('phone'))
    
结果

张三
15945678901
李四
13945677701
王二
13845666901

# 如果需要 点也匹配换行符 ，可以使用 DOTALL 参数

content = '''
<div class="el">
        <p class="t1">           
            <span>
                <a>Python开发工程师</a>
            </span>
        </p>
        <span class="t2">南京</span>
        <span class="t3">1.5-2万/月</span>
</div>
<div class="el">
        <p class="t1">
            <span>
                <a>java开发工程师</a>
            </span>
		</p>
        <span class="t2">苏州</span>
        <span class="t3">1.5-2/月</span>
</div>
'''

a = re.compile(r'<div class="el">.*?<a>(.*?)</a>',re.DOTALL)
result = a.findall(content)

for item in result:
    print(item)

结果

Python开发工程师
java开发工程师

# 字符串对象的split方法只适用于 简单的字符串分割。有时需要更加灵活的字符串切割。比如，我们需要从下面字符串中提取武将的名字。

names = '关羽; 张飞, 赵云,马超, 黄忠  李逵'
result = re.split(r'[,;\s]\s*',names) # 匹配逗号和分号的其中一种紧接着零个或者多个任意\s
for item in result:
    print(item)
    
结果

关羽
张飞
赵云
马超
黄忠
李逵

```

江旭川/笔记

简介

发行版

贡献者

近期动态

江旭川/笔记 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

江旭川/笔记