Python 正则表达式RE知识学习

正则表达式（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 外的任意字符

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

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