Python re模块 用法详解 学习py正则表达式看这一篇就够了 超详细

引言

python 内置正则表达式模块 re 提供了一个功能强大且高度灵活的工具集,使得正则表达式的使用变得更加高效和直观,本文包含了大部分使用re时会使用的功能,同时提供使用用例

使用指南

导入模块

在 Python 中,使用正则表达式功能前需要先导入 re 模块:

import re

基本语法

python使用 r"正则表达式" 来将字符串定义为模式串,用以匹配字符串,使用下方语法创建模式串

  • 字符类
  • 锚点
  • 量词与分支
  • 标志
  • 组和引用
  • 零宽断言
  • 字符类

    1. 匹配集合中的任意*字符: [abc]
      text = "bar ber bir bor bur"
      result = re.findall(r"b[eo]r", text)
      print(result) # 输出 ['ber', 'bor']
      
    2. 匹配不在集合中的任意字符:[^abc]
      text = "bar ber bir bor bur"
      result = re.findall(r"b[^eo]r", text)
      print(result) # 输出 ['bar', 'bir', 'bur']
      
    3. 匹配范围:[a-z]
      能够匹配a-z的26字母,除此之外还有0-9A-Z
      text = "bar ber bir bor bur"
      result = re.findall(r"b[a-z]r", text)
      print(result) # 输出 ['bar', 'ber', 'bur']
      
      text = "abcdefghijklmnopqrstuvwxyz"
      result = re.findall(r"[e-i]", text)
      print(result) # 输出 ['e', 'f', 'g', 'h', 'i']
      
    4. 通配符匹配:.
      result = re.findall(r".", "hi012_-!?") 
      print(result) # 输出: ['h', 'i', '0', '1', '2', '_', '-', '!', '?']
      
    5. 匹配字母、数字或下划线: \w
      text = "hi012_-!? foo_bar123" 
      result = re.findall(r"\w", text) 
      print(result) # 输出: ['h', 'i', '0', '1', '2', 'f', 'o', 'o', 'b', 'a', 'r', '1', '2', '3']
      
    6. 匹配除字母、数字和下划线之外的任意字符: \W
      text = "hi012_-!? foo_bar123" 
      result = re.findall(r"\w", text) 
      print(result) # 输出: ['-', '-', '!', '?', ' ']
      
    7. 匹配所有数字: \d
      text = "Call 123-456-7890!" 
      result = re.findall(r"\D", text) 
      print(result) # 输出: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'] 
      
    8. 匹配除数字外的任意字符 \D
      text = "Call 123-456-7890!" 
      result = re.findall(r"\D", text) 
      print(result) # 输出: ['C', 'a', 'l', 'l', ' ', '-', '-', '!'] 
      
    9. 匹配所有空白字符: \s
      text = "Hello World!\nThis is a test." 
      result = re.findall(r"\s", text) print(result) # 输出: [' ', '\n', ' ', ' ', ' ']
      
    10. 匹配除空白字符以外的任意字符: \S
      text = "Hello World!\n" 
      result = re.findall(r"\S", text) 
      print(result) # 输出: ['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '!']
      
    11. 匹配特殊字符:\
      在正则表达式中,反斜杠\是转义字符,因此需要使用双反斜杠\\ 来匹配实际的反斜杠字符,使用\.来表示.,使用\+来表示+,等字符
      text = r"This is a path: C:\\Users\\Name\\Documents and \\Settings"
      # 匹配所有反斜杠
      result = re.findall(r"\\", text)
      print(result)  # 输出: ['\\', '\\', '\\', '\\', '\\']
      

    锚点

    1. 匹配字符串或行的开头: ^
      text = "an answer or a question"  
      result = re.findall(r"^\w+", text)
      print(result)  # 输出: ['an']
      
    2. 匹配字符串或行的结尾: $
      text = "an answer or a question"
      result = re.findall(r"\w+$", text)
      print(result)  # 输出: ['question']
      
    3. 匹配单词的开头或结尾: \b
      text = "an answer or a question"
      result = re.findall(r"n\b", text)
      print(result)  # 输出: ['n', 'n']
      # 这里匹配的是位于单词结尾的n 匹配的是an和question
      
    4. 匹配不在单词开头或末尾的位置:\B
      text = "an answer or a question"
      result = re.findall(r"n\B", text)
      print(result)  # 输出: ['n']
      # 这里匹配的是不在单词结尾的n 匹配的是answer
      

    量词与分支

    1. 匹配一个或多个:+
      text = "bp bep beep beeep"
      result = re.findall(r"be+p", text)
      print(result) # 输出: ['bep', 'beep', 'beeep']
      
    2. 匹配零个或多个:*
      text = "bp bep beep beeep"
      result = re.findall(r"be*p", text)
      print(result) # 输出: ['bp', 'bep', 'beep', 'beeep']
      
    3. 匹配指定范围:{n, m}
      text = "bp bep beep beeep"
      result = re.findall(r"be{1,2}p", text)
      print(result) # 输出: ['bep', 'beep']
      
    4. 匹配可选: ?
      text = "color colour colr"
      result = re.findall(r"colou?r", text)
      print(result) # 输出: ['color', 'colour']
      
    5. 分支条件: |
      text = "fat cat rat"
      result = re.findall(r"cat|rat", text)
      print(result) # 输出: ['cat', 'rat']
      
      # 可以与()结合使用
      text = "Error 404: Page not found. Error 500: Internal server error." 
      pattern = 
      result = re.findall(r"Error (404|500)", text) 
      # 匹配 "Error 404" 或 "Error 500" 
      print(result) # 输出: ['404', '500']
      # 使用findall函数,若正则表达式中有分组(),则只返回分组中内容
      

    标志

    1. 忽略大小写:re.I
      text = "CaT cat cAt"
      result = re.findall(r"cat", text, flags=re.I)
      print(result)  # 输出: ['CaT', cat, cAt]
      
    2. 多行模式:re.M
      主要针对^$,添加后可以匹配到每一行的行头和行尾,否则只能匹配到整个字符串的开头和末尾
      multiline_text = "cat\ncat\ncat"
      
      result = re.findall(r"^cat", multiline_text)
      print(result) # 输出: ['cat']
      
      result = re.findall(r"^cat", multiline_text, flags=re.M)
      print(result)  # 输出: ['cat', 'cat', 'cat']
      
    3. 添加注释:re.X
      可以使用"""#为自己写的正则表达式添加注释
      a = re.compile(r"""\d +  # the integral part
                         \.    # the decimal point
                         \d *  # some fractional digits""", re.X)
      b = re.compile(r"\d+\.\d*")
      # 这两者的效果相等
      

    组和引用

    如果在findall中使用分组,只会返回匹配成功后分组内的内容

    1. 使用括号分组:()
      用于将正则表达式的一部分组合在一起,方便后续应用量词或提取数据
      text = "hahaha hah haha" 
      # 匹配重复的 "ha" 
      result = re.findall(r"(ha)+", text) 
      # 匹配到 hahaha ha haha
      print(result) # 输出: ['ha', 'ha', 'ha']
      
    2. 引用表达式的分组: \1, \2, …
      \1 引用第一个分组,\2 引用第二个分组,依此类推
      text = "hah haa dad" 
      # 匹配模式是 "某字符 + a + 相同字符" 
      result = re.findall(r"(\w)a\1", text)
      # 匹配到 haa dad
      print(result) # 输出: ['h', 'd']
      
    3. 创建无法引用的分组: (?: )
      (?: ) 表示一个非捕获分组,不会存储匹配内容
      text = "hahaha hah haha" 
      # 匹配 "ha" 多次,但不捕获分组内容
      result = re.findall(r"(?:ha)+", text) 
      print(result) # 输出: ['hahaha', 'ha', 'haha']
      # 使用正常分组的结果:['ha', 'ha', 'ha']
      
      text = "hah haa dad"
      re.findall(r"(?:\w)a\1", text) # 抛错
      
    4. 分组命名:(?P<name>...)
      text = "apple=apple banana=orange grape=grape"
      result = re.findall(r"(?P<word>\w+)=(?P=word)", text)
      print(result) # 输出:['apple', 'grape']
      # (?P<word>\w+) 定义了一个名为 word 的分组,匹配一个单词
      # (?P=word) 引用了分组 word 的内容,要求后面的部分与前面的单词一致
      
      # 验证HTML标签的正确配对
      pattern = r"<(?P<tag>\w+)>.*?</(?P=tag)>"
      text = "<div>content</div> <p>text</p> <div>another</p>"
      result = re.findall(pattern, text)
      print(result) # 输出:[('div',), ('p',)]
      # (?P<tag>\w+) 定义了一个名为 tag 的分组,用来匹配 HTML 标签名称
      # </(?P=tag)> 引用了 tag 分组,要求结束标签与开始标签名称一致
      

    零宽断言

    零宽断言匹配的是位置,而不是字符

    1. 正向前瞻: (?=...)
      匹配满足某条件的前一个字符或位置。
      text = "1st 2nd 3pc"
      # 匹配数字后面跟着 "nd" 的情况
      result = re.findall(r"\d(?=nd)", text)
      print(result)  # 输出: ['2']
      
    2. 负向前瞻: (?!...)
      匹配不满足某条件的前一个字符或位置
      text = "1st 2nd 3pc"
      # 匹配数字后面不是 "nd" 的情况
      result = re.findall(r"\d(?!nd)", text)
      print(result)  # 输出: ['1', '3']
      
    3. 正向后瞻: (?<=...)
      匹配满足某条件的后一个字符或位置
      text = "#1 $2 %3"
      # 匹配 "前面是 %" 的数字
      result = re.findall(r"(?<=%)\d", text)
      print(result)  # 输出: ['3']
      
    4. 负向后瞻: (?<!...)
      匹配不满足某条件的后一个字符或位置
      text = "#1 $2 %3"
      # 匹配 "前面不是 %" 的数字
      result = re.findall(r"(?<!%)\d", text)
      print(result)  # 输出: ['1', '2']
      

    贪婪模式与非贪婪模式

    python默认就是贪婪模式,在量词后添加?可以变成非贪婪模式

    贪婪模式

    *+会尽量多地匹配字符,直到无法再匹配为止

    text = "<h1>Title</h1><p>Paragraph</p>"
    # 贪婪模式:匹配整个 HTML 标签内容
    result = re.search(r'<.*>', text)
    print(result.group())  # 输出: <h1>Title</h1><p>Paragraph</p>
    

    非贪婪模式

    *?+?会尽量少地匹配字符,通常在满足匹配条件时就停止

    text = "<h1>Title</h1><p>Paragraph</p>"
    # 非贪婪模式:只匹配第一个 HTML 标签内容
    result = re.search(r'<.*?>', text)
    print(result.group())  # 输出: <h1>
    

    核心函数

    re.compile(pattern, flags=0)

    作用:将正则表达式模式串编译成一个正则表达式对象,后续可以多次使用,提高匹配效率
    参数

  • pattern:字符串类型,正则表达式模式串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个 Pattern 对象

    示例

    pattern = re.compile(r"\d{3}-\d{2}-\d{4}")
    result = pattern.match("123-45-6789")
    print(result.group())  # 输出: 123-45-6789
    

    re.search(pattern, string, flags=0)

    作用:扫描整个字符串,查找第一个匹配正则表达式的子串,返回一个匹配对象 match,如果没有找到匹配,返回 None
    参数

  • pattern :字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个 Match 对象,或者如果没有找到匹配,返回 None

    示例

    result = re.search(r"\d{3}-\d{2}-\d{4}", "My number is 123-45-6789")
    if result:
        print(result.group())  # 输出: 123-45-6789
    

    re.match(pattern, string, flags=0)

    作用:尝试从字符串的开头开始匹配,如果开头的部分匹配正则表达式,则返回一个匹配对象。如果匹配失败,则返回 None
    参数

  • pattern:字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个 Match 对象,或者如果没有匹配,返回 None

    示例

    result = re.match(r"\d{3}-\d{2}-\d{4}", "123-45-6789")
    if result:
        print(result.group())  # 输出: 123-45-6789
    

    re.fullmatch(pattern, string, flags=0)

    作用:如果整个字符串完全匹配正则表达式,则返回匹配对象。如果只有部分匹配,则返回 None
    参数

  • pattern:字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个 Match 对象,或者如果没有匹配,返回 None

    示例

    result = re.fullmatch(r"\d{3}-\d{2}-\d{4}", "123-45-6789")
    if result:
        print(result.group())  # 输出: 123-45-6789
    
    result = re.fullmatch(r"\d{3}-\d{2}-\d{4}", "123-45-678910")
    print(result)  # 输出: None
    

    re.split(pattern, string, maxsplit=0, flags=0)

    作用:根据正则表达式匹配的分隔符分割字符串,返回一个列表
    参数

  • pattern:字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • maxsplit(可选):最大分割次数。如果指定了 maxsplit,则只进行 maxsplit 次分割
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个列表,包含分割后的子串

    示例

    result = re.split(r"\s+", "This is a test string")
    print(result)  # 输出: ['This', 'is', 'a', 'test', 'string']
    
    result = re.split(r'\W+', 'Words, words, words.', maxsplit=1)
    print(result) #输出:['Words', 'words, words.']
    

    re.findall(pattern, string, flags=0)

    作用:返回所有匹配项的列表,每个匹配项是一个字符串,如果有捕获组,则返回捕获组内容
    参数

  • pattern:字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个列表,包含所有匹配的子串

    示例

    result = re.findall(r"\d+", "123 abc 456 def 789")
    print(result)  # 输出: ['123', '456', '789']
    

    re.finditer(pattern, string, flags=0)

    作用:类似于 findall(),但返回的是一个迭代器,每个元素是一个 match 对象,可以获取匹配的具体信息(如位置)
    参数

  • pattern:字符串类型,正则表达式模式串
  • string:要进行匹配的目标字符串
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个迭代器,迭代每个匹配的 Match 对象

    示例

    text = "abc123def456ghi789"
    matches = re.finditer(r"\d+", text)
    
    for match in matches:
        print(f"Matched: {match.group()}, Start: {match.start()}, End: {match.end()}")
        # 输出:
        # Matched: 123, Start: 3, End: 6
    	# Matched: 456, Start: 9, End: 12
    	# Matched: 789, Start: 15, End: 18
    

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

    作用:用指定的替换字符串替换正则表达式匹配的所有部分,返回替换后的字符串
    参数

  • pattern:字符串类型,正则表达式模式串
  • repl:用于替换的字符串
  • string:要进行匹配的目标字符串
  • count(可选):替换的最大次数,默认替换所有匹配项
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回替换后的字符串

    示例

    result = re.sub(r"\d+", "X", "123 abc 456 def 789")
    print(result)  # 输出: X abc X def X
    

    re.subn(pattern, repl, string, count=0, flags=0)

    作用:与sub()类似,但返回的是一个元组 (替换后的字符串, 替换次数)
    参数

  • pattern:字符串类型,正则表达式模式串
  • repl:用于替换的字符串
  • string:要进行匹配的目标字符串
  • count(可选):替换的最大次数,默认替换所有匹配项
  • flags(可选):匹配模式,通常是 re.Mre.I
  • 返回:返回一个元组,包含替换后的字符串和替换的次数

    示例

    result = re.subn(r"\d+", "X", "123 abc 456 def 789")
    print(result)  # 输出: ('X abc X def X', 3)
    

    re.escape(pattern)

    作用:对字符串中的特殊字符进行转义,使它们能够作为普通字符使用,返回转义后的字符串
    参数

  • pattern:要进行转义的字符串
  • 返回:返回转义后的字符串

    示例

    result = re.escape("Hello. How are you?")
    print(result)  # 输出: Hello\. How are you\?
    

    核心对象

    Match对象

    Match 对象通常由 re.match(), re.search(), re.finditer()等函数返回

    属性:

  • string:原始输入字符串
    match = re.match(r"(\d+)-(\d+)", "123-456-234")
    print(match.group()) # 输出:123-456
    print(match.string) # 输出:123-456-234
    
  • pos:匹配的起始位置(相对于原字符串的偏移量)
    match = re.match(r"(\d+)-(\d+)", "123-456-234")
    print(match.pos) # 输出:0
    
  • endpos:匹配的结束位置(相对于原字符串的偏移量),结束是指最后一个匹配字符的后一位
    match = re.match(r"(\d+)-(\d+)", "123-456-234")
    print(match.endpos) # 输出:11
    
  • lastgroup:返回最后一个捕获组的名称(如果有命名组)
    match = re.match(r"(?P<first>\d+)-(?P<second>\d+)", "123-456")
    # 命名第一个分组为first,第二个分组为second
    print(match.lastgroup) # 输出: second
    
  • lastindex:返回最后一个捕获组的索引(数字表示)
    match = re.match(r"(\d+)-(\d+)", "123-456")
    print(match.lastindex) # 输出: 2
    
  • 方法

  • group([group1, …]): 返回匹配的子字符串或多个子字符串,如果没有指定参数,返回整个匹配内容,如果指定了参数,返回指定组的内容
    match = re.match(r"(\d+)-(\d+)", "123-456")  
    # 不使用分组也能输出
    print(match.group()) # 输出: '123-456'
    # 使用分组后才能输出,否则会报错
    print(match.group(1)) # 输出: '123'
    print(match.group(2)) # 输出: '456'
    
  • start([group]):返回匹配的起始位置,如果指定了组号,返回该组匹配的起始位置
    match = re.match(r"(\d+)-(\d+)", "abc-123-456")
    print(match.start(1)) # 输出: 0 (组 1 匹配的开始位置)
    
    match = re.search(r"(\d+)-(\d+)", "abc-123-456")
    print(match.start(1)) # 输出:4
    
  • end([group]):回匹配的结束位置,如果指定了组号,返回该组匹配的结束位置,结束是指最后一个匹配字符的后一位
    match = re.match(r"(\d+)-(\d+)", "123-456")
    print(match.end(1))  # 输出: 3 (组 1 匹配的结束位置)
    print(match.end()) # 输出:7
    
  • span([group]):返回匹配的(start, end)位置元组,表示匹配的起始和结束位置,结束是指最后一个匹配字符的后一位
    match = re.match(r"(\d+)-(\d+)", "123-456")
    print(match.span(2)) # 输出: (4, 7)
    
  • groupdict(default=None):返回一个字典,其中键为命名的分组名,值为分组匹配到的内容,如果某个命名分组没有匹配内容,则返回 default 参数的值
    text = "2024-12-23"
    pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
    print(match.groupdict()) # 输出:{'year': '2024', 'month': '12', 'day': '23'}
    
    pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})-?(?P<time>\d{2}:\d{2})?"
    match = re.match(pattern, text)
    print(match.groupdict(default="N/A")) # 输出: {'year': '2024', 'month': '12', 'day': '23', 'time': 'N/A'}
    
  • expand(template):使用指定的模板格式化匹配结果,模板中的 \g<name>\number 表示引用命名分组或捕获组
    pattern = r"(?P<area_code>\d{3})-(?P<number>\d{7})"
    text = "123-4567890"
    
    # 引用命名分组
    match = re.match(pattern, text)
    print(match.expand(r"(\g<area_code>) \g<number>"))  # 输出: (123) 4567890
    
    # 引用分组编号
    match = re.match(r"(\d{3})-(\d{7})", text)
    print(match.expand(r"(\1) \2"))  # 输出: (123) 4567890
    
  • Pattern对象

    Pattern 对象是通过 re.compile() 编译正则表达式后得到的对象,它代表了一个正则表达式的预编译版本,可以重复使用,以提高性能

    属性:

  • flags: 返回用于编译正则表达式时所用的标志(flags)
    pattern = re.compile(r"(?i)hello", re.M)
    print(pattern.flags) # 输出: 42
    print(pattern.flags & re.MULTILINE) # 输出:re.MULTILINE
    print(pattern.flags & re.S) # 输出:re.NOFLAG
    
  • groups:返回模式中捕获组的数量(即括号()的个数),非捕获组 (?:...) 不会计入捕获组数
    pattern = re.compile(r"(a)(b(c))")
    print(pattern.groups) # 输出: 3 (对应: a, b, c)
    
  • groupindex:返回一个字典,映射命名分组的名称到对应的分组编号,如果没有使用命名分组,则返回空字典
    pattern = re.compile(r"(?P<first>a)(?P<second>b)")
    print(pattern.groupindex) # 输出: {'first': 1, 'second': 2}
    
    pattern = re.compile(r"(a)(b)")
    print(pattern.groupindex) # 输出: {}
    
  • pattern:返回原始的正则表达式字符串
    pattern = re.compile(r"hello\d+")
    print(pattern.pattern) # 输出: hello\d+
    
  • 方法

  • search(string[, pos[, endpos]]):在字符串中搜索第一个匹配的子字符串,返回一个 Match 对象;如果没有匹配,返回 None
  • 参数
  • string:要匹配的目标字符串
  • pos:开始搜索的位置,默认为 0
  • endpos:结束搜索的位置,默认为字符串的长度
  • pattern = re.compile(r"\d+")
    match = pattern.search("abc123xyz456")
    print(match.group()) # 输出: 123
    
  • match(string[, pos[, endpos]]):从字符串的开头匹配,如果匹配成功,返回一个 Match 对象,否则返回 None
  • 参数
  • string:要匹配的目标字符串
  • pos:开始搜索的位置,默认为 0
  • endpos:结束搜索的位置,默认为字符串的长度
  • pattern = re.compile(r"\d+")
    match = pattern.match("123abc")
    print(match.group()) # 输出: 123
    
  • fullmatch(string[, pos[, endpos]]): 尝试将整个字符串与正则模式完全匹配,匹配成功则返回 Match 对象;否则返回 None
  • 参数
  • string:要匹配的目标字符串
  • pos:开始搜索的位置,默认为 0
  • endpos:结束搜索的位置,默认为字符串的长度
  • pattern = re.compile(r"\d+")
    match = pattern.fullmatch("123")
    print(match.group()) # 输出: 123
    
  • split(string, maxsplit=0):使用正则表达式的匹配结果分割字符串,返回一个列表
  • 参数
  • string:要匹配的目标字符串
  • maxsplit:最大分割次数,默认为 0 表示分割所有可能的位置
  • pattern = re.compile(r"\s+")
    result = pattern.split("a b  c   d")
    print(result) # 输出: ['a', 'b', 'c', 'd']
    
  • findall(string[, pos[, endpos]]):返回所有匹配项的列表,每个匹配项是一个字符串;如果有捕获组,则返回捕获组内容
  • 参数
  • string:要匹配的目标字符串
  • pos:开始搜索的位置,默认为 0
  • endpos:结束搜索的位置,默认为字符串的长度
  • pattern = re.compile(r"\d+")
    result = pattern.findall("abc123xyz456")
    print(result) # 输出: ['123', '456']
    
  • finditer(string[, pos[, endpos]]):类似于 findall(),但返回的是一个迭代器,每个元素是一个 match 对象
  • 参数
  • string:要匹配的目标字符串
  • pos:开始搜索的位置,默认为 0
  • endpos:结束搜索的位置,默认为字符串的长度
  • pattern = re.compile(r"\d+")
    for match in pattern.finditer("abc123xyz456"):
    	print(match.group())
        # 输出:
    	# 123
    	# 456
    
  • sub(repl, string, count=0):用指定的替换字符串替换正则表达式匹配的所有部分,返回替换后的字符串
  • 参数
  • repl:替换的内容,可以是字符串或函数
  • string:目标字符串
  • count:替换次数,默认为 0 表示替换所有匹配项
  • pattern = re.compile(r"\d+")
    result = pattern.sub("0", "abc123xyz456")
    print(result)  # 输出: abc0xyz0
    
  • subn(repl, string, count=0):与sub()类似,但返回的是一个元组 (替换后的字符串, 替换次数)
  • 参数
  • repl:替换的内容,可以是字符串或函数
  • string:目标字符串
  • count:替换次数,默认为 0 表示替换所有匹配项
  • pattern = re.compile(r"\d+")
    result = pattern.sub("0", "abc123xyz456")
    print(result)  # 输出: ("abc0xyz0", 2)
    

    小结

    本指南从基础到进阶,详细介绍了 re 模块的核心功能,并通过丰富的示例帮助您掌握其应用技巧,希望本文能够为深入学习正则表达式的读者提供启发,同时也为初学者实践打下坚实的基础

    最后,学习regex推荐一个网站:RegexLearn,零基础学习正则表达式,特别适合短时间系统学习正则表达式

    码字不易,求赞求收藏!

    作者:玖年JN

    物联沃分享整理
    物联沃-IOTWORD物联网 » Python re模块 用法详解 学习py正则表达式看这一篇就够了 超详细

    发表回复