Python怎么使用正则表达式匹配_Python正则表达式使用教程-Python教程-PHP中文网

<p>Python中正则表达式通过re模块实现，可用于匹配、搜索、替换和验证文本模式；常用函数包括re.match()（从开头匹配）、re.search()（全局搜索）、re.findall()（查找所有匹配）、re.sub()（替换）和re.compile()（编译模式以提升效率）；核心元字符如. ^ $ * + ? {} [] () | \ 及特殊序列如\d \w \s等用于构建复杂模式；量词默认为贪婪模式（尽可能多匹配），在量词后加?可变为非贪婪模式（尽可能少匹配），适用于提取HTML标签等内容；常见应用场景包括数据验证（邮箱、手机号、密码）、文本解析（日志分析、网页抓取）、文本清洗（去空格、脱敏）和高级搜索，是处理字符串的强大工具。</p>

python怎么使用正则表达式匹配_python正则表达式使用教程

Python里处理字符串，尤其是当你想从一大堆文本里精准地抓取、替换或者验证特定模式的时候，正则表达式（Regex）绝对是个绕不开的话题。简单来说，它就是一套描述文本模式的强大语言，通过特定的字符组合，让你能像用筛子一样，从复杂的文本数据中筛出你想要的那部分。在Python里，这一切都围绕着内置的

re

登录后复制

模块展开。

解决方案

要在Python中使用正则表达式，核心就是

re

登录后复制

模块。这个模块提供了一系列函数，用于编译正则表达式、执行匹配、搜索、替换等操作。

首先，你需要导入

re

登录后复制

模块：

import re

登录后复制

1. 匹配单个模式：

re.search()

登录后复制

和
re.match()
登录后复制

立即学习“Python免费学习笔记（深入）”；

```
re.match(pattern, string)
```
登录后复制
：尝试从字符串的开头匹配模式。如果匹配成功，返回一个匹配对象；否则，返回
```
None
```
登录后复制
。
```
re.search(pattern, string)
```
登录后复制
：扫描整个字符串，找到第一个匹配模式的位置。如果找到，返回一个匹配对象；否则，返回
```
None
```
登录后复制
。

举个例子：

text = "Hello, my phone number is 123-456-7890."
pattern_start = r"Hello"
pattern_number = r"\d{3}-\d{3}-\d{4}"

match_start = re.match(pattern_start, text)
if match_start:
    print(f"从开头匹配到: {match_start.group()}") # 输出: 从开头匹配到: Hello

match_number = re.search(pattern_number, text)
if match_number:
    print(f"找到电话号码: {match_number.group()}") # 输出: 找到电话号码: 123-456-7890

# 如果用re.match来找电话号码，会是None，因为它不在开头
no_match = re.match(pattern_number, text)
print(f"尝试从开头匹配电话号码: {no_match}") # 输出: 尝试从开头匹配电话号码: None

登录后复制

2. 查找所有匹配项：

re.findall()

登录后复制

re.findall(pattern, string)

登录后复制

：在字符串中查找所有非重叠的匹配项，并以列表形式返回所有匹配到的字符串。

text = "Email addresses: test@example.com, user@domain.org, another@mail.net."
email_pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

all_emails = re.findall(email_pattern, text)
print(f"找到的所有邮箱: {all_emails}")
# 输出: 找到的所有邮箱: ['test@example.com', 'user@domain.org', 'another@mail.net']

登录后复制

3. 替换匹配项：

re.sub()

登录后复制

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

登录后复制

：用

repl

登录后复制

替换

string

登录后复制

中所有匹配

pattern

登录后复制

的子串。

count

登录后复制

参数可选，表示最多替换的次数。

text = "The price is $100. Another item costs $25."
price_pattern = r"\$\d+"
replacement = "FREE"

new_text = re.sub(price_pattern, replacement, text)
print(f"替换后的文本: {new_text}")
# 输出: 替换后的文本: The price is FREE. Another item costs FREE.

# 限制替换次数
new_text_one_replace = re.sub(price_pattern, replacement, text, count=1)
print(f"只替换一次的文本: {new_text_one_replace}")
# 输出: 只替换一次的文本: The price is FREE. Another item costs $25.

登录后复制

4. 编译正则表达式：

re.compile()

登录后复制

当你在代码中需要多次使用同一个正则表达式模式时，编译它是一个好习惯。

re.compile()

登录后复制

函数会将正则表达式编译成一个RegexObject对象，这样可以提高效率。

phone_regex = re.compile(r"\d{3}-\d{3}-\d{4}")
text = "Call me at 123-456-7890 or 987-654-3210."

matches = phone_regex.findall(text)
print(f"编译后查找的电话号码: {matches}")
# 输出: 编译后查找的电话号码: ['123-456-7890', '987-654-3210']

登录后复制

说实话，刚接触的时候，这些符号确实让人头大，但一旦你理解了它们背后的逻辑，会发现它们在文本处理上简直是神器。

Python正则表达式中的元字符和特殊序列有哪些？

理解正则表达式的威力，很大程度上取决于你对元字符（Metacharacters）和特殊序列（Special Sequences）的掌握。这些是构建复杂匹配模式的基础。它们不是字面意义上的字符，而是具有特殊含义的“指令”。

常见的元字符：

```
.
```
登录后复制
(点号)：匹配除换行符
```
\n
```
登录后复制
之外的任何单个字符。
- ```
a.b
```
  登录后复制
  可以匹配
```
acb
```
  登录后复制
  ,
```
a!b
```
  登录后复制
  ,
```
a b
```
  登录后复制
  等。
```
^
```
登录后复制
(脱字符)：匹配字符串的开头。
- ```
^Hello
```
  登录后复制
  只会匹配以 "Hello" 开头的字符串。
```
$
```
登录后复制
(美元符号)：匹配字符串的结尾。
- ```
World$
```
  登录后复制
  只会匹配以 "World" 结尾的字符串。
```
*
```
登录后复制
(星号)：匹配前一个字符零次或多次。
- ```
ab*c
```
  登录后复制
  可以匹配
```
ac
```
  登录后复制
  ,
```
abc
```
  登录后复制
  ,
```
abbc
```
  登录后复制
  ,
```
abbbc
```
  登录后复制
  等。
```
+
```
登录后复制
(加号)：匹配前一个字符一次或多次。
- ```
ab+c
```
  登录后复制
  可以匹配
```
abc
```
  登录后复制
  ,
```
abbc
```
  登录后复制
  ,
```
abbbc
```
  登录后复制
  ，但不能匹配
```
ac
```
  登录后复制
  。
```
?
```
登录后复制
(问号)：匹配前一个字符零次或一次。
- ```
ab?c
```
  登录后复制
  可以匹配
```
ac
```
  登录后复制
  ,
```
abc
```
  登录后复制
  。
```
{m}
```
登录后复制
(大括号)：匹配前一个字符恰好m次。
- ```
a{3}b
```
  登录后复制
  匹配
```
aaab
```
  登录后复制
  。
```
{m,n}
```
登录后复制
：匹配前一个字符至少m次，至多n次。
- ```
a{2,4}b
```
  登录后复制
  匹配
```
aab
```
  登录后复制
  ,
```
aaab
```
  登录后复制
  ,
```
aaaab
```
  登录后复制
  。
```
[]
```
登录后复制
(方括号)：匹配方括号内任何一个字符。这叫字符集。
- ```
[abc]
```
  登录后复制
  匹配
```
a
```
  登录后复制
  ,
```
b
```
  登录后复制
  , 或
```
c
```
  登录后复制
  。
- ```
[a-z]
```
  登录后复制
  匹配所有小写字母。
- ```
[0-9]
```
  登录后复制
  匹配所有数字。
- ```
[^0-9]
```
  登录后复制
  匹配所有非数字字符（
```
^
```
  登录后复制
  在方括号内表示否定）。
```
|
```
登录后复制
(竖线)：逻辑或操作。
- ```
cat|dog
```
  登录后复制
  匹配
```
cat
```
  登录后复制
  或
```
dog
```
  登录后复制
  。
```
()
```
登录后复制
(圆括号)：用于分组和捕获匹配的子串。
- ```
(ab)+
```
  登录后复制
  匹配
```
ab
```
  登录后复制
  ,
```
abab
```
  登录后复制
  ,
```
ababab
```
  登录后复制
  等。
- ```
(\d{3})-(\d{4})
```
  登录后复制
  可以分别捕获区号和电话号码的后四位。
```
\
```
登录后复制
(反斜杠)：转义字符。如果想匹配元字符本身，需要用
```
\
```
登录后复制
转义。
- ```
\.
```
  登录后复制
  匹配字面意义上的点号。
- ```
\$
```
  登录后复制
  匹配字面意义上的美元符号。

特殊序列（通常以

登录后复制

开头）：

这些是预定义的字符集，非常方便：

```
\d
```
登录后复制
：匹配任何数字（等同于
```
[0-9]
```
登录后复制
）。
```
\d
```
登录后复制
：匹配任何非数字字符（等同于
```
[^0-9]
```
登录后复制
）。
```
\w
```
登录后复制
：匹配任何字母、数字或下划线（等同于
```
[a-zA-Z0-9_]
```
登录后复制
）。
```
\w
```
登录后复制
：匹配任何非字母、数字或下划线字符（等同于
```
[^a-zA-Z0-9_]
```
登录后复制
）。
```
\s
```
登录后复制
：匹配任何空白字符（包括空格、制表符
```
\t
```
登录后复制
、换行符
```
\n
```
登录后复制
、回车符
```
\r
```
登录后复制
等）。
```
\s
```
登录后复制
：匹配任何非空白字符。
```
\b
```
登录后复制
：匹配单词边界。
- ```
\bword\b
```
  登录后复制
  匹配独立的 "word"，不会匹配 "wordy" 或 "keyword"。
```
\b
```
登录后复制
：匹配非单词边界。

掌握这些元字符和特殊序列，就像掌握了正则表达式的“字母表”和“词汇”，就能开始构建复杂的“句子”来描述你想要的文本模式了。

如何处理Python正则表达式中的贪婪与非贪婪匹配？

在使用正则表达式时，你可能会遇到一个让人有点困惑但又非常重要的概念：贪婪（Greedy）与非贪婪（Non-Greedy）匹配。这决定了当一个量词（如

登录后复制

{m,n}

登录后复制

）遇到多种可能的匹配长度时，它会选择哪一种。

默认的贪婪模式

LuckyCola工具库

LuckyCola工具库是您工作学习的智能助手，提供一系列AI驱动的工具，旨在为您的生活带来便利与高效。

133

查看详情

正则表达式中的量词默认是“贪婪”的。这意味着它们会尽可能多地匹配字符，直到无法再匹配为止。

看个例子：

text = "<a>link1</a><a>link2</a>"
# 目标：提取第一个<a>...</a>标签内的内容
pattern_greedy = r"<.*>"

match = re.search(pattern_greedy, text)
if match:
    print(f"贪婪匹配结果: {match.group()}")
# 输出: 贪婪匹配结果: <a>link1</a><a>link2</a>

登录后复制

你可能期望它只匹配到

<a>link1</a>

登录后复制

，但由于

登录后复制

是贪婪的，它会一直匹配到最后一个

登录后复制

字符，把整个字符串都吞了进去。这就是贪婪的特性。

切换到非贪婪模式

要让量词变成“非贪婪”模式，你只需要在量词后面加上一个问号

登录后复制

。

```
*?
```
登录后复制
：匹配前一个字符零次或多次，但尽可能少。
```
+?
```
登录后复制
：匹配前一个字符一次或多次，但尽可能少。
```
??
```
登录后复制
：匹配前一个字符零次或一次，但尽可能少。
```
{m,n}?
```
登录后复制
：匹配前一个字符至少m次，至多n次，但尽可能少。

让我们用非贪婪模式来解决上面的问题：

text = "<a>link1</a><a>link2</a>"
pattern_non_greedy = r"<.*?>" # 注意这里的问号

match = re.search(pattern_non_greedy, text)
if match:
    print(f"非贪婪匹配结果: {match.group()}")
# 输出: 非贪婪匹配结果: <a>link1</a>

登录后复制

这次，

.*?

登录后复制

匹配了从第一个

登录后复制

到第一个

登录后复制

之间的最短字符串，这正是我们想要的。

何时使用贪婪，何时使用非贪婪？

贪婪模式在需要匹配整个块，直到字符串结束或遇到明确的结束标记时非常有用。例如，如果你想匹配从某个起始标记到行尾的所有内容。
非贪婪模式则在处理具有重复结构（如HTML/XML标签、JSON对象等）的文本时显得尤为重要，因为它能让你精确地匹配到每个独立的单元，而不是把它们全部连起来。

实际项目中，当你发现正则表达式匹配的结果比你预期的要长时，很可能就是贪婪模式在作祟，这时候尝试加上

登录后复制

往往能解决问题。这是一个非常实用的技巧。

Python正则表达式在实际项目中常见应用场景有哪些？

正则表达式在实际项目中的应用非常广泛，几乎只要涉及文本处理，它都有可能派上用场。它就像一把瑞士军刀，能帮你高效地完成各种文本操作。

1. 数据验证 (Data Validation)

这是最常见的应用之一。当你需要确保用户输入的数据符合特定格式时，正则表达式是你的得力助手。

邮箱地址验证： 检查用户输入的邮箱是否符合

name@domain.com

登录后复制

的基本结构。

email_regex = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
print(bool(re.match(email_regex, "user@example.com"))) # True
print(bool(re.match(email_regex, "invalid-email"))) # False

登录后复制

手机号码验证： 验证手机号是否为11位数字，且符合特定号段（虽然国内手机号规则复杂，但基本格式可用正则检查）。
密码强度检查： 检查密码是否包含大小写字母、数字、特殊字符，以及长度要求。
URL验证： 验证字符串是否是一个有效的URL格式。

2. 文本解析与信息提取 (Text Parsing and Information Extraction)

从非结构化或半结构化文本中提取特定信息是正则表达式的强项。

日志文件分析： 从大量的服务器日志中提取错误信息、IP地址、请求时间、用户ID等关键数据。

log_line = "ERROR 2023-10-27 10:30:05 User 'admin' failed login from 192.168.1.100."
error_pattern = r"ERROR (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) User '(\w+)' failed login from (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"
match = re.search(error_pattern, log_line)
if match:
    timestamp, username, ip_address = match.groups()
    print(f"时间: {timestamp}, 用户: {username}, IP: {ip_address}")

登录后复制

网页内容抓取 (Web Scraping)： 从HTML或XML文档中提取特定的标签内容、链接、图片URL等（虽然对于复杂HTML，BeautifulSoup等库更优，但正则对简单模式依然高效）。
配置文件的解析： 提取INI、YAML等配置文件中的键值对。

3. 文本替换与清洗 (Text Replacement and Cleaning)

批量修改或清理文本内容，正则表达式能让你事半功倍。

敏感信息脱敏： 将文本中的电话号码、身份证号等敏感信息替换为星号或其他占位符。

统一文本格式： 移除多余的空格、制表符，或者将特定格式的日期统一为另一种格式。

text = "  Hello   World!  "
cleaned_text = re.sub(r"\s+", " ", text).strip() # 将多个空格替换为单个空格，并去除首尾空格
print(f"清洗后的文本: '{cleaned_text}'") # 输出: 清洗后的文本: 'Hello World!'

登录后复制