Python 正则表达式是一种强大的工具，用于在文本中查找、匹配和操作符合特定模式的字符串。
导入模块
import re
匹配函数
函数语法
re.match(pattern, string, flags=0)
re.search(pattern,string, flags=0)
re.findall(pattern, string, flags=0)
re.finditer(pattern, string, flags=0)
re.match: 从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，返回none。
re.search: 扫描整个字符串并返回第一个成功的匹配。
re.findall: 返回字符串中所有与模式匹配的非重叠匹配项的列表。
re.finditer: 返回一个迭代器，包含与模式匹配的非重叠匹配项的匹配对象。
参数说明
pattern（模式）
一个字符串，表示要匹配的正则表达式模式。用于在文本中查找特定的模式。
例如，pattern可以是一个简单的字符串模式，如 'hello'，也可以是一个更复杂的正则表达式模式，如 '[0-9]+'（匹配一个或多个数字）。
pattern可以包含特殊字符和元字符，用于指定匹配规则和模式的特定部分。
string（目标字符串）
搜索匹配的目标字符串。
re.match()函数将尝试从目标字符串的起始位置开始匹配模式。
flags（标志）（可选）
可选的参数，用于控制正则表达式的匹配方式。
可以使用标志来 修改匹配的行为 ，例如忽略大小写、多行匹配等。
flags可以使用多个标志组合，以逻辑或（|）操作符分隔。
匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。
获取匹配对象：
匹配对象具有以下常用方法和属性：
group()方法：
该方法返回匹配的字符串。
如果模式中使用了分组（正则表达式中使用圆括号括起来的部分），可以通过传递分组的索引或分组的名称来获取特定分组的匹配结果，表示从1到所含的小组号。group(num=0)表示匹配的整个表达式的字符串。
start()方法：
该方法返回匹配的起始位置在目标字符串中的索引。
end()方法：
该方法返回匹配的结束位置在目标字符串中的索引。
span()方法：
该方法返回一个元组，包含匹配的起始位置和结束位置的索引。
示例
re.match
import re
pattern = r"hello"
string = "hello world"
result = re.match(pattern, string)
if result:
print("匹配成功")
else:
print("匹配失败")
匹配成功
re.search
import re
pattern = r"world"
string = "hello world"
result = re.search(pattern, string)
if result:
print("匹配成功")
else:
print("匹配失败")
匹配成功
re.findall
import re
pattern = r"\d+"
string = "I have 123 apples and 456 oranges"
result = re.findall(pattern, string)
print(result)
['123', '456']
re.finditer
import re
pattern = r"\d+"
string = "I have 123 apples and 456 oranges"
#迭代器
result = re.finditer(pattern, string)
for match in result:
print(match.group())
123
456
替换函数
函数语法
re.sub(pattern, repl, string, count=0, flags=0)
re.sub: 使用指定的替换字符串替换与模式匹配的所有子串。
参数说明
pattern: 要匹配的正则表达式模式。
repl: 替换匹配字符串的字符串或一个替换函数。
string: 要进行替换的字符串。
count (可选): 最大替换次数。默认为0，表示替换所有匹配项。
flags (可选): 匹配模式的标志。 返回替换后的字符串。
示例1
import re
pattern = r"apple"
repl = "orange"
string = "I have an apple."
result = re.sub(pattern, repl, string)
print(result)
I have an orange.
示例2
import re
def repl_func(match):
word = match.group(0) #获取匹配到的完整单词
#print(word)
return word.upper()
pattern = r"\b\w+\b"
string = "Hello, world! How are you today 123?"
result = re.sub(pattern, repl_func, string)
print(result)
HELLO, WORLD! HOW ARE YOU TODAY 123?
拆分函数
函数语法
re.split(pattern, string, maxsplit=0, flags=0)
re.split：根据给定的模式将字符串拆分为列表。
参数说明
pattern: 要匹配的正则表达式模式。
string: 要进行拆分的字符串。
maxsplit (可选): 最大拆分次数。默认为0，表示拆分所有匹配项。
flags (可选): 匹配模式的标志。 返回一个包含拆分后子字符串的列表。
示例
import re
pattern = r"[\s,;]+" # 匹配连续的空白字符(制表符，换行符)、逗号和分号
string = "Hello, World; How are you today?\n I am fine; Thank you"
result = re.split(pattern, string)
print(result)
['Hello', 'World', 'How', 'are', 'you', 'today?', 'I', 'am', 'fine', 'Thank', 'you']
编译函数
函数语法
re.compile(pattern, flags=0)
re.compile: 可以将正则表达式模式编译为模式对象，这样可以提高匹配效率并重复使用模式对象。它与直接使用匹配函数的区别在于，编译函数将正则表达式模式预先编译成一个可重复使用的对象，而不需要每次都重新解析和编译模式。
示例
import re
# 编译正则表达式模式，并使用多个标志
pattern = re.compile(r'hello', re.IGNORECASE | re.MULTILINE)
# 在文本中搜索匹配模式的所有位置
text = 'Hello World\nhello there\nHi, hello!'
matches = pattern.findall(text)
# 输出匹配结果
for match in matches:
print('匹配成功:', match)
匹配成功: Hello
匹配成功: hello
匹配成功: hello
正则表达式语法
字面字符（Literal Characters）：
字面字符直接匹配相应的字符。例如，正则表达式abc将匹配字符串中连续的字符"abc"。
元字符（Metacharacters）：
元字符具有特殊的含义，用于表示一类字符或者某种特殊的匹配方式。常见的元字符包括：
.：匹配任意单个字符，除了换行符。
^：匹配字符串的开头。
$：匹配字符串的结尾。
*：匹配前面的模式零次或多次。
+：匹配前面的模式一次或多次。
?：匹配前面的模式零次或一次。
|：指定多个模式中的一个，匹配任意一个模式。
[]：定义字符集，匹配其中的任意一个字符。
()：分组，用于控制匹配的顺序和提取匹配的子串。
\：转义字符，用于匹配特殊字符本身。
注意： 在正则表达式中，^符号有两种不同的含义，具体取决于它出现的位置：
当^位于字符类的开头，即[^...]形式，表示否定字符类，匹配除了指定字符类中的字符之外的任意一个字符。
当^位于正则表达式的开头，即^...形式，表示匹配字符串的开头位置。
字符集（Character Classes）：
字符集用于匹配一个特定位置的多个字符中的任意一个。常见的字符集语法如下：
[abc]：匹配字符"a"、"b"或"c"。
[a-z]：匹配任意小写字母。
[A-Z]：匹配任意大写字母。
[0-9]：匹配任意数字。
预定义字符集（Predefined Character Classes）：
预定义字符集是一些常用字符集的简写形式。常见的预定义字符集包括：
\d：匹配任意数字，相当于[0-9]。
\D：匹配任意非数字字符，相当于[^0-9]。
\w：匹配任意字母、数字或下划线，相当于[a-zA-Z0-9_]。
\W：匹配任意非字母、数字或下划线，相当于[^a-zA-Z0-9_]。
\s：匹配任意空白字符，包括空格、制表符、换行符等。
\S：匹配任意非空白字符。
\b：匹配单词边界，用于匹配单词字符和非单词字符之间的位置。
\B：匹配非单词边界，用于匹配不在单词字符和非单词字符之间的位置。
示例：
\b:单词边界是指一个单词字符与非单词字符之间的位置。单词字符包括字母、数字和下划线。
import re
pattern = r"\bapple\b" #r:不转义
text = "I have an apple and a pineapple."
matches = re.findall(pattern, text)
print(matches) # 输出: ['apple']
['apple']
在这个例子中，正则表达式\bapple\b匹配独立的单词"apple"，而不是包含在其他单词中的部分，如"pineapple"。
量词（Quantifiers）：
量词用于指定模式的重复次数。常见的量词包括：
{n}：匹配前面的模式恰好出现n次。
{n,}：匹配前面的模式至少出现n次。
{n,m}：匹配前面的模式出现至少n次，最多m次。
*：匹配前面的模式零次或多次，相当于{0,}。
+：匹配前面的模式一次或多次，相当于{1,}。
?：匹配前面的模式零次或一次，相当于{0,1}。
修饰符(flags)
常用的flags包括：
re.IGNORECASE（或re.I）：忽略大小写，使匹配对大小写不敏感。
re.MULTILINE（或re.M）：多行模式，使^和$匹配每行的开头和结尾，而不仅仅是整个字符串的开头和结尾。
re.DOTALL（或re.S）：点（.）匹配所有字符，包括换行符。
re.UNICODE（或re.U）：启用Unicode匹配模式，使预定义字符类（如\w，\s）能够匹配Unicode字符。
re.LOCALE（或re.L）：根据当前的本地化设置，使预定义字符类（如\w，\s）能够匹配本地化字符。
re.ASCII（或re.A）：使预定义字符类（如\w，\s）仅匹配ASCII字符。
re.VERBOSE（或re.X）：启用详细模式，可以在正则表达式中使用空白和注释，提高可读性。
条件组合
在正则表达式中，你可以使用多种方法来同时满足多个条件。下面是几种常用的方式：
字符串连接（Concatenation）
你可以按照条件的顺序将多个模式字符串连接在一起，形成一个整体的匹配模式。例如，正则表达式pattern1pattern2将要求字符串同时满足pattern1和pattern2。
示例：
字符串前用f开头表示格式化字符串（formatted string），可以在字符串中使用花括号（{}）作为占位符，并在其中指定要插入的变量或表达式。这些占位符可以包含格式说明符，用于指定变量在字符串中的显示格式。
格式化字符串只能在Python 3.6及更高版本中使用。在旧版本的Python中，可以使用str.format()方法来执行类似的字符串格式化操作。
import re
pattern1 = r"apple"
pattern2 = r"banana"
pattern3 = r"cherry"
combined_pattern = f"({pattern1}|{pattern2}|{pattern3})"
text = "I have an apple and a banana."
matches = re.findall(combined_pattern, text)
print(matches) # 输出: ['apple', 'banana']
['apple', 'banana']
字符串分组（Grouping）：
你可以使用括号将多个模式字符串分组，以创建更复杂的匹配模式。分组可以通过括号进行嵌套，形成层次结构。例如，正则表达式(pattern1)(pattern2)将要求字符串同时满足pattern1和pattern2，并将每个模式的匹配结果分别捕获。
逻辑运算符（Logical Operators）：
正则表达式提供了逻辑运算符来表示与、或、非等逻辑关系。常见的逻辑运算符包括：
|：表示或的关系。例如，正则表达式pattern1|pattern2将要求字符串满足pattern1或者pattern2。
(?=...)：表示正向预查。例如，正则表达式pattern1(?=pattern2)将要求字符串满足同时满足pattern1和pattern2，但只匹配pattern1。
(?!...)：表示负向预查。例如，正则表达式pattern1(?!pattern2)将要求字符串满足pattern1，但不能紧接着出现pattern2。
import re
pattern1 = r"(?=.*apple)"
pattern2 = r"(?=.*banana)"
pattern3 = r"(?=.*cherry)"
combined_pattern = f"an{pattern1}{pattern2}{pattern3}.*$"
text = "I have an apple, a banana, and a cherry."
match = re.search(combined_pattern, text)
if match:
print("Match found!")
print(match.group())
else:
print("No match.")
Match found!
an apple, a banana, and a cherry.
在上述示例中，定义了三个模式字符串pattern1、pattern2和pattern3，分别表示包含"apple"、"banana"和"cherry"的条件。然后，使用正向肯定预查(?=...)将这些模式字符串连接在一起，并将它们作为整体的匹配条件。