[一招过] Python的正则表达式篇
Python 正则表达式（re模块）
正则表达式（regular expression）是用于匹配字符串的一种强大工具。Python 提供了 re 模块来处理正则表达式。通过正则表达式，可以快速匹配、查找、替换、分割字符串等。
1. re 模块基础
首先，导入 re 模块：
import re
2. 常见正则表达式语法
正则表达式使用一组特殊的符号来描述字符串的模式。以下是一些常见的正则表达式元素：
- 元素 说明
. 匹配任何单个字符（除换行符外）
^ 匹配字符串的开始位置
$ 匹配字符串的结束位置
[] 字符集，匹配其中的任意字符，例如 [aeiou]
` `
* 匹配前一个元素零次或多次
+ 匹配前一个元素一次或多次
? 匹配前一个元素零次或一次
{n} 匹配前一个元素恰好 n 次
{n,} 匹配前一个元素至少 n 次
{n,m} 匹配前一个元素在 n 和 m 次之间
() 分组，用来分组正则表达式中的部分内容
\ 转义字符，用来转义特殊字符，如 \.
示例正则表达式
a.b：匹配一个字符串中 a 和 b 之间有任意一个字符（除了换行符）。
^abc：匹配以 abc 开头的字符串。
abc$：匹配以 abc 结尾的字符串。
[0-9]：匹配任何一个数字字符。
[a-zA-Z]：匹配任何一个字母字符（大小写字母都匹配）。
\d：匹配任何一个数字（等价于 [0-9]）。
\w：匹配任何字母、数字和下划线（等价于 [a-zA-Z0-9_]）。
\s：匹配任何空白字符，包括空格、制表符、换行符等。
3. re 模块的常用函数
3.1. re.match()
re.match() 尝试从字符串的起始位置匹配一个模式，如果匹配成功，返回一个 Match 对象，否则返回 None。
import re
pattern = r"hello"
string = "hello world"
result = re.match(pattern, string)
if result:
print("匹配成功")
else:
print("匹配失败")
3.2. re.search()
re.search() 扫描整个字符串，返回第一个匹配的结果。如果匹配成功，返回一个 Match 对象，否则返回 None。
pattern = r"world"
string = "hello world"
result = re.search(pattern, string)
if result:
print(f"匹配成功: {result.group()}")
else:
print("匹配失败")
3.3. re.findall()
re.findall() 返回所有匹配模式的非重叠字符串的列表。
pattern = r"\d+" # 匹配所有数字
string = "abc 123 def 456 ghi 789"
result = re.findall(pattern, string)
print(result) # 输出 ['123', '456', '789']
3.4. re.finditer()
re.finditer() 返回一个迭代器，包含所有匹配模式的 Match 对象。可以用来获取匹配的详细信息，比如位置、分组等。
pattern = r"\d+"
string = "abc 123 def 456 ghi 789"
matches = re.finditer(pattern, string)
for match in matches:
print(f"匹配的字符串: {match.group()}, 开始位置: {match.start()}, 结束位置: {match.end()}")
3.5. re.sub()
re.sub() 用于替换字符串中所有匹配正则表达式的部分。
pattern = r"\d+" # 匹配所有数字
string = "abc 123 def 456 ghi 789"
result = re.sub(pattern, "数字", string)
print(result) # 输出 abc 数字 def 数字 ghi 数字
3.6. re.split()
re.split() 根据正则表达式分割字符串，返回一个列表。
pattern = r"\s+" # 匹配空白字符
string = "hello world python"
result = re.split(pattern, string)
print(result) # 输出 ['hello', 'world', 'python']
- 分组和捕获
使用圆括号 () 可以对正则表达式中的一部分进行分组。捕获组可以用来提取匹配到的子字符串。
pattern = r"(\d{3})-(\d{3})-(\d{4})" # 捕获电话号码的三部分
string = "My phone number is 123-456-7890."
match = re.search(pattern, string)
if match:
print("匹配成功")
print(f"第一组: {match.group(1)}") # 输出 123
print(f"第二组: {match.group(2)}") # 输出 456
print(f"第三组: {match.group(3)}") # 输出 7890
group(0)：返回完整匹配的字符串。
group(n)：返回第 n 个分组的匹配内容。
- 正则表达式中的常用符号和函数
\d：匹配数字字符，等价于 [0-9]。
\D：匹配非数字字符，等价于 [^0-9]。
\w：匹配字母、数字或下划线字符，等价于 [a-zA-Z0-9_]。
\W：匹配非字母、数字或下划线字符，等价于 [^a-zA-Z0-9_]。
\s：匹配任何空白字符（如空格、制表符、换行符等）。
\S：匹配任何非空白字符。
*：匹配前一个字符零次或多次。
+：匹配前一个字符一次或多次。
?：匹配前一个字符零次或一次。
- 正则表达式的模式修正符（Flags）
正则表达式还支持一些模式修正符（flags），可以改变正则表达式的匹配行为：
re.IGNORECASE 或 re.I：忽略大小写。
re.MULTILINE 或 re.M：让 ^ 和 $ 匹配每一行的开始和结束。
re.DOTALL 或 re.S：让 . 匹配包括换行符在内的所有字符。
re.VERBOSE 或 re.X：允许正则表达式中使用空格和注释。
例如：
pattern = r"^abc" # 匹配字符串的开始
string = "abc Hello"
result = re.match(pattern, string, re.IGNORECASE) # 忽略大小写
print(result.group()) # 输出 'abc'
总结
re 模块 是 Python 提供的处理正则表达式的标准库，允许你执行模式匹配、查找、替换等操作。
正则表达式是一种强大的工具，能够帮助你高效地处理字符串，但也需要小心使用，因为不当的正则表达式可能会影响性能或者导致复杂的错误。
面试题
1. 写正则匹配一个ip地址 10.199.65.20
要编写正则表达式来匹配类似 10.199.65.20 这样的 IPv4 地址，可以使用以下的正则模式。
r"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
单个255 25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?
解释：
^ 和 $：分别表示字符串的开始和结束，确保匹配的是整个字符串，而不是其中的一部分。
25[0-5]：匹配 250 到 255 之间的数字。
2[0-4][0-9]：匹配 200 到 249 之间的数字。
[01]?[0-9][0-9]?：匹配 0 到 199 之间的数字。[01]? 允许 0 或 1 出现 0 或 1 次，[0-9][0-9]? 匹配 0 到 99 的数字。
\.：匹配点号（.）字符，注意点是特殊字符，需要用反斜杠转义。
{3}：表示前面括号中的内容（即三个部分的数字加点）重复 3 次。
最后一个部分没有 \.，因为它是最后一部分，不需要点。
import re
def func_valid_ip(ip):
pattern = r"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
if re.match(pattern, ip):
print("{} 是一个有效的 IP 地址".format(ip))
else:
print("{} 不是一个有效的 IP 地址".format(ip))
if __name__ == '__main__':
ips = ['10.199.65.2', '192.168.1.1 ', '256.256.256.256', '10.10.10.300']
for ip in ips:
func_valid_ip(ip)
说明：
这个正则表达式严格按照 IPv4 地址的格式进行匹配。它检查每个数字段是否在 0 到 255 之间。
10.199.65.20 将被正确匹配，并且不会误匹配类似 999.999.999.999 的无效地址。
测试用例：
10.199.65.20 → 匹配成功，是有效的 IP 地址。
192.168.1.1 → 匹配成功，是有效的 IP 地址。
256.256.256.256 → 不匹配，因为 256 超过了有效的范围。
10.10.10.300 → 不匹配，因为 300 超过了有效的范围。
这个正则表达式适用于常规的 IPv4 地址验证。如果要进行更复杂的 IP 地址验证（比如子网掩码、IP 类别等），可以考虑扩展或使用专门的库。