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']

4. 分组和捕获
   使用圆括号 () 可以对正则表达式中的一部分进行分组。捕获组可以用来提取匹配到的子字符串。

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 个分组的匹配内容。

5. 正则表达式中的常用符号和函数

\d：匹配数字字符，等价于 [0-9]。
\D：匹配非数字字符，等价于 [^0-9]。
\w：匹配字母、数字或下划线字符，等价于 [a-zA-Z0-9_]。
\W：匹配非字母、数字或下划线字符，等价于 [^a-zA-Z0-9_]。
\s：匹配任何空白字符（如空格、制表符、换行符等）。
\S：匹配任何非空白字符。
*：匹配前一个字符零次或多次。
+：匹配前一个字符一次或多次。
?：匹配前一个字符零次或一次。

7. 正则表达式的模式修正符（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 类别等），可以考虑扩展或使用专门的库。