python 之正则表达式详解

分清字符串与字符

r与R

在Python中，前缀 r 或 R 表示原始字符串。这种原始字符串中的反斜杠字符 \ 被视为普通字符，而不是转义字符。这在处理正则表达式、文件路径等需要保留反斜杠原始含义的情况下非常有用。

原始字符串的特点：

1. 反斜杠不进行转义： 在普通字符串中，反斜杠具有特殊含义，如 \n 表示换行符、\t 表示制表符等。但在原始字符串中，反斜杠只是普通字符，如 \\ 会被视为两个反斜杠字符而不是转义字符。

2. 常用于正则表达式、文件路径： 在处理正则表达式时，原始字符串非常有用，因为正则表达式经常包含大量反斜杠。同时，处理文件路径时，原始字符串能够避免不必要的转义。

示例：

正则表达式示例：

import re

# 使用原始字符串处理正则表达式
pattern = r'\b\d{3}\b'  # 匹配一个三位数的单词
text = "The code is 123 and 4567."

matches = re.findall(pattern, text)
print(matches)

文件路径示例：

path = r'C:\Users\Username\Documents\file.txt'
with open(path, 'r') as file:
    content = file.read()
    print(content)

这些示例演示了如何使用 r 或 R 前缀创建原始字符串，以便在正则表达式或文件路径等场景中保留反斜杠的原始含义。

有没有r 带来的影响

在Python中，使用 r 前缀与不使用 r 前缀的主要区别是，r 前缀创建的是一个"原始字符串"，其中反斜杠 \ 不会被解释为转义字符。这在处理正则表达式时特别有用，因为正则表达式本身经常包含大量反斜杠。

使用 r 前缀的示例：

pattern = r'(\d{4}-\d{2}-\d{2})\s\1'

这个模式是用来匹配一个日期格式（YYYY-MM-DD），然后后面跟着相同的日期格式，两者之间有一个空格。在原始字符串中，反斜杠 \ 不会被看作是转义字符，而是作为普通字符。所以 \d 表示匹配数字字符，\s 表示匹配空白字符（空格、制表符等），\1 表示引用前面捕获的日期格式。

不使用 r 前缀的示例：

pattern = '(\d{4}-\d{2}-\d{2})\s\1'

在这种情况下，没有使用 r 前缀，因此反斜杠 \ 会被看作是转义字符。这可能导致一些意想不到的结果，因为反斜杠后面的字符可能被解释为特殊字符而非字面意义。 在正则表达式中，\d 代表数字字符，\s 代表空白字符，\1 引用前面捕获的内容。

总的来说，使用 r 前缀创建原始字符串通常更适合于编写正则表达式，因为它可以让反斜杠在字符串中保持原样，避免不必要的转义。

\b 作为单词的界限

当使用 \b 作为单词边界的元字符时，可以结合不同的模式以展示其作用。以下是不同用法的示例代码：

匹配以 “cat” 开头的单词：

import re

text = "The cat and the catfish sat on the catwalk."

pattern_starting_with_cat = r'\bcat\w*'
matches_starting_with_cat = re.findall(pattern_starting_with_cat, text)
print("匹配以 'cat' 开头的单词:", matches_starting_with_cat)

这段代码中的 r'\bcat\w*' 匹配以 “cat” 开头的单词。在给定文本中，它会返回以 “cat” 开头的所有单词，例如 “cat”, “catfish”, “catwalk”。

匹配以 “cat” 结尾的单词：

pattern_ending_with_cat = r'\b\w*cat\b'
matches_ending_with_cat = re.findall(pattern_ending_with_cat, text)
print("匹配以 'cat' 结尾的单词:", matches_ending_with_cat)

这段代码中的 r'\b\w*cat\b' 匹配以 “cat” 结尾的单词。在给定文本中，它会返回以 “cat” 结尾的所有单词，例如 “cat”, “catfish”。

匹配整个单词 “cat”:

pattern_entire_word = r'\bcat\b'
matches_entire_word = re.findall(pattern_entire_word, text)
print("匹配整个单词 'cat':", matches_entire_word)

这段代码中的 r'\bcat\b' 匹配整个单词 “cat”。在给定文本中，它会返回所有独立的 “cat” 单词。

但是它不会返回“catfood"等包含"cat"的单词

运行这些代码将展示 \b 作为单词边界的不同用法，以便更好地理解其功能。

’ .’ 匹配除’\n’外任意字符

在正则表达式中，. 是一个特殊的元字符，用于匹配除了换行符 \n 之外的任何单个字符。

用法示例：

1. 匹配任何单个字符： 正则表达式 . 可以匹配任何单个字符，比如字母、数字、标点符号等，除了换行符。

2. 结合其他模式使用： 可以将. 与其他模式结合使用，比如 a. 可以匹配以字母 “a” 开头，后面跟着任何一个字符的字符串。

3. 贪婪匹配： . 是贪婪的，它会尽可能多地匹配字符，直到无法匹配为止。

示例：

import re

text = "The cat sat on the mat."

pattern = r'c.t'  # 匹配以 "c" 开头，后面是任意字符，然后是 "t"
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上述示例中，r'c.t' 这个模式将匹配字符串中以 “c” 开头，后面跟着任意字符，然后以 “t” 结尾的部分。在给定的文本中，匹配到的是 “cat”。

. 是一个非常常用的元字符，用于捕获或匹配大多数的单个字符，但需要注意它不能匹配换行符 \n。

*匹配位于 * 之前的字符或者子模式0次或者多次

在正则表达式中，* 是一个量词，用于指示其前面的模式可以出现零次或多次。它表示匹配前面的元素零次或多次。

用法示例：

• 匹配零次或多次：

  • a* 匹配零个或多个 “a”。
  • ab* 匹配 “a” 后面跟着零个或多个 “b”。例如，“a”, “ab”, “abb”, “abbb”, 等等。

• 贪婪匹配：

  • a* 是贪婪的，它会尽可能多地匹配 “a”，直到无法匹配为止。

• 结合其他模式使用：

  • 可以将 * 与其他字符结合使用，比如 .* 可以匹配任意数量的任意字符（除了换行符）。

示例：

import re

text = "The cat sat on the mat."

pattern = r's.*t'  # 匹配以 "s" 开头，后面是零个或多个任意字符，然后以 "t" 结尾
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上述示例中，r's.*t' 这个模式将匹配字符串中以 “s” 开头，后面跟着零个或多个任意字符，最后以 “t” 结尾的部分。在给定的文本中，匹配到的是 “sat” 和 “sat on the mat”。

* 是一个灵活且常用的量词，用于指示匹配其前面的模式零次或多次，以满足灵活的匹配需求。

+ 匹配+ 之前的字符或者子模式 1次或者多次出现

在正则表达式中，+ 是一个量词，用于指示其前面的模式必须至少出现一次或多次。它表示匹配前面的元素至少一次或多次。

用法示例：

• 匹配一次或多次：

  • a+ 匹配一个或多个 “a”。
  • ab+ 匹配 “a” 后面跟着一个或多个 “b”。例如，“ab”, “abb”, “abbb”, 等等。

• 贪婪匹配：

  • a+ 是贪婪的，它会尽可能多地匹配 “a”，直到无法匹配为止。

• 结合其他模式使用：

  • 可以将 + 与其他字符结合使用，比如 .+ 可以匹配任意数量的任意字符（除了换行符）。

示例：

import re

text = "The cat sat on the mat."

pattern = r's.+t'  # 匹配以 "s" 开头，后面是一个或多个任意字符，然后以 "t" 结尾
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上述示例中，r's.+t' 这个模式将匹配字符串中以 “s” 开头，后面跟着一个或多个任意字符，最后以 “t” 结尾的部分。在给定的文本中，匹配到的是 “sat on the mat”。

+ 用于指示至少要有一个或多个其前面的元素出现，使得匹配更具体并要求至少有一次出现。
注意：+ 号会至少匹配一次，但是* 可以至少匹配0次

- 号运算符

在[ ]里面表示范围

[a-z]//表示小写字母

单单表示连接

当 - 不用作特殊含义时，它只匹配连字符本身而不具备其他特殊作用。

举例：

假设我们有一个文本字符串 “I have a 5-year-old cat”，如果我们使用模式 r'\d+-year-old'，这个模式会匹配包含连字符的短语，比如 “5-year-old”。

在这个例子中，- 只是表示连字符，它并没有特殊的匹配行为。

| 或关系

在正则表达式中，| 称为“管道符”或“竖线”，它用于表示“或”关系。在正则表达式中，| 用于匹配多个模式中的任何一个。

用法示例：

• 匹配多个模式之一：

  • cat|dog 匹配包含 “cat” 或 “dog” 中任何一个的字符串。
  • yes|no 匹配包含 “yes” 或 “no” 中任何一个的字符串。

• 用括号分组：

  • (cat|dog)food 匹配 “catfood” 或 “dogfood”。
  • yes(no|yes) 匹配 “yesno” 或 “yesyes”。

示例：

import re

text = "I have a cat and a dog."

pattern = r'cat|dog'  # 匹配包含 "cat" 或 "dog" 中任何一个的字符串
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上面的示例中，r'cat|dog' 这个模式将匹配包含 “cat” 或 “dog” 中任何一个的部分。在给定的文本中，匹配到的是 “cat” 和 “dog”。

| 是一个非常有用的元字符，允许同时匹配多个模式中的任何一个，从而提供更灵活的匹配。

^ 规定开头

在正则表达式中，^ 是一个特殊的元字符，用于匹配字符串的开头。

用法示例：

• 匹配字符串开头： ^pattern 匹配以指定模式 pattern 开头的字符串。
  • 例如，^hello 匹配以 “hello” 开头的字符串。

示例：

import re

text = "hello world"

pattern = r'^hello'  # 匹配以 "hello" 开头的字符串
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上面的示例中，r'^hello' 这个模式将匹配以 “hello” 开头的字符串。在给定的文本中，由于 “hello” 出现在开头，所以正则表达式匹配到了 “hello”。

^ 在正则表达式中具有锚定作用，它表示匹配字符串的开头位置。

$ 匹配以$ 前面的字符或者模式结束的字符串

在正则表达式中，$ 是一个特殊的元字符，用于匹配字符串的结尾。

用法示例：

• 匹配字符串结尾： pattern$ 匹配以指定模式 pattern 结尾的字符串。
  • 例如，world$ 匹配以 “world” 结尾的字符串。

示例：

import re

text = "hello world"

pattern = r'world$'  # 匹配以 "world" 结尾的字符串
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上面的示例中，r'world$' 这个模式将匹配以 “world” 结尾的字符串。在给定的文本中，由于 “world” 出现在结尾，所以正则表达式匹配到了 “world”。

$ 在正则表达式中具有锚定作用，它表示匹配字符串的结尾位置。

? 的可选择性与改变“贪心性”

在正则表达式中，? 是一个量词，用于指示其前面的模式可以出现零次或一次，表示可选匹配。

用法示例：

• 匹配零次或一次（也就是选择性）：

  • colou?r 匹配 “colour” 或 “color”。在这里，ou? 表示 u 可以出现零次或一次，使得匹配模式更加灵活。

• 非贪婪匹配：

  • a? 是非贪婪的，它只匹配零次或一次，尽可能少地匹配。

• 结合其他模式使用：

  • 可以将 ? 与其他字符结合使用，比如 a?b 可以匹配零个或一个 “a”，后面跟着 “b”。

示例：

import re

text = "The colour is red, but color is also acceptable."

pattern = r'colou?r'  # 匹配 "colour" 或 "color"
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

在上述示例中，r'colou?r' 这个模式将匹配 “colour” 或 “color”。在给定的文本中，它匹配到了 “colour” 和 “color”，因为 ou? 允许 u 出现零次或一次，使得模式可以匹配两种拼写形式。

改变贪心性

当 ? 紧跟在其他限定符（比如 *, +, {}）后面时，它改变限定符的默认贪婪性，使其变为非贪婪或最小匹配。

默认贪婪匹配和非贪婪匹配：

• 默认情况下，*, +, {} 等限定符是贪婪的：

  • 它们会尽可能多地匹配文本，直到无法匹配为止。

• 在限定符后添加 ? 将使其变为非贪婪匹配：

  • 这表示它们会尽可能少地匹配文本，只匹配所需的最小字符数。

示例：

import re

text = "This is a sample sentence for demonstrating non-greedy matching."

# 贪婪匹配
pattern_greedy = r'.+e'
matches_greedy = re.findall(pattern_greedy, text)
print("贪婪匹配:", matches_greedy)

# 非贪婪匹配
pattern_non_greedy = r'.+?e'
matches_non_greedy = re.findall(pattern_non_greedy, text)
print("非贪婪匹配:", matches_non_greedy)

在上述示例中，r'.+e' 是一个贪婪匹配，它会匹配尽可能多的字符直到找到以 “e” 结尾的内容。相反，r'.+?e' 是一个非贪婪匹配，它会尽可能少地匹配字符直到找到以 “e” 结尾的内容。在给定文本中，这两种模式的匹配结果是不同的，一个会匹配更多的内容，另一个会匹配更少的内容。

\ 为转义

在正则表达式中，反斜杠 \ 是一个特殊字符，用于表示后面紧跟着的字符具有特殊含义或具有特定功能。它会改变紧跟其后的字符的解释方式，称为转义字符。

下面是一些常见的用法和特殊含义：

1. 转义特殊字符：

• 使用 \ 可以让特殊字符失去其特殊含义。比如，. 通常匹配任意字符，但 \. 匹配实际的句点。

2. 匹配特殊字符：

• \d 匹配一个数字字符。
• \w 匹配一个字母、数字或下划线字符。
• \s 匹配任何空白字符（例如空格、制表符、换行符等）。

3. 匹配特定字符：

• \n 匹配换行符。
• \t 匹配制表符。
• \r 匹配回车符。
• \\ 匹配实际的反斜杠字符。

示例：

假设有以下文本字符串：

text = "The cat and the hat sat flat on the mat."

import re

pattern = r'\st\w+'  # 匹配以空格开始，后面是字母 "t"，然后跟着一个或多个字母、数字或下划线字符的内容
matches = re.findall(pattern, text)
print(matches)

在这个示例中，r'\st\w+' 这个模式会匹配以空格开始，后面是字母 “t”，然后跟着一个或多个字母、数字或下划线字符的内容。在给定的文本中，这个模式匹配到的内容是 " the"、 " the".

\num 匹配重复出现字符或者模式

当使用 \num 这种形式的反向引用时，num 代表着之前已经捕获的分组编号。这种引用可以用来匹配之前已经出现的相同模式。以下是两个示例：

示例1：匹配重复的连续数字

假设有字符串：

text = "1234 1234 5678"

使用正则表达式来匹配重复的连续数字：

import re

pattern = r'(\d+)\s\1'  # 匹配重复的连续数字
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

示例2：匹配重复的日期格式

假设有字符串：

text = "Today is 2023-10-10, and tomorrow is 2023-10-10 as well."

使用正则表达式来匹配重复的日期格式：

import re

pattern = r'(\d{4}-\d{2}-\d{2})\s\1'  # 匹配重复的日期格式
matches = re.findall(pattern, text)
print(matches)  # 输出匹配的内容

这两个示例都使用了 \num 的反向引用，用来匹配先前已经捕获的相同模式。

\d 匹配任何数字，相当于[0-9]

在 Python 中，\d 是一个正则表达式模式，用于匹配任何十进制数字（0 到 9）。正则表达式是一种强大的文本匹配工具，\d 是其中的一个特殊标记，表示匹配一个数字字符。

下面是一些示例，演示了如何在 Python 中使用 \d：

示例 1：使用 re 模块进行匹配

import re

# 定义一个字符串
text = "The price is $20.99."

# 使用正则表达式模式匹配数字
matches = re.findall(r'\d', text)

# 打印匹配结果
print(matches)  # 输出：['2', '0', '9', '9']

示例 2：结合其他正则表达式模式

\d 可以与其他模式结合使用，例如 \d+ 匹配一个或多个连续数字。

import re

text = "There are 12 cats, 3 dogs, and 8 birds."

# 匹配一个或多个数字
matches = re.findall(r'\d+', text)

# 打印匹配结果
print(matches)  # 输出：['12', '3', '8']

示例 3：使用正则表达式进行替换

也可以使用 \d 来替换匹配的数字。

import re

text = "My phone number is 123-456-7890."

# 用 "X" 替换数字
new_text = re.sub(r'\d', 'X', text)

# 打印替换后的文本
print(new_text)  # 输出："My phone number is XXX-XXX-XXXX."

总之，\d 是一个在正则表达式中表示匹配数字的特殊符号，在 Python 的 re 模块中可以使用它进行文本匹配、提取或替换操作。

\D匹配任何不是数字

在 Python 的正则表达式中，\D 是一个特殊的元字符，用于匹配非数字字符。与 \d 匹配数字相反，\D 匹配除了 0 到 9 的任何非数字字符。

下面是一些示例，演示了如何在 Python 中使用 \D：

示例 1：使用 re 模块进行匹配

import re

# 定义一个字符串
text = "The price is $20.99."

# 使用正则表达式模式匹配非数字字符
matches = re.findall(r'\D', text)

# 打印匹配结果
print(matches)  # 输出：['T', 'h', 'e', ' ', 'p', 'r', 'i', 'c', 'e', ' ', 'i', 's', ' ', '$', '.']

示例 2：结合其他正则表达式模式

\D 也可以与其他模式结合使用，例如 \D+ 匹配一个或多个连续的非数字字符。

import re

text = "There are 12 cats, 3 dogs, and 8 birds."

# 匹配一个或多个非数字字符
matches = re.findall(r'\D+', text)

# 打印匹配结果
print(matches)  # 输出：['There are ', ' cats, ', ' dogs, and ', ' birds.']

示例 3：使用正则表达式进行替换

同样可以使用 \D 来替换匹配的非数字字符。

import re

text = "My phone number is 123-456-7890."

# 用 "*" 替换非数字字符
new_text = re.sub(r'\D', '*', text)

# 打印替换后的文本
print(new_text)  # 输出："************1234567890"

总之，\D 是一个在正则表达式中表示匹配非数字字符的特殊符号，在 Python 的 re 模块中可以使用它进行文本匹配、提取或替换操作。

\s 匹配任何空白字符

在 Python 中，\s 是一个特殊的正则表达式元字符，用于匹配空白字符。空白字符可以是空格、制表符（Tab）、换行符、回车符等在文本中不可见的空白符号。

下面是一些示例，演示了如何在 Python 中使用 \s：

示例 1：使用 re 模块进行匹配

import re

# 定义一个字符串包含空白字符
text = "Hello\tWorld\nPython Regex"

# 使用正则表达式模式匹配空白字符
matches = re.findall(r'\s', text)

# 打印匹配结果
print(matches)  # 输出：['\t', '\n', ' ']

示例 2：结合其他正则表达式模式

\s 也可以与其他模式结合使用，例如 \s+ 匹配一个或多个连续的空白字符。

import re

text = "This  is    a  test"

# 匹配一个或多个空白字符
matches = re.findall(r'\s+', text)

# 打印匹配结果
print(matches)  # 输出：['  ', ' ', '    ', '  ']

示例 3：使用正则表达式进行替换

同样可以使用 \s 来替换匹配的空白字符。

import re

text = "Python\tis\tawesome."

# 用空格替换空白字符
new_text = re.sub(r'\s', ' ', text)

# 打印替换后的文本
print(new_text)  # 输出："Python is awesome."

总之，\s 是一个在正则表达式中表示匹配空白字符的特殊符号，在 Python 的 re 模块中可以使用它进行文本匹配、提取或替换操作。

\S,与\s 含义相反

\w匹配数字，字母，下划线

在 Python 中，\w 是一个特殊的正则表达式元字符，用于匹配字母、数字或下划线字符（即单词字符）。\w 匹配单词字符，包括 A-Z、a-z、0-9 和下划线（_）。

下面是一些示例，演示了如何在 Python 中使用 \w：

示例 1：使用 re 模块进行匹配

import re

# 定义一个包含单词字符的字符串
text = "Hello, this is a sample string with 123 and _underscore."

# 使用正则表达式模式匹配单词字符
matches = re.findall(r'\w', text)

# 打印匹配结果
print(matches)  # 输出：['H', 'e', 'l', 'l', 'o', 't', 'h', 'i', 's', 'i', 's', 'a', 's', 'a', 'm', 'p', 'l', 'e', 's', 't', 'r', 'i', 'n', 'g', 'w', 'i', 't', 'h', '1', '2', '3', 'a', 'n', 'd', '_', 'u', 'n', 'd', 'e', 'r', 's', 'c', 'o', 'r', 'e']

示例 2：结合其他正则表达式模式

\w 也可以与其他模式结合使用，例如 \w+ 匹配一个或多个连续的单词字符。

import re

text = "Words, numbers like 123, and_special_characters!"

# 匹配一个或多个单词字符
matches = re.findall(r'\w+', text)

# 打印匹配结果
print(matches)  # 输出：['Words', 'numbers', 'like', '123', 'and_special_characters']

示例 3：使用正则表达式进行替换

可以使用 \w 来替换匹配的单词字符。

import re

text = "Replace these words with a single character."

# 用 "X" 替换单词字符
new_text = re.sub(r'\w', 'X', text)

# 打印替换后的文本
print(new_text)  # 输出："XXXXXXX XXXXX XXXX XXXX X XXXXX XXXXXXXXX."

总之，\w 是一个在正则表达式中表示匹配字母、数字或下划线字符的特殊符号，在 Python 的 re 模块中可以使用它进行文本匹配、提取或替换操作。

\W 与\w 含义相反

(),用于分组，提取，提取匹配

在 Python 的正则表达式中，括号 () 不是具体的匹配字符，而是一个元字符，用于多种功能，包括分组、捕获和提取匹配等。

1. 分组

括号 () 用于创建一个子表达式，使其中的模式被视为一个整体，可以对其应用量词或进行逻辑分组。这允许对一个组内的模式进行操作。例如：

import re

text = "apple pie, cherry pie, peach pie"

# 匹配 "apple", "cherry", "peach" 后面紧跟着 " pie" 的部分
matches = re.findall(r'(.*?) pie', text)

# 输出匹配结果
print(matches)  # 输出：['apple', 'cherry', 'peach']

在这个例子中，(.*?) 是一个捕获组，匹配任何字符零次或多次（非贪婪匹配），然后紧接着单词 “pie”。括号将 .*? 模式分组，使得后面的 " pie" 对整个组进行匹配。

2. 捕获

括号 () 还用于捕获匹配的内容，这样匹配的结果可以被提取出来。这种捕获可以被后续引用或者在匹配后提取出来。例如：

import re

text = "Date: 2023-11-07"

# 匹配日期格式并进行捕获
match = re.search(r'Date: (\d{4}-\d{2}-\d{2})', text)

# 输出捕获的日期
if match:
    print(match.group(1))  # 输出：'2023-11-07'

在这个例子中，(\d{4}-\d{2}-\d{2}) 是一个捕获组，用括号捕获了形如 “yyyy-mm-dd” 的日期格式。

3. 后向引用

捕获组中的内容还可以在同一个正则表达式中后向引用，用于检索匹配到的内容。这样可以在正则表达式中引用之前捕获的内容。例如：

import re

text = "apple apple"

# 查找重复的单词
matches = re.search(r'(\b\w+\b) \1', text)

# 输出匹配结果
if matches:
    print(matches.group())  # 输出："apple apple"

在这个例子中，(\b\w+\b) 捕获一个单词，并且 \1 匹配之前捕获的单词。

总的来说，括号 () 在正则表达式中用于创建子表达式、捕获匹配内容和后向引用。它们提供了强大的功能，可以更灵活地进行模式匹配和提取文本信息。

{m,n}控制次数

在正则表达式中，花括号 {} 用于指定模式的重复次数或者长度范围。这个元字符提供了灵活的量词控制，允许你指定匹配的确切次数或某个范围内的次数。

指定重复次数

花括号 {} 可以用来指定精确的重复次数。比如：

• \d{3} 匹配恰好连续出现 3 次的数字。
• \w{4} 匹配恰好包含 4 个字母、数字或下划线的单词字符。

import re

text = "12345, abc, 9876, xy"

# 匹配恰好连续出现 3 次的数字
matches = re.findall(r'\d{3}', text)

# 输出匹配结果
print(matches)  # 输出：['123', '987']

指定范围

花括号也可用于指定一个范围，表示匹配次数的最小和最大值。

• \w{2,4} 匹配包含 2 到 4 个字母、数字或下划线的单词字符。

import re

text = "apple, banana, grapes, pear, orange"

# 匹配包含 2 到 4 个字母的单词
matches = re.findall(r'\w{2,4}', text)

# 输出匹配结果
print(matches)  # 输出：['appl', 'bana', 'grap', 'pear', 'oran']

贪婪与非贪婪匹配

默认情况下，花括号是贪婪的，会匹配尽可能长的字符串。但可以使用 ? 将其变为非贪婪匹配。

• \d{2,4} 会匹配最长的连续数字（2 到 4 位数字）。
• \d{2,4}? 会匹配最短的连续数字（2 到 4 位数字）。

import re

text = "123456789"

# 贪婪匹配
matches_greedy = re.search(r'\d{2,4}', text)
if matches_greedy:
    print(matches_greedy.group())  # 输出：'1234'

# 非贪婪匹配
matches_non_greedy = re.search(r'\d{2,4}?', text)
if matches_non_greedy:
    print(matches_non_greedy.group())  # 输出：'12'

花括号 {} 在正则表达式中提供了精确控制和灵活性，允许指定重复次数或长度范围，可以根据具体需求匹配所需的模式。

[ ] 与 [ ^ ]

在正则表达式中，方括号 [] 用于创建一个字符集，它表示一个字符可以是集合中的任何一个字符。方括号提供了一种灵活的方式来匹配特定的字符。

单个字符匹配

使用方括号 [] 可以指定要匹配的单个字符。例如：

• [aeiou] 匹配任何一个元音字母（a、e、i、o、u）。
• [123] 匹配任何一个数字 1、2 或 3。

import re

text = "apple, orange, banana"

# 匹配单词中包含的元音字母
matches = re.findall(r'[aeiou]', text)

# 输出匹配结果
print(matches)  # 输出：['a', 'e', 'o', 'a', 'e', 'a', 'a']

字符范围

方括号 [] 还允许指定字符范围。使用连字符 - 可以表示一个字符范围。

• [a-z] 匹配任何小写字母。
• [A-Z] 匹配任何大写字母。
• [0-9] 匹配任何数字字符。

import re

text = "apple123, ORANGE456, Banana789"

# 匹配字符串中的小写字母、大写字母和数字字符
matches_lower = re.findall(r'[a-z]', text)
matches_upper = re.findall(r'[A-Z]', text)
matches_digits = re.findall(r'[0-9]', text)

# 输出匹配结果
print(matches_lower)  # 输出：['a', 'p', 'p', 'l', 'e']
print(matches_upper)  # 输出：['O', 'R', 'A', 'N', 'G', 'E', 'B']
print(matches_digits)  # 输出：['1', '2', '3', '4', '5', '6', '7', '8', '9']

否定字符集

在方括号内的 ^ 符号可以用来创建否定字符集，匹配不在集合中的字符。

• [^0-9] 匹配任何不是数字的字符。

import re

text = "abc123def456ghi"

# 匹配非数字字符
matches = re.findall(r'[^0-9]', text)

# 输出匹配结果
print(matches)  # 输出：['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

方括号 [] 在正则表达式中提供了一种便捷的方式来匹配指定的字符集或范围，使得对单个字符的匹配变得非常灵活。