Python 正则表达式RE知识学习

￡神魔★判官ぃ 2023-10-12 16:53 40阅读 0赞

正则表达式（Regular Expression）是一种强大的文本模式匹配工具，常用于在字符串中查找、替换、分割等操作。在 Python 中，可以使用内置的 `re` 模块来操作正则表达式。

# （ChatGPT编写）下面是一些需要掌握的正则表达式知识： #

1.  字符匹配：
    
     *  普通字符：正则表达式中的普通字符（如字母、数字、特殊字符）与字符串中的对应字符进行匹配。
     *  元字符：正则表达式中的特殊字符，如 `.`（匹配任意字符）、`*`（匹配前一个字符零次或多次）、`+`（匹配前一个字符一次或多次）等。
2.  字符类：
    
     *  使用方括号 `[]` 来定义一个字符类，可以指定匹配的字符范围。例如，`[abc]` 匹配字符 'a'、'b' 或 'c'。
     *  可以使用连字符 `-` 表示范围，例如 `[a-z]` 匹配任意小写字母。
     *  可以使用取反符号 `^` 来取反字符类，例如 `[^0-9]` 匹配除数字之外的任意字符。
3.  重复匹配：
    
     *  `*`：匹配前一个字符零次或多次。
     *  `+`：匹配前一个字符一次或多次。
     *  `?`：匹配前一个字符零次或一次。
     *  `{n}`：匹配前一个字符恰好 n 次。
     *  `{n, m}`：匹配前一个字符至少 n 次，最多 m 次。
4.  边界匹配：
    
     *  `^`：匹配字符串的开头。
     *  `$`：匹配字符串的结尾。
     *  `\b`：匹配单词的边界。
5.  分组与捕获：
    
     *  使用小括号 `()` 可以创建一个分组，并可以对分组进行操作，如应用重复匹配、应用修饰符等。
     *  使用 `|` 可以表示多个分组的选择。
6.  贪婪与非贪婪匹配：
    
     *  默认情况下，正则表达式是贪婪匹配，即尽可能多地匹配字符串。
     *  在重复匹配元字符后加上 `?` 可以实现非贪婪匹配，即尽可能少地匹配字符串。
7.  修饰符：
    
     *  `re.IGNORECASE` 或 `re.I`：忽略大小写匹配。
     *  `re.MULTILINE` 或 `re.M`：多行模式，使 `^` 和 `$` 匹配每行的开头和结尾。
     *  `re.DOTALL` 或 `re.S`：使 `.` 匹配包括换行符在内的任意字符。
     *  `re.VERBOSE` 或 `re.X`：允许使用正则表达式中的空格和注释。

除了以上提到的基本知识，还有更多复杂的正则表达式操作，如零宽断言、反向引用、非捕获分组等。学习正则表达式需要不断练习和实践，可以参考 Python 的官方文档和其他教程资源来深入了解和掌握正则表达式的用法。

提供几个示例来说明正则表达式的使用。

首先，我们需要导入 Python 的 `re` 模块：

`import re`

*  # 字符匹配： #

pattern = r"apple"
    text = "I have an apple and a banana."
    
    match = re.search(pattern, text)
    if match:
        print("Match found:", match.group())
    else:
        print("No match found.")
    
    # Match found: apple

在这个示例中，我们使用了 `re.search()` 函数来查找字符串中是否有匹配的模式。`r"apple"` 是我们的模式，而 `text` 是要进行匹配的字符串。`re.search()` 返回一个匹配对象，我们可以通过 `group()` 方法提取匹配的结果。

*  # 字符类： #

pattern = r"[aeiou]"
    text = "Hello, world!"
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['e', 'o', 'o']

在这个示例中，我们使用了 `re.findall()` 函数来查找字符串中所有匹配的模式。`[aeiou]` 是一个字符类，它匹配任何一个元音字母。`re.findall()` 返回一个包含所有匹配项的列表。

*  # 重复匹配： #

pattern = r"ab*c"
    strings = ["ac", "abc", "abbc", "abbbc"]
    
    for string in strings:
        if re.match(pattern, string):
            print("Match found:", string)
        else:
            print("No match found:", string)
    
    # Match found: ac
    # Match found: abc
    # Match found: abbc
    # No match found: abbbc

在这个示例中，我们使用了 `re.match()` 函数来判断字符串是否与模式匹配。`ab*c` 是我们的模式，其中 `*` 表示前一个字符 'b' 可以出现零次或多次。循环遍历 `strings` 列表中的字符串，并进行匹配判断。

*  # 边界匹配： #

pattern = r"\bcat\b"
    text = "The cat is black. A cat is not a dog. The caterpillar is green."
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['cat', 'cat']

在这个示例中，我们使用了 `\b` 来匹配单词的边界。`\bcat\b` 匹配单独的 "cat" 单词。`re.findall()` 返回一个包含所有匹配项的列表。

*  # 分组与捕获： #

pattern = r"(\d{3})-(\d{4})"
    text = "My phone number is 123-4567."
    
    match = re.search(pattern, text)
    if match:
        print("Match found:", match.group())
        print("Area code:", match.group(1))
        print("Number:", match.group(2))
    else:
        print("No match found.")
    
    # Match found: 123-4567
    # Area code: 123
    # Number: 4567

在这个示例中，我们使用了两个小括号 `()` 来创建分组，并使用 `\d` 匹配数字。`(\d{3})` 匹配一个由三个数字组成的区号，`(\d{4})` 匹配一个由四个数字组成的号码。`match.group(1)` 和 `match.group(2)` 分别提取了匹配结果中的区号和号码。

*  # 贪婪与非贪婪匹配： #

pattern = r"<.*>"
    text = "<p>This is a paragraph.</p><div>This is a div.</div>"
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['<p>This is a paragraph.</p><div>This is a div.</div>']

在这个示例中，我们使用了 `<.*>` 的模式进行匹配。`.*` 表示匹配任意字符零次或多次。由于默认是贪婪匹配，所以整个文本都被匹配为一个结果。如果我们想要非贪婪匹配，只需在 `*` 后面添加一个 `?`。

pattern = r"<.*?>"
    text = "<p>This is a paragraph.</p><div>This is a div.</div>"
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['<p>', '</p>', '<div>', '</div>']

在这个示例中，我们使用了 `<.*?>` 的模式进行非贪婪匹配。`.*?` 表示匹配任意字符零次或多次，但尽可能少地匹配。因此，我们得到了每个标签的单独匹配结果。

这些示例涵盖了更多的正则表达式知识点，包括分组、贪婪与非贪婪匹配。你可以根据需要继续学习和实践更复杂的正则表达式用法。

*  # 修饰符： #

pattern = r"hello"
    text = "Hello, world!"
    
    match = re.search(pattern, text, re.IGNORECASE)
    if match:
        print("Match found:", match.group())
    else:
        print("No match found.")
    
    # Match found: Hello

在这个示例中，我们使用了 `re.IGNORECASE` 修饰符，使匹配过程忽略大小写。因此，即使模式中是小写的 "hello"，它也能匹配到文本中的 "Hello"。

pattern = r"^hello"
    text = "Hello, world!\nHello, everyone!"
    
    matches = re.findall(pattern, text, re.MULTILINE)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['Hello']

在这个示例中，我们使用了 `re.MULTILINE` 修饰符，使 `^` 匹配每行的开头。因此，模式中的 "^hello" 只匹配第一行的 "Hello"。

这些示例展示了修饰符的使用，你可以根据需要选择合适的修饰符来实现不同的匹配需求。

除了以上的示例，正则表达式还有很多其他功能

*  # 零宽断言： #

零宽断言用于在匹配时指定位置，而不包括实际的字符。常见的零宽断言包括正向肯定断言 `(?=...)`、正向否定断言 `(?!...)`、反向肯定断言 `(?<=...)` 和反向否定断言 `(?<!...)`。

pattern = r"\b\w+(?=ing\b)"
    text = "I'm singing while walking."
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['sing']

在这个示例中，我们使用了正向肯定断言 `(?=...)`，它匹配一个以 "ing" 结尾的单词，但不包括 "ing" 部分。

pattern = r"\b(?=\w{5}\b)\w+\b"
    text = "Hello world! This is a test sentence."
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['Hello', 'world', 'This', 'sentence']

在这个示例中，我们使用了零宽正向断言 `(?=\w{5}\b)`，它匹配包含五个字母的单词的单词边界。`\w+` 匹配一个或多个字母字符，`\b` 匹配单词边界。因此，我们得到了包含五个字母的单词列表。

*  # 反向引用： #

反向引用允许在正则表达式中引用前面匹配的内容。可以使用 `\number` 来引用第 n 个分组的内容。

pattern = r"(\w+)\s+\1"
    text = "apple apple orange"
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['apple']

在这个示例中，我们使用了 `\1` 来引用第一个分组 `(\w+)` 匹配的内容。`(\w+)` 匹配一个或多个字母或数字，`\s+` 匹配一个或多个空白字符，`\1` 引用第一个分组匹配的内容。因此，我们得到了两个相邻的相同单词 "apple"。

*  # 非捕获分组： #

非捕获分组允许对分组进行逻辑分组，但不捕获匹配的内容。可以使用 `(?:...)` 来创建非捕获分组。

pattern = r"(?:Mr|Ms|Mrs)\. (\w+)"
    text = "Mr. Smith, Ms. Johnson, Mrs. Davis"
    
    matches = re.findall(pattern, text)
    if matches:
        print("Matches found:", matches)
    else:
        print("No matches found.")
    
    # Matches found: ['Smith', 'Johnson', 'Davis']

在这个示例中，我们使用了 `(?:Mr|Ms|Mrs)\.` 来创建非捕获分组。它匹配 "Mr."、"Ms." 或 "Mrs."，后面跟着一个空格和一个单词。但由于使用了非捕获分组，我们只获取了匹配的单词部分。

pattern = r"(?:https?://)?(www\.\w+\.\w+)"
    text = "Visit my website at https://www.example.com"
    
    match = re.search(pattern, text)
    if match:
        print("Match found:", match.group())
    else:
        print("No match found.")
    
    # Match found: www.example.com

在这个示例中，我们使用了非捕获分组 `(?:https?://)` 来匹配可选的 "http://" 或 "https://"。`(www\.\w+\.\w+)` 匹配以 "[www][]." 开头，后面跟着一个或多个单词字符，然后是一个点和一个或多个单词字符。我们只提取了网址部分，而不包括 "http://" 或 "https://"。

*  # 查找和替换： #

pattern = r"apple"
    text = "I have an apple and a banana."
    
    new_text = re.sub(pattern, "orange", text)
    print("Updated text:", new_text)
    
    # Updated text: I have an orange and a banana.

在这个示例中，我们使用 `re.sub()` 函数来查找并替换匹配的文本。`"apple"` 是要查找的模式，`"orange"` 是要替换成的新文本。`re.sub()` 返回替换后的新字符串。

*  # 分割字符串 #

pattern = r"\s+"
    text = "Hello   world!  How are   you?"
    
    parts = re.split(pattern, text)
    print("Parts:", parts)
    
    # Parts: ['Hello', 'world!', 'How', 'are', 'you?']

在这个示例中，我们使用 `re.split()` 函数根据指定的模式将字符串分割成多个部分。`\s+` 匹配一个或多个空白字符，因此我们将字符串按照空白字符进行分割。

\---------------

# 以下是一些常见的正则表达式普通字符的示例： #

1.  字母和数字字符：
    
     *  匹配小写字母 `[a-z]`
     *  匹配大写字母 `[A-Z]`
     *  匹配字母（大小写不区分） `[a-zA-Z]`
     *  匹配数字字符 `[0-9]`
     *  匹配字母或数字字符 `[a-zA-Z0-9]`
2.  字符类：
    
     *  匹配给定的字符集合 `[abc]`（匹配字符 'a'、'b' 或 'c'）
     *  匹配不在字符集合内的字符 `[^abc]`（匹配除了字符 'a'、'b' 和 'c' 之外的任意字符）
     *  匹配范围内的字符 `[a-z]`（匹配任意小写字母）
3.  数量限定符：
    
     *  匹配零次或一次出现的字符 `?`
     *  匹配零次或多次出现的字符 `*`
     *  匹配一次或多次出现的字符 `+`
     *  匹配指定次数出现的字符 `{n}`
     *  匹配至少n次出现的字符 `{n,}`
     *  匹配n到m次出现的字符 `{n,m}`
4.  转义字符：
    
     *  匹配特殊字符本身，而不是其元字符含义 `\.`, `\[`, `\(`, `\\` 等

这些都是普通字符的示例，它们在正则表达式中按照字面意义进行匹配。当你希望匹配这些字符时，可以直接使用它们，而不需要进行特殊处理。当然，如果某个普通字符与元字符重叠，你可能需要使用转义字符来确保它的字面意义。

### **元字符（metacharacters）在正则表达式中具有特殊的含义和功能。它们用于定义模式中的特殊字符或字符类，以实现更灵活的匹配规则。以下是一些常见的正则表达式元字符：** ###

1.  `.` （点号）：匹配任意字符，除了换行符 `\n`。
2.  `^`（脱字符）：匹配输入字符串的开头。在多行模式下，它也匹配行的开头。
3.  `$`（美元符号）：匹配输入字符串的结尾。在多行模式下，它也匹配行的结尾。
4.  `*`（星号）：匹配前面的元素零次或多次。
5.  `+`（加号）：匹配前面的元素一次或多次。
6.  `?`（问号）：匹配前面的元素零次或一次。
7.  `{}`（花括号）：指定前面的元素重复的次数。例如，`{n}` 表示前面的元素重复 n 次，`{n,}` 表示前面的元素重复至少 n 次，`{n,m}` 表示前面的元素重复 n 到 m 次。
8.  `[]`（方括号）：定义一个字符类，匹配方括号中的任意字符。例如，`[abc]` 表示匹配字符 'a'、'b' 或 'c'。
9.  `|`（竖线）：表示或的关系，用于在模式中选择多个模式中的一个。
10. `()`（圆括号）：创建一个分组，可以对分组中的内容进行重复、引用或应用其他操作。
11. `\`（反斜杠）：转义字符，用于匹配特殊字符本身，或者给特殊字符赋予字面意义。

这些元字符在正则表达式中具有特殊的含义和功能，可以用于定义更复杂的匹配规则。在使用这些元字符时，需要小心转义字符的使用，以确保元字符被解释为其特殊含义而不是字面字符。

### **在正则表达式中，字符匹配指的是匹配具体的字符或字符类。以下是一些字符匹配的示例：** ###

1.  匹配具体字符：
    
     *  匹配字符 'a'：`a`
     *  匹配字符 'X'：`X`
     *  匹配字符 '9'：`9`
2.  字符类：
    
     *  匹配任意小写字母：`[a-z]`
     *  匹配任意大写字母：`[A-Z]`
     *  匹配任意字母（大小写不区分）：`[a-zA-Z]`
     *  匹配任意数字字符：`[0-9]`
     *  匹配特定的字符集合：`[abc]`（匹配字符 'a'、'b' 或 'c'）
3.  转义字符：
    
     *  匹配特殊字符本身，而不是其元字符含义：`\.` 匹配点号，`\[` 匹配左方括号，`\\` 匹配反斜杠等
4.  元字符的字符类：
    
     *  匹配任意非空白字符：`\S`
     *  匹配任意空白字符：`\s`
     *  匹配任意数字字符：`\d`
     *  匹配任意非数字字符：`\D`
     *  匹配任意单词字符（字母、数字或下划线）：`\w`
     *  匹配任意非单词字符：`\W`
5.  点号 `.`：
    
     *  匹配除了换行符 `\n` 外的任意字符

这些示例展示了不同方式的字符匹配。你可以根据需要选择合适的字符或字符类，来匹配你想要的具体字符。

**需要注意的是，在使用某些特殊字符时，可能需要使用转义字符 `\` 进行转义，以确保其被解释为字面字符而不是元字符。**

[www]: http://www/