python正则匹配非贪婪匹配 python 正则匹配 (?!pattern)

转载

mob64ca13f937ae 2024-07-22 18:35:59

文章标签 python正则匹配非贪婪匹配 python 字符串正则表达式子串 文章分类 Python 后端开发

1. 正则表达式模块: re

正则表达式简单使用示例:

import re

pattern = re.compile("[0-9]+")          # 编译正则表达式, 返回 re.Pattern

print(pattern.match("12cd"))            # 匹配字符串(匹配开头), 匹配, 返回 re.Match
print(pattern.match("ab34"))            # 匹配字符串(匹配开头), 不匹配, 返回 None
print(pattern.fullmatch("1234"))        # 匹配整个字符串
print(pattern.findall("ab12cd34"))      # 搜索整个字符串, 返回所有匹配的子串列表: ["12", "34"]

match = pattern.search("ab12cd")        # 从整个字符串中搜索("[0-9]+")第一个匹配的结果,
if match:                               # 搜索到匹配结果, 返回 re.Match, 否则为 None,
    print(match.group())                # 获取搜索到的结果, 结果为 "12"

print(re.match("[0-9]+", "12cd"))       # 也可以调用 re 模块的直接方法进行匹配,
print(re.fullmatch("[0-9]+", "1234"))   # 内部也是先编译再匹配, 内部编译好的正则表达式对象会缓存, 
print(re.findall("[0-9]+", "ab12cd34")) # 下次再使用该正则表达式(pattern与flags相同)时, 
print(re.search("[0-9]+", "ab12cd"))    # 直接从缓存中获取正则表达式对象, re.purge() 清除缓存。

re模块中的函数与常量（Python官网 re模块内容）:

# 将正则表达式编译为正则表达式对象 re.Pattern
#
# 参数:
#     pattern: 正则表达式（字符串类型, 原始样式字符串）
#     flags: 标志常量（例如只匹配ASCII码, 忽略大小写等）, re.RegexFlag 类中的常量
# 返回: 
#     正则表达式对象 re.Pattern
#
# 得到编译好的正则表达式对象后, 可以用它的 match(), search() 等方法匹配字符串。
re.compile(pattern, flags=0)


# 搜索整个字符串, 找到匹配样式的第一个位置
#
# 参数:
#     pattern: 正则表达式（字符串类型）
#     string: 搜索的字符串
#     flags: 标志常量
# 返回:
#     搜索成功, 则返回 re.Match 对象, 否则返回 None。
#     搜索成功后调用 match.group() 方法可以获取搜索到的内容。
re.search(pattern, string, flags=0)


# 匹配字符串的开头, 函数内部将会把 pattern字符串 编译为 re.Pattern对象, 再进行匹配。
#
# 参数:
#     pattern: 正则表达式（字符串类型）
#     string: 需要匹配的字符串
#     flags: 标志常量
# 返回:
#     匹配成功, 则返回 re.Match 对象, 否则返回 None。
#     匹配成功后调用 match.group() 方法可以获取匹配的内容。
re.match(pattern, string, flags=0)


# 匹配整个字符串
re.fullmatch(pattern, string, flags=0)


# 用 pattern 分开 string, 返回一个由分开后子字符串组成的 列表
re.split(pattern, string, maxsplit=0, flags=0)


# 查找整个字符串, 返回一个不重复的与 pattern 匹配的子字符串列表
re.findall(pattern, string, flags=0)


# 查找整个字符串, 返回一个迭代器, 迭代元素为 re.Match
re.finditer(pattern, string, flags=0)


# string 中匹配 pattern 的子字符串用 repl 替换, count 表示最多替换次数
# count=0表示全部替换, 返回被替换后的字符串。
re.sub(pattern, repl, string, count=0, flags=0)


# 与 re.sub(...) 相同, 返回的是一个元祖 (替换后的字符串, 替换次数)
re.subn(pattern, repl, string, count=0, flags=0)


# 转义 pattern 中的特殊字符。如果想匹配任何可能包含正则表达式元字符的 
# 文本字符串, 可以用该方法先转义正则表达式。
# 例如: re.escape(".+abc") 结果为 "\.\+abc"
# 匹配字符串是否以 ".+abc" 开头: re.match(re.escape(".+abc"), ".+abc123")
re.escape(pattern)


# 清除正则表达式缓存
re.purge()

re.match() 与 re.search() 的区别：前者只匹配字符串开头，后者搜索整个字符串。

标记常量 flags 是 re.RegexFlag 类中的示例，该类继承自 enum.IntFlag，并有多个别名引用。flags 的部分常量:

# 让 \w, \W, \b, \B, \d, \D, \s, \S 只匹配ASCII, 而不是 Unicode
re.A,   re.ASCII,       re.RegexFlag.A,     re.RegexFlag.ASCII

# 匹配时忽略大小写
re.I,   re.IGNORECASE,  re.RegexFlag.I,     re.RegexFlag.IGNORECASE

# 由本地语言区域决定 \w, \W, \b, \B 和 大小写敏感匹配
re.L,   re.LOCALE,      re.RegexFlag.L,     re.RegexFlag.LOCALE

# 样式字符 '^' 和 '$' 除了匹配字符串的开始和结束外, 还匹配每一行的开始和结束
re.M,   re.MULTILINE,   re.RegexFlag.M,     re.RegexFlag.MULTILINE

# 使特殊字符 '.' 匹配换行符, 没有该标记, '.' 只匹配除了换行符以外的其他任意字符
re.S,   re.DOTALL,      re.RegexFlag.S,     re.RegexFlag.DOTALL

# 编译时忽略空白和注释, 设置了该标记后可以在正则表达式的原始样式字符串中添加注释
re.X,   re.VERBOSE,     re.RegexFlag.X,     re.RegexFlag.VERBOSE

标记常量 flags 可以同时设置多个，例如: flags=re.A|re.I

2. 正则表达式对象: re.Pattern

正则表达式对象re.Pattern中的属性和方法（Python官网 Regular Expression Objects）:

Pattern.search(string[, pos[, endpos]])         # 参考 re.search()

Pattern.match(string[, pos[, endpos]])          # 参考 re.match()
Pattern.fullmatch(string[, pos[, endpos]])      # 参考 re.fullmatch()

Pattern.split(string, maxsplit=0)               # 参考 re.split()

Pattern.findall(string[, pos[, endpos]])        # 参考 re.findall()
Pattern.finditer(string[, pos[, endpos]])       # 参考 re.finditer()

Pattern.sub(repl, string, count=0)              # 参考 re.sub()
Pattern.subn(repl, string, count=0)             # 参考 re.subn()

Pattern.pattern                                 # 编译对象的原始样式字符串
Pattern.flags                                   # 正则表达式对象的标志常量
Pattern.groups                                  # 捕获组合的数量
Pattern.groupindex                              # 映射由 (?P<id>) 定义的命名符号组合和数字组合的字典,
                                                # 如果没有符号组, 则该字典为空字典 {}。

3. 匹配对象: re.Match

匹配对象re.Match中的部分属性和方法（Python官网 Match Objects）:

Match.group([group1, ...])  # 返回一个(str)或多个(tuple)匹配的子组, group 默认为 0 表示匹配的整个子串
Match.groups(default=None)  # 返回一个元祖, 包含了所有匹配的子组

Match.start([group])    # 返回 group 匹配到的子字符串的开始位置, group 默认为 0 表示匹配的整个子串
Match.end([group])      # 返回 group 匹配到的子字符串的结束位置, group 默认为 0 表示匹配的整个子串

Match.span([group])     # 返回一个元祖 (m.start(group), m.end(group))

Match.re                # 产生该匹配对象 的 正则表达式对象
Match.string            # 产生该匹配对象 的 中的原待匹配字符串

代码示例:

>>> import re
>>> m = re.search("(\\w+)_(\\w+)", "xx aa_bb yy")
>>> 
>>> m.group()           # 匹配的整个子串
'aa_bb'
>>> m.group(0)          # 匹配的整个子串
'aa_bb'
>>> m.group(1)          # 第1个匹配组(带圆括号的组)匹配的子串
'aa'
>>> m.group(2)          # 第2个匹配组 匹配的子串
'bb'
>>> m.group(1, 2)       # 第1、2个匹配组 匹配的子串组成的元祖
('aa', 'bb')
>>> m.groups()          # 所有匹配组 匹配的子串组成的元祖
('aa', 'bb')
>>> 
>>> m.start()           # 匹配的整个子串 在 原字符串中的 开始 位置
3
>>> m.start(0)          # 匹配的整个子串 在原字符串中的 开始 位置
3
>>> m.start(2)          # 第2个匹配组 匹配的子串 在原字符串中的 开始 位置
6
>>> m.end(1)            # 第1个匹配组 匹配的子串 在原字符串中的 结束 位置（下一个位置的索引）
5
>>> m.span()            # 匹配的整个子串 在原字符串中的 开始 和 结束 位置
(3, 8)
>>> m.span(0)           # 匹配的整个子串 在原字符串中的 开始 和 结束 位置
(3, 8)
>>> m.span(1)           # 第1个匹配组 匹配的子串 在原字符串中的 开始 和 结束 位置
(3, 5)
>>> 
>>> m.re                        # 产生该匹配对象 的 正则表达式对象
re.compile('(\\w+)_(\\w+)')
>>> m.string                    # 产生该匹配对象 的 中的原待匹配字符串
'xx aa_bb yy'

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。