当前位置:首页 > 文章列表 > 文章 > python教程 > Python正则表达式怎么用

Python正则表达式怎么用

2025-09-16 12:55:50 0浏览 收藏

来到golang学习网的大家,相信都是编程学习爱好者,希望在这里学习文章相关编程知识。下面本篇文章就来带大家聊聊《python怎么使用正则表达式匹配内容_python正则表达式使用指南》,介绍一下,希望对大家的知识积累有所帮助,助力实战开发!

Python通过re模块实现正则表达式,核心是编写模式字符串并使用search、match、findall、sub等函数进行查找、匹配、提取和替换操作。

python怎么使用正则表达式匹配内容_python正则表达式使用指南

Python使用正则表达式主要通过内置的re模块来实现,它提供了一系列函数,让你能够定义复杂的文本匹配模式,并在字符串中查找、替换或提取符合这些模式的内容。核心思想是先写一个描述目标文本结构的“模式字符串”,然后用re模块的函数去处理你想要分析的文本。

解决方案

在Python里玩转正则表达式,我的经验是,首先得把re模块请进来。这就像你要盖房子,得先有工具箱。

import re

然后,我们就可以开始干活了。最常用的几个工具大概是这样的:

  1. re.search(pattern, string): 这个函数会扫描整个字符串,找到第一个匹配pattern的位置。如果找到了,它会返回一个Match对象;如果没找到,就返回None。我个人觉得,这是日常使用频率最高的函数之一,因为很多时候我只需要知道“有没有”或者“第一个是什么”。

    text = "我的电话是138-0013-8000,紧急联系人电话是13912345678。"
    pattern = r"\d{3}-\d{4}-\d{4}" # 匹配手机号格式,r前缀表示这是一个原始字符串,避免反斜杠的转义问题
    match = re.search(pattern, text)
    
    if match:
        print(f"找到了第一个电话号码: {match.group(0)}") # group(0)返回整个匹配到的字符串
        # 输出: 找到了第一个电话号码: 138-0013-8000
    else:
        print("没找到符合格式的电话号码。")
  2. re.match(pattern, string): 和search有点像,但它有个严格的规定:只从字符串的开头进行匹配。如果模式不在字符串开头,即使后面有匹配项,match也会返回None。这在处理固定格式的字符串开头时特别有用,比如我经常用它来验证文件名的前缀。

    text_start = "Hello World!"
    text_middle = "Say Hello World!"
    pattern_hello = r"Hello"
    
    match_start = re.match(pattern_hello, text_start)
    match_middle = re.match(pattern_hello, text_middle)
    
    if match_start:
        print(f"从开头匹配到: {match_start.group(0)}") # 输出: 从开头匹配到: Hello
    else:
        print("开头未匹配到。")
    
    if match_middle:
        print(f"从开头匹配到: {match_middle.group(0)}")
    else:
        print("开头未匹配到。") # 输出: 开头未匹配到。
  3. re.findall(pattern, string): 如果你需要找出字符串中所有不重叠的匹配项,findall就是你的不二之选。它会返回一个包含所有匹配字符串的列表。我发现它在从日志文件或网页内容中批量提取信息时特别好用。

    text_all_numbers = "商品A价格12.5元,商品B价格99.99元,商品C价格3元。"
    pattern_price = r"\d+\.?\d*" # 匹配整数或小数
    all_prices = re.findall(pattern_price, text_all_numbers)
    print(f"所有价格: {all_prices}") # 输出: 所有价格: ['12.5', '99.99', '3']
  4. re.sub(pattern, repl, string, count=0): 这个函数用来替换字符串中匹配pattern的部分。repl可以是字符串,也可以是一个函数。count参数可以限制替换的次数。我经常用它来清洗数据,比如把多余的空格替换掉,或者把一些敏感信息脱敏。

    text_clean = "你好  世界!  这是一个   测试。"
    pattern_spaces = r"\s+" # 匹配一个或多个空格
    cleaned_text = re.sub(pattern_spaces, " ", text_clean)
    print(f"清理后的文本: {cleaned_text}") # 输出: 清理后的文本: 你好 世界! 这是一个 测试。

理解这几个基本函数,并掌握如何构建模式字符串,你就已经迈出了Python正则表达式的第一步。

Python正则表达式中常用的匹配模式有哪些?

说实话,正则表达式的“模式”才是它真正强大且让人又爱又恨的地方。刚开始学的时候,我常常被那些符号搞得头晕眼花,但一旦掌握了,你会发现它们能解决很多看似复杂的文本处理问题。这里我把我日常最常用的一些模式总结一下:

  • 基本字符匹配:

    • . (点): 匹配除了换行符\n之外的任意一个字符。这玩意儿简直是万能牌,但用的时候得小心,因为它可能匹配到你不想匹配的东西。
    • \d: 匹配任意一个数字(0-9)。我的密码验证、电话号码提取都离不开它。
    • \D: 匹配任意一个非数字字符
    • \w: 匹配任意一个字母、数字或下划线([a-zA-Z0-9_])。处理变量名、单词时很方便。
    • \W: 匹配任意一个非字母、数字、下划线字符
    • \s: 匹配任意一个空白字符(空格、制表符、换行符等)。文本清洗时,它和+组合起来是神器。
    • \S: 匹配任意一个非空白字符
  • 数量词(Quantifiers): 这些是用来指定前面那个字符或组要出现多少次的。

    • *: 匹配零次或多次。比如a*能匹配"", a, aa, aaa...
    • +: 匹配一次或多次a+能匹配a, aa, aaa...但不能匹配""
    • ?: 匹配零次或一次colou?r可以匹配colorcolour
    • {n}: 匹配恰好n次\d{4}匹配四位数字。
    • {n,}: 匹配至少n次\d{3,}匹配三位或更多位数字。
    • {n,m}: 匹配n到m次\d{3,5}匹配三到五位数字。
  • 边界匹配:

    • ^: 匹配字符串的开头
    • $: 匹配字符串的结尾
    • \b: 匹配单词边界。比如\bcat\b只会匹配独立的单词"cat",而不会匹配"category"中的"cat"。这在精确匹配单词时非常有用。
    • \B: 匹配非单词边界
  • 字符集:

    • [abc]: 匹配方括号中的任意一个字符。比如[aeiou]匹配任意一个元音字母。
    • [a-z]: 匹配指定范围内的字符[0-9]等同于\d
    • [^abc]: 匹配不在方括号中的任意一个字符[^0-9]等同于\D
  • 分组与捕获:

    • (pattern): 用小括号括起来的部分形成一个捕获组。这不仅能让你把一组模式当作一个整体来应用数量词(比如(ab)+),还能让你在Match对象中单独提取这个组匹配到的内容(通过match.group(1)match.group(2)等)。我个人觉得,分组是正则表达式进阶的必经之路,数据提取全靠它了。
    • (?:pattern): 非捕获组。它也把模式当作一个整体,但不会捕获匹配到的内容,所以不会占用group()的索引。当你只想分组而不关心捕获时,用这个可以提升一点点性能,也让代码更清晰。
  • 选择符:

    • |: cat|dog可以匹配"cat"或"dog"。
  • 转义:

    • \ (反斜杠): 如果你的模式中需要匹配正则表达式的特殊字符本身(比如., *, ?, +, (, ), [, ], {, }, ^, $, |, \),你就需要在它们前面加上反斜杠进行转义。比如要匹配一个点号,你得写\.

构建这些模式的时候,我通常会先在心里模拟一下,或者直接用一些在线的正则表达式测试工具(比如regex101.com)来验证我的模式是不是真的能匹配到我想要的东西。

在Python中处理正则表达式匹配结果时有哪些技巧和注意事项?

匹配到了结果,怎么用好它,这也有不少学问。我这里分享一些我常用的技巧和踩过的一些坑。

  1. Match对象的妙用: 当re.search()re.match()找到匹配时,它们返回的是一个Match对象。这个对象可不只是告诉你“有”或“没有”那么简单,它包含了匹配的所有细节:

    • match.group(0): 返回整个匹配到的字符串。这是最常用的。
    • match.group(1), match.group(2)...: 返回对应捕获组匹配到的字符串。如果你有多个捕获组,它们会按从左到右的顺序编号。
    • match.groups(): 返回一个包含所有捕获组内容的元组。
    • match.start(): 返回匹配开始的索引。
    • match.end(): 返回匹配结束的索引(不包含)。
    • match.span(): 返回一个元组(start, end)。 利用这些,你可以精确地知道匹配到的内容是什么,在哪里。
    text = "联系电话是: (010)1234-5678"
    pattern = r"\((\d{3})\)(\d{4}-\d{4})" # 两个捕获组,一个用于区号,一个用于号码
    match = re.search(pattern, text)
    
    if match:
        print(f"完整匹配: {match.group(0)}") # 输出: (010)1234-5678
        print(f"区号: {match.group(1)}")   # 输出: 010
        print(f"号码: {match.group(2)}")   # 输出: 1234-5678
        print(f"所有分组: {match.groups()}") # 输出: ('010', '1234-5678')
        print(f"匹配位置: {match.span()}")  # 输出: (7, 22)
  2. 贪婪与非贪婪匹配: 这是个经典陷阱!默认情况下,正则表达式的数量词(*, +, ?, {n,m})都是“贪婪”的,它们会尽可能多地匹配字符。但有时候,你可能只想要最短的匹配。这时,你可以在数量词后面加上一个?,让它变成“非贪婪”模式。

    html_text = "<h1>标题1</h1><p>内容</p><h1>标题2</h1>"
    greedy_pattern = r"<h1>.*</h1>" # 贪婪模式
    non_greedy_pattern = r"<h1>.*?</h1>" # 非贪婪模式
    
    greedy_match = re.search(greedy_pattern, html_text)
    if greedy_match:
        print(f"贪婪匹配: {greedy_match.group(0)}") # 输出: <h1>标题1</h1><p>内容</p><h1>标题2</h1>
    
    non_greedy_match = re.search(non_greedy_pattern, html_text)
    if non_greedy_match:
        print(f"非贪婪匹配: {non_greedy_match.group(0)}") # 输出: <h1>标题1</h1>

    你看,一个?的区别,结果大相径庭。我刚开始用的时候就经常被这个坑到,以为.*就能匹配一个标签,结果把整个HTML都吞了。

  3. 编译正则表达式: 如果你需要在程序中多次使用同一个正则表达式模式,那么使用re.compile()来编译它是一个非常好的习惯。它会把模式编译成一个RegexObject对象,这样在后续使用时就不用每次都重新编译了,能提升一点性能。对于短脚本可能不明显,但对于处理大量文本或在循环中频繁使用正则的场景,编译带来的好处是实实在在的。

    phone_pattern = re.compile(r"(\d{3})-(\d{4})-(\d{4})")
    text_list = ["电话: 139-1234-5678", "座机: 010-8765-4321"]
    
    for text in text_list:
        match = phone_pattern.search(text)
        if match:
            print(f"找到号码: {match.group(0)}")
  4. 匹配标志(Flags): re模块提供了一些标志,可以改变正则表达式的匹配行为。这些标志可以作为函数的第三个参数传入,或者在编译时传入。

    • re.IGNORECASE (或 re.I): 忽略大小写。
    • re.DOTALL (或 re.S): 让.(点号)也能匹配换行符\n。默认情况下.是不匹配换行符的。
    • re.MULTILINE (或 re.M): 改变^$的行为。在多行模式下,^不仅匹配字符串开头,还匹配每一行的开头;$不仅匹配字符串结尾,还匹配每一行的结尾。
    multi_line_text = "First line\nSecond line"
    pattern_dotall = r"First.*line"
    match_dotall = re.search(pattern_dotall, multi_line_text, re.DOTALL)
    if match_dotall:
        print(f"DOTALL匹配: '{match_dotall.group(0)}'") # 输出: 'First line\nSecond line'
  5. 处理无匹配情况: 永远要记得,re.search()re.match()在没有找到匹配时会返回None。所以,在使用Match对象之前,务必进行非空判断,否则直接访问match.group()会抛出AttributeError。这是我个人写代码时最常犯的低级错误之一,因为有时候我太自信我的模式了,哈哈。

    no_match_text = "没有数字"
    pattern_digit = r"\d+"
    match_obj = re.search(pattern_digit, no_match_text)
    
    if match_obj: # 良好的编程习惯
        print(f"找到了: {match_obj.group(0)}")
    else:
        print("什么也没找到。")

掌握这些技巧,能让你在处理匹配结果时更加得心应手,避免一些不必要的错误。

Python正则表达式在实际开发中能解决哪些具体问题?

正则表达式在实际开发中简直是文本处理的瑞士军刀,用途非常广泛。我个人在很多场景下都依赖它,从最简单的文本清理到复杂的数据提取。

  1. 数据验证: 这是我用得最多的场景之一。

    • 邮箱地址验证: 虽然完全符合RFC标准的邮箱正则非常复杂,但一个简单的模式(比如r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")就能过滤掉大部分不合法的输入。
    • 手机号码验证: 针对不同国家的手机号格式,编写相应的正则进行验证。比如中国大陆的11位手机号(r"^1[3-9]\d{9}$")。
    • URL验证: 确保用户输入的链接格式正确。
    • 密码强度检查: 检查密码是否包含大小写字母、数字、特殊字符,以及是否达到最小长度。
  2. 文本提取: 从非结构化或半结构化文本中抽取出你想要的信息。

    • 日志文件解析: 从大量的服务器日志中提取出错误信息、IP地址、请求时间、特定事件ID等。比如,我想找出所有包含“ERROR”关键字的行,并提取其后的错误代码。
    • 网页爬虫数据提取: 虽然现在很多爬虫会用BeautifulSoup等库解析HTML,但在处理特定格式的文本块或JS代码中的数据时,正则依然是高效且直接的工具。比如,从