零基础入门 Python 正则表达式：从懵懂到精通

亲爱的编程初学者们，你们是否在处理文本数据时，遇到过这样的困扰：

想要从一大段文字中找出所有的电话号码或邮箱地址？
需要检查用户输入的字符串是否符合特定的格式要求（比如密码必须包含大小写字母和数字）？
需要批量替换文本中的某些特定模式的字符串？
想要从网页源代码或日志文件中提取出结构化的信息？

如果答案是肯定的，那么恭喜你，你即将接触到一种强大而灵活的文本处理工具——正则表达式 (Regular Expression)，简称 Regex 或 Regexp。虽然初看起来它像一堆神秘的符号组合，但一旦掌握了它的基本原理和常用模式，你会发现它在字符串处理方面具有无与伦比的效率和便利性。

而 Python，作为一门以易读性和强大库支持著称的语言，为正则表达式提供了完善的支持，通过内置的 re 模块，我们可以轻松地在 Python 中使用正则表达式。

本文将带领你从零开始，一步步揭开 Python 正则表达式的神秘面纱，让你从完全不懂到能够熟练运用它来解决实际问题。

文章目录

正则表达式是什么？为什么需要它？
- 它是什么？
- 它能做什么？为什么比传统方法更强大？
Python 中的 re 模块
- 导入 re 模块
- re 模块的核心函数：match, search, findall, sub
正则表达式的基础语法
- 匹配字面字符
- 元字符 (Metacharacters) 的力量
  - . (点号)：匹配任意单个字符
  - ^ 和 $：匹配字符串的开头和结尾
  - *, +, ?：量词 (Quantifiers) – 重复匹配
  - {m, n}：精确控制重复次数
  - []：字符集 – 匹配指定范围或集合内的任意单个字符
  - -：在字符集中表示范围
  - [^]：否定字符集 – 匹配不在指定范围或集合内的任意单个字符
  - \：转义字符
  - |：选择 (Alternation) – 匹配多个模式之一
  - ()：分组 (Grouping) 与捕获
常用的特殊序列 (Common Sequences)
- \d, \D: 数字与非数字
- \w, \W: 单词字符与非单词字符
- \s, \S: 空白符与非空白符
- \b, \B: 单词边界
re 模块核心函数详解及示例
- re.match()：从字符串开头匹配
- re.search()：在整个字符串中搜索第一个匹配
- re.findall()：查找字符串中所有匹配的非重叠子串
- re.sub()：替换匹配的子串
- 编译正则表达式：re.compile()
更高级的用法（入门了解）
- 贪婪 (Greedy) 与非贪婪 (Non-Greedy) 匹配
- 原始字符串 (Raw Strings) r”
学习资源与实践建议
- 在线正则表达式测试工具
- Python 官方文档
- 多练习，从简单到复杂

1. 正则表达式是什么？为什么需要它？

它是什么？

简单来说，正则表达式是一种用于描述字符串模式的强大工具。它不是一门编程语言，而是一种独立的、用于处理文本的“迷你语言”，几乎所有的编程语言都提供了对它的支持。你可以用它来定义一个规则，然后让程序去检查某个字符串是否符合这个规则，或者找到符合这个规则的字符串片段。

它能做什么？为什么比传统方法更强大？

想象一下，你要从一篇文章中找出所有以 “http://” 开头的网址。如果没有正则表达式，你可能需要使用字符串的 startswith() 方法，配合循环和条件判断来完成，这对于更复杂的模式（比如包含 http:// 或 https://，后面跟着域名，可能还有路径和参数）会变得异常繁琐，代码量巨大且难以维护。

而使用正则表达式，你只需要写一个简洁的模式字符串（比如 http[s]?://\S+），然后调用一个函数，就能轻松搞定。正则表达式特别擅长处理以下任务：

搜索 (Search): 在大量文本中快速定位符合特定模式的字符串。
匹配 (Match): 判断整个字符串或字符串的开头是否完全符合某个模式。
提取 (Extract): 从文本中捕获符合模式的特定部分（比如电话号码中的区号和座机号）。
替换 (Replace): 将符合某个模式的字符串替换成其他字符串。
分割 (Split): 根据符合某个模式的分隔符将字符串分割成列表。

相比传统的字符串方法（如 find(), index(), split(), replace(), startswith(), endswith()），正则表达式提供了更灵活、更强大、更紧凑的方式来表达复杂的字符串模式匹配需求。

2. Python 中的 re 模块

Python 通过内置的 re 模块来支持正则表达式。在使用之前，你需要先导入它：

python import re

re 模块提供了一系列函数，用于执行正则表达式相关的操作。对于初学者，最常用的几个函数是：

re.match(pattern, string): 尝试从 string 开头匹配 pattern。
re.search(pattern, string): 在 string 任意位置搜索第一个匹配 pattern 的位置。
re.findall(pattern, string): 找到 string 中所有与 pattern 匹配的非重叠子串，返回一个列表。
re.sub(pattern, repl, string): 找到 string 中所有与 pattern 匹配的子串，用 repl 替换它们。

这些函数是使用 Python 正则表达式的入口，我们将在后面详细介绍它们的用法。

3. 正则表达式的基础语法

正则表达式的强大之处在于其丰富的元字符和语法规则。让我们从最简单的开始：

匹配字面字符

最简单的正则表达式就是普通字符串。它们只会匹配自身：

“`python
import re

text = “hello world”
pattern = “hello”

匹配 “hello”

match = re.search(pattern, text)
if match:
print(“找到匹配:”, match.group()) # 输出: 找到匹配: hello
“`

元字符 (Metacharacters) 的力量

元字符是正则表达式中具有特殊含义的字符。它们不代表字符本身，而是某种规则或模式。

. (点号)：匹配除换行符 \n 外的任意单个字符。

python text = "cat cot cut cet c@t" pattern = "c.t" matches = re.findall(pattern, text) print(matches) # 输出: ['cat', 'cot', 'cut', 'cet', 'c@t']
^ 和 $：匹配字符串的开头和结尾。
- ^pattern: 要求模式从字符串的开头匹配。
- pattern$: 要求模式匹配到字符串的结尾。
- ^pattern$: 要求整个字符串完全匹配模式。
“`python
text1 = “apple pie”
text2 = “pie apple”
text3 = “apple”

print(re.search(“^apple”, text1)) #
print(re.search(“^apple”, text2)) # None (text2不是以apple开头)
print(re.search(“apple$”, text1)) # None (text1不是以apple结尾)
print(re.search(“apple$”, text3)) #
print(re.search(“^apple$”, text3))#
`` 注意：re.match(pattern, string)函数本身就隐含了^，它总是从字符串开头尝试匹配。所以re.match(“abc”, “abcdef”)等价于re.search(“^abc”, “abcdef”)`。
*, +, ?：量词 (Quantifiers) – 控制前面的元素重复出现的次数。
- *: 匹配前面的元素零次或多次。
- +: 匹配前面的元素一次或多次。
- ?: 匹配前面的元素零次或一次。
python text = "abbbbc abc ac" print(re.findall("ab*c", text)) # 输出: ['abbbbc', 'abc', 'ac'] ('b'出现0, 1, 4次) print(re.findall("ab+c", text)) # 输出: ['abbbbc', 'abc'] ('b'出现1次或多次) print(re.findall("ab?c", text)) # 输出: ['abc', 'ac'] ('b'出现0次或1次)
{m, n}：精确控制重复次数。
- {m}: 精确匹配前面的元素 m 次。
- {m,}: 匹配前面的元素至少 m 次。
- {m,n}: 匹配前面的元素至少 m 次，至多 n 次。
python text = "a aa aaa aaaa aaaaa" print(re.findall("a{2}", text)) # 输出: ['aa', 'aa', 'aa', 'aa'] (匹配所有的"aa") print(re.findall("a{2,4}", text)) # 输出: ['aa', 'aaa', 'aaaa', 'aaaa'] (匹配"aa", "aaa", "aaaa") print(re.findall("a{3,}", text)) # 输出: ['aaa', 'aaaa', 'aaaaa'] (匹配"aaa", "aaaa", "aaaaa")
[]：字符集 – 匹配方括号内的任意单个字符。
- [abc]: 匹配 ‘a’, ‘b’, 或 ‘c’ 中的任意一个。
- [0-9]: 匹配任意一个数字 (等价于 \d)。
- [a-z]: 匹配任意一个小写字母。
- [A-Z]: 匹配任意一个大写字母。
- [a-zA-Z]: 匹配任意一个英文字母。
- [a-zA-Z0-9_]: 匹配任意一个字母、数字或下划线 (等价于 \w)。
“`python
text = “color colour”
print(re.findall(“colou?r”, text)) # 使用 ? 匹配 0 或 1 个 u: [‘color’, ‘colour’]
print(re.findall(“colo[u]r”, text))# 使用 [] 匹配一个 u: [‘colour’]
print(re.findall(“colou[r]”, text))# 使用 [] 匹配一个 r: [‘colour’]

text = “phone: 123-456-7890, zip: 98765”
print(re.findall(“[0-9]”, text)) # 输出: [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘0’, ‘9’, ‘8’, ‘7’, ‘6’, ‘5’]
print(re.findall(“[0-9]{3}”, text))# 输出: [‘123’, ‘456’, ‘789’, ‘987’, ’65’]
`` 注意：在[]内部，大部分元字符失去了特殊含义，变成了字面字符（除了–,^,]和`）。例如，[.+*?] 会匹配字面上的点、加号、星号或问号。
-：在字符集中表示范围。必须放在字符集内部，且通常放在开头或结尾以外的位置，否则会被当作字面字符。

python print(re.findall("[a-z]", "Hello World 123")) # 输出: ['e', 'l', 'l', 'o', 'o', 'r', 'l', 'd'] print(re.findall("[A-Za-z]", "Hello World 123")) # 输出: ['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd'] print(re.findall("[0-9]", "Hello World 123")) # 输出: ['1', '2', '3'] print(re.findall("[0-9a-fA-F]", "Hex: 1A2B3f")) # 输出: ['1', 'A', '2', 'B', '3', 'f'] (匹配十六进制数字)
[^]：否定字符集 – 匹配不在方括号内的任意单个字符。^ 放在 [] 的开头表示否定。

python text = "This is a test string with numbers 123!" print(re.findall("[^aeiouAEIOU ]", text)) # 输出: ['T', 'h', 's', 's', ' ', ' ', 't', 's', 't', ' ', 's', 't', 'r', 'n', 'g', ' ', 'w', 't', 'h', ' ', 'n', 'm', 'b', 'r', 's', '1', '2', '3', '!'] (匹配不是元音字母或空格的字符) print(re.findall("[^0-9]", text)) # 输出: ['T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 'w', 'i', 't', 'h', ' ', 'n', 'u', 'm', 'b', 'e', 'r', 's', ' '] (匹配所有非数字字符)
\：转义字符。用于取消元字符的特殊含义，使其匹配字面字符。例如，. 匹配任意字符，而 \. 则只匹配字面上的点。

“`python
text = “Is this 192.168.1.1 a valid IP address?”

错误尝试：使用 . 匹配 IP 地址中的点

print(re.findall(“\d+.\d+.\d+.\d+”, text)) # 可能匹配到 “192.168.1.1 “, “.168.1.1 a”, 等错误结果

正确做法：使用 . 转义点号

print(re.findall(“\d+.\d+.\d+.\d+”, text)) # 输出: [‘192.168.1.1’]
`` **重要提示：原始字符串 (Raw Strings)r”** 在 Python 中，反斜杠` 本身也是转义字符。这意味着如果你想在正则表达式中使用 \，你可能需要写成 \\ (例如，匹配字面上的反斜杠需要 \\\\)。这会使正则表达式变得非常难以阅读。为了解决这个问题，强烈建议在定义正则表达式字符串时使用原始字符串（在字符串前加上 r），例如 r"..."。在原始字符串中，反斜杠不会被 Python 解释为转义字符，而是直接传递给正则表达式引擎。

“`python

匹配一个反斜杠

print(re.search(r”\”, “abc\def”)) #

匹配一个点号

print(re.search(r”.”, “abc.def”)) #
`` 从此以后，写正则表达式时，请养成使用r””或r”` 的习惯！
|：选择 (Alternation) – 匹配符号两边的任意一个模式。

python text = "cat dog mouse" print(re.findall("cat|dog", text)) # 输出: ['cat', 'dog'] print(re.findall("cat|dog|mouse", text)) # 输出: ['cat', 'dog', 'mouse']
()：分组 (Grouping) 与捕获。
- 将多个字符视为一个整体进行量词匹配：(ab)+ 匹配 “ab”, “abab”, “ababab”…
- 用于捕获匹配的子串，以便后续处理。
“`python
text = “ababab ccc abc”
print(re.findall(“(ab)+”, text)) # 输出: [‘ab’, ‘ab’, ‘ab’] — 注意这里findall的行为，当有分组时，findall返回的是分组内匹配的内容
# 如果我们不关心分组捕获，只想要匹配整个模式，可以使用 (?:ab)+ (非捕获分组)

捕获分组的例子将在 re 模块函数详解中说明

“`

4. 常用的特殊序列 (Common Sequences)

为了方便表示一些常见的字符集，正则表达式提供了一些简写形式：

\d: 匹配任意数字 (等价于 [0-9])。
\D: 匹配任意非数字字符 (等价于 [^0-9])。
\w: 匹配任意单词字符（字母、数字、下划线）(等价于 [a-zA-Z0-9_])。
\W: 匹配任意非单词字符 (等价于 [^a-zA-Z0-9_])。
\s: 匹配任意空白符（空格、制表符 \t、换行符 \n、回车符 \r 等）。
\S: 匹配任意非空白符。
\b: 匹配单词边界。单词边界是指单词字符和非单词字符之间的位置，或者字符串的开头/结尾。
\B: 匹配非单词边界。

“`python
text = “Hello World! 123 GO.”
print(re.findall(r”\d+”, text)) # 输出: [‘123’] (匹配一个或多个数字)
print(re.findall(r”\w+”, text)) # 输出: [‘Hello’, ‘World’, ‘123’, ‘GO’] (匹配一个或多个单词字符)
print(re.findall(r”\s+”, text)) # 输出: [‘ ‘, ‘ ‘, ‘ ‘, ‘.’, ”] (匹配一个或多个空白符) — 注意最后一个匹配是GO.和字符串结尾之间的空白

text2 = “word words wordy”
print(re.findall(r”\bword\b”, text2)) # 输出: [‘word’] (只匹配独立的单词 “word”)
print(re.findall(r”word\b”, text2)) # 输出: [‘word’, ‘word’, ‘word’] (匹配以 “word” 结尾的单词)
print(re.findall(r”\bword”, text2)) # 输出: [‘word’, ‘word’] (匹配以 “word” 开头的单词)
“`

5. re 模块核心函数详解及示例

现在我们将之前学到的语法和 re 模块的函数结合起来使用。

re.match(pattern, string)

只尝试从字符串的开头匹配模式。如果匹配成功，返回一个匹配对象 (Match Object)，否则返回 None。

“`python
import re

text1 = “Hello, world!”
text2 = “world, Hello!”

pattern = r”Hello”

match1 = re.match(pattern, text1)
if match1:
print(“text1 match:”, match1.group()) # 输出: text1 match: Hello

match2 = re.match(pattern, text2)
if match2:
print(“text2 match:”, match2.group())
else:
print(“text2 does not match from the beginning”) # 输出: text2 does not match from the beginning
``match.group()` 方法返回匹配到的子串。

re.search(pattern, string)

在整个字符串中搜索第一个匹配模式的位置。如果找到，返回一个匹配对象，否则返回 None。

“`python
import re

text = “The quick brown fox jumps over the lazy dog.”
pattern = r”fox”

search_result = re.search(pattern, text)
if search_result:
print(“Found pattern:”, search_result.group()) # 输出: Found pattern: fox
print(“Start index:”, search_result.start()) # 输出: Start index: 20
print(“End index:”, search_result.end()) # 输出: End index: 23
print(“Span:”, search_result.span()) # 输出: Span: (20, 23)
else:
print(“Pattern not found.”)
`` 匹配对象提供了start(),end(),span()` 等方法获取匹配位置信息。

使用分组 (Capturing Groups) 捕获特定部分

通过在模式中使用 ()，可以创建捕获分组。match.group(n) 或 search.group(n) 可以用来获取第 n 个分组匹配的内容（group(0) 或 group() 是整个匹配的子串）。

“`python
import re

text = “My phone number is 123-456-7890.”

模式解释:

(\d{3}) : 捕获第一个分组，匹配3个数字 (区号)

– : 匹配字面上的连字符

(\d{3}) : 捕获第二个分组，匹配3个数字

– : 匹配字面上的连字符

(\d{4}) : 捕获第三个分组，匹配4个数字

pattern = r”(\d{3})-(\d{3})-(\d{4})”

search_result = re.search(pattern, text)
if search_result:
print(“Full match:”, search_result.group(0)) # 或 search_result.group()
print(“Area code:”, search_result.group(1))
print(“First part:”, search_result.group(2))
print(“Second part:”, search_result.group(3))
print(“All groups as tuple:”, search_result.groups()) # 返回所有捕获分组内容的元组
“`

re.findall(pattern, string)

找到字符串中所有与模式匹配的非重叠子串，并以列表形式返回。
* 如果模式中没有分组，返回所有完整匹配的子串。
* 如果模式中有分组，返回一个列表，列表中的每个元素是一个元组，元组包含了所有分组捕获的内容。

“`python
import re

text = “There are 12 apples, 34 bananas, and 5 fruits in total.”

没有分组，返回所有匹配的数字字符串

pattern1 = r”\d+”
numbers = re.findall(pattern1, text)
print(“Numbers:”, numbers) # 输出: Numbers: [’12’, ’34’, ‘5’]

text2 = “Name: Alice, Age: 30; Name: Bob, Age: 25.”

有分组，捕获姓名和年龄

pattern2 = r”Name: (\w+), Age: (\d+)”
info = re.findall(pattern2, text2)
print(“Info:”, info) # 输出: Info: [(‘Alice’, ’30’), (‘Bob’, ’25’)]
“`

re.sub(pattern, repl, string, count=0)

查找字符串中所有与模式匹配的子串，并用 repl 字符串替换它们。
* pattern: 要匹配的模式。
* repl: 用于替换的字符串。可以是一个普通字符串，也可以引用捕获分组（使用 \number 或 \g<number>）。
* string: 要进行替换的字符串。
* count: 可选参数，最多替换的次数。默认 0 表示替换所有匹配。

“`python
import re

text = “Hello world, hello Python, hello Regex.”

替换所有的 “hello” 为 “Hi” (不区分大小写，后面会介绍旗标)

pattern1 = r”hello”
replaced_text1 = re.sub(pattern1, “Hi”, text)
print(“Replace all:”, replaced_text1) # 输出: Replace all: Hi world, Hi Python, Hi Regex.

替换电话号码格式

text2 = “My phone is 123-456-7890.”

使用 \1, \2, \3 引用捕获分组

pattern2 = r”(\d{3})-(\d{3})-(\d{4})”
replaced_text2 = re.sub(pattern2, r”(\1) \2-\3″, text2)
print(“Reformat phone:”, replaced_text2) # 输出: Reformat phone: My phone is (123) 456-7890.
“`

编译正则表达式：re.compile(pattern, flags=0)

如果你需要在同一个程序中多次使用同一个正则表达式模式，或者想提高效率，可以使用 re.compile() 函数将模式编译成一个正则表达式对象。这个对象有与 re 模块函数同名的方法（match, search, findall, sub 等），但它们是针对这个特定模式的。

“`python
import re

编译模式

phone_pattern = re.compile(r”(\d{3})-(\d{3})-(\d{4})”)

text1 = “Call me at 123-456-7890.”
text2 = “His number is 987-654-3210.”

使用编译后的对象进行搜索

match1 = phone_pattern.search(text1)
if match1:
print(“Found phone1:”, match1.group())

使用编译后的对象进行替换

replaced_text2 = phone_pattern.sub(r”(\1) \2-\3″, text2)
print(“Reformat phone2:”, replaced_text2)

编译的优势在多次使用同一个模式时尤其明显，可以避免重复解析模式字符串。

“`

6. 更高级的用法（入门了解）

贪婪 (Greedy) 与非贪婪 (Non-Greedy) 匹配

默认情况下，量词 (*, +, ?, {m,n}) 是“贪婪”的，它们会尽可能多地匹配字符。有时这不是我们想要的行为。例如，我们想匹配 <b> 和 </b> 标签之间的内容：

“`python
import re

text = “Hello world Python“

尝试匹配 …

.*: 匹配任意字符（除换行）零次或多次，贪婪模式下会一直匹配到最后一个

pattern_greedy = r”.*”
print(“Greedy:”, re.findall(pattern_greedy, text)) # 输出: Greedy: [‘Hello world Python‘] (匹配了从第一个到最后一个之间的所有内容)
“`

为了实现“非贪婪”或“惰性”匹配，即尽可能少地匹配字符，可以在量词后面加上 ?：
* *?: 匹配前面的元素零次或多次，非贪婪。
* +?: 匹配前面的元素一次或多次，非贪婪。
* ??: 匹配前面的元素零次或一次，非贪婪。
* {m,n}?: 匹配前面的元素 m 到 n 次，非贪婪。

“`python
import re

text = “Hello world Python“

使用 *? 使匹配非贪婪

pattern_non_greedy = r”.*?”
print(“Non-Greedy:”, re.findall(pattern_non_greedy, text)) # 输出: Non-Greedy: [‘Hello‘, ‘Python‘]
“`

非贪婪匹配在解析标记语言（如 HTML, XML）时非常有用。

原始字符串 (Raw Strings) r''

我们前面已经强调过它的重要性，这里再次提醒：在 Python 中书写包含反斜杠的正则表达式时，强烈建议使用原始字符串 (r"your regex")，以避免 Python 解释器对反斜杠进行转义，从而保持正则表达式的清晰和准确。

7. 学习资源与实践建议

正则表达式的学习是一个实践出真知过程。掌握了基本语法和函数后，最重要的是多练习。

在线正则表达式测试工具: 这些工具通常提供一个界面，你可以输入待匹配的文本和正则表达式，实时查看匹配结果和解释。这对于调试和学习非常方便。推荐几个：
- Regex101 (regex101.com) – 功能强大，支持多种语言的正则表达式风格，提供详细解释。
- Pythex (pythex.org) – 专门针对 Python 的正则表达式。
Python 官方文档: re 模块的官方文档是权威的学习资料，虽然对于初学者可能有点枯燥，但在遇到问题或需要深入了解某个特性时，它是最佳参考。
多练习，从简单到复杂:
- 从匹配简单的模式开始：邮箱地址、电话号码、URL、日期格式等。
- 尝试用正则表达式解决你实际遇到的文本处理问题。
- 参考别人的正则表达式，理解它们是如何构建的。
- 遇到复杂的模式，不要一步到位，先拆解成简单的部分，逐步构建。

实践示例：匹配简单邮箱地址

“`python
import re

emails = [“[email protected]”, “[email protected]”, “invalid-email”, “another@domain.”]

简单邮箱地址模式 (不匹配所有可能的合法邮箱，但适合练习)

\w+ : 匹配用户名部分 (一个或多个单词字符)

@ : 匹配字面上的 @ 符号

\w+ : 匹配域名部分

. : 匹配字面上的点

\w+ : 匹配顶级域名部分

pattern = r”\w+@\w+.\w+”

print(“Matching simple emails:”)
for email in emails:
if re.match(pattern, email): # 使用match因为我们希望整个字符串是邮箱格式
print(f”{email}: ✅ Valid”)
else:
print(f”{email}: ❌ Invalid”)

输出:

[email protected]: ✅ Valid

[email protected]: ❌ Invalid (因为包含 . 和 +)

invalid-email: ❌ Invalid

another@domain.: ❌ Invalid (因为顶级域名后有点)

如果想匹配更广泛的邮箱格式，模式会复杂得多。这是一个好的进阶练习。

“`

总结

恭喜你！你已经学习了 Python 正则表达式的基础知识，包括：

正则表达式的概念和作用。
Python re 模块的导入和核心函数 (match, search, findall, sub)。
正则表达式的基础语法：字面字符、元字符 (., ^, $, *, +, ?, {m,n}, [], [^], \, |, ())。
常用的特殊序列 (\d, \w, \s, \b 等)。
如何使用 re 模块的函数进行匹配、搜索、提取和替换。
编译正则表达式的优势。
了解了贪婪与非贪婪匹配，以及原始字符串的重要性。

正则表达式是一个强大但需要练习才能掌握的工具。不要被最初看似复杂的模式吓倒。从简单的开始，结合在线工具多实践，你会越来越熟练。随着经验的积累，你将能够构建和理解更复杂的模式，从而高效地解决各种文本处理挑战。

现在，就开始你的正则表达式之旅吧！拿起 Python 解释器，或者打开一个在线测试工具，尝试写出你的第一个正则表达式，去匹配、搜索、提取和替换你感兴趣的字符串吧！祝你学习愉快！

零基础入门 Python 正则表达式：从懵懂到精通

1. 正则表达式是什么？为什么需要它？

2. Python 中的 re 模块

3. 正则表达式的基础语法

匹配 “hello”

错误尝试：使用 . 匹配 IP 地址中的点

print(re.findall(“\d+.\d+.\d+.\d+”, text)) # 可能匹配到 “192.168.1.1 “, “.168.1.1 a”, 等错误结果

正确做法：使用 . 转义点号

匹配一个反斜杠

匹配一个点号

捕获分组的例子将在 re 模块函数详解中说明

4. 常用的特殊序列 (Common Sequences)

5. re 模块核心函数详解及示例

模式解释:

(\d{3}) : 捕获第一个分组，匹配3个数字 (区号)

– : 匹配字面上的连字符

(\d{3}) : 捕获第二个分组，匹配3个数字

– : 匹配字面上的连字符

(\d{4}) : 捕获第三个分组，匹配4个数字

没有分组，返回所有匹配的数字字符串

有分组，捕获姓名和年龄

替换所有的 “hello” 为 “Hi” (不区分大小写，后面会介绍旗标)

替换电话号码格式

使用 \1, \2, \3 引用捕获分组

编译模式

使用编译后的对象进行搜索

使用编译后的对象进行替换

编译的优势在多次使用同一个模式时尤其明显，可以避免重复解析模式字符串。

6. 更高级的用法（入门了解）

尝试匹配 …

.*: 匹配任意字符（除换行）零次或多次，贪婪模式下会一直匹配到最后一个

使用 *? 使匹配非贪婪

7. 学习资源与实践建议

简单邮箱地址模式 (不匹配所有可能的合法邮箱，但适合练习)

\w+ : 匹配用户名部分 (一个或多个单词字符)

@ : 匹配字面上的 @ 符号

\w+ : 匹配域名部分

. : 匹配字面上的点

\w+ : 匹配顶级域名部分

输出:

[email protected]: ✅ Valid

[email protected]: ❌ Invalid (因为包含 . 和 +)

invalid-email: ❌ Invalid

another@domain.: ❌ Invalid (因为顶级域名后有点)

如果想匹配更广泛的邮箱格式，模式会复杂得多。这是一个好的进阶练习。

总结

发表评论 取消回复

发表评论取消回复