# 正则表达式-python篇
*正则表达式*
文章描述了有关 python 处理 正则表达式 相关的知识文库，敬请阅读！
## 开始
### compile()
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有，match 和 search 的区别也很大，详细信息在其它页有介绍
这里主要需要讨论的是其返回值的展现方式，即findall函数根据正则表达式的不同所返回的结果包含的不同信息！
```python
import re
data = """
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
matcher = re.compile(r"(<([a-zA-Z]+).*?>.*?</\2>)")
# 其中具有所有正则表达式中的函数，通过这些函数可以匹配到我们需要的所有结果组成的列表
res = matcher.findall(data)
# 值得注意的是，当正则表达式中使用到了括号包裹的时候，它匹配的是所有的括号
for s in res:
# 例如在这里，我们的每一个匹配结果中是这样的[<([a-zA-Z]+).*?>.*?</\2>的结果，\2 的结果]，因为这里的两个括号包裹的是他们两个
print(s)
# 当然，如果正则表达式中没有被括号包裹的正则，那么它将会返回一个由整个正则表达式匹配的字符串
matcher = re.compile(r"<table.*?>[\s\S]*?</table>")
res = matcher.findall(data)
for s in res:
print(s)
```
### Match()
简单来说，在python中match函数的作用就是匹配一个字符串的起始位置是否满足正则表达式，如果满足，返回匹配结果，不满足返回None
```python
import re
data = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"<.*?>")
# 通过match可以匹配到字符串的起始位置是否满足表达式,如果不满足表达式，这里返回None
matcher = pattern.match(data)
# 如果满足表达式，返回的是一个match对象，可以通过group方法获取到匹配到的数据
if matcher is not None:
# 开始匹配到的数据
print(matcher.group(0))
else:
print("匹配不成功！")
```
### Search()
```python
import re
data = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"(<([a-zA-Z]+).*?>.*?</\2>)")
# 通过search 可以匹配到第一个满足正则表达式的字符串结果，如果匹配到，返回对象
matcher = pattern.search(data)
# 如果满足表达式，返回的是一个match对象，可以通过group方法获取到匹配到的数据
if matcher is not None:
# 开始匹配到的数据
print(matcher.group(0))
else:
print("匹配不成功！")
Sub()
import re
data = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"(<([a-zA-Z]+).*?>.*?</\2>)")
# 通过sub 可以将一个字符串中符合正则表达式的字符串替换成，然后返回一个新字符串
string = pattern.sub("----------", data)
print(string)
```
### findAll()
查找所有满足正则表达式的匹配项，是一个列表，其中的每一个元素是列表或字符串，当正则表达式中有小括号的时候，返回的列表中的每一个元素不只是一个正则匹配，还有很多小括号的匹配，因此每一个元素是一个元组。
当正则表达式没有小括号的时候，返回的列表中的每一个元素都是字符串，因为正则表达式的匹配项是正则本身。
```python
import re
data = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"(<([a-zA-Z]+).*?>.*?</\2>)")
# 通过findall 可以将所有符合正则表达式的子字符串获取到
res = pattern.findall(data)
# 这里的正则表达式由于有括号，所以获取到的每一个元素是一个元组，元组的元素是小括号的匹配项
for ls in res:
print(ls)
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"<td.*?>.*?</td>")
# 通过findall 可以将所有符合正则表达式的子字符串获取到
res = pattern.findall(data)
# 这里的正则表达式由于没有括号，所以返回值是一个字符串，代表整个正则表达式的匹配项
for ls in res:
print(ls)
finditer()
import re
data = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<table>
<tr>
<td>张三</td>
<td>男</td>
</tr>
<tr>
<td>李四</td>
<td>男</td>
</tr>
<tr>
<td>爱嘤斯坦</td>
<td>女</td>
</tr>
<tr>
<td>汤姆瑞斗</td>
<td>男</td>
</tr>
</table>
</body>
</html>
"""
# compile 函数可以将一个正则表达式编译成为一个对象存储起来，使得我们可以复用这个正则表达式
pattern = re.compile(r"<([a-zA-Z]+).*?>(.*?)</\1>")
# 通过finditer 可以将所有符合正则表达式的子字符串的match对象获取到
res = pattern.finditer(data)
# 这里的正则表达式由于没有括号，所以返回值是一个字符串，代表整个正则表达式的匹配项
for ls in res:
print(ls.group(1) + '\t' + ls.group(2) + '\t' + ls.group(0))
```
----
相关文章
* [《正则表达式 - Java篇》](http://lsf.lingyuzhao.top/LS-WebFront?/linkController=/articleController&link=-15790370 "《正则表达式 - Java篇》")
------
***操作记录***
作者：[root](http://www.lingyuzhao.top/index.html?search=1 "root")
操作时间：2023-12-08 10:37:31 星期五
事件描述备注：保存/发布
[](如果不需要此记录可以手动删除，每次保存都会自动的追加记录)
