Regex - README

介绍

此正则表达式实现的向后兼容标准 're' 模块，但提供了附加功能。

Python 2

Python 2 已不再支持。最后一个支持 Python 2 的版本是 2021.11.10。

PyPy

此模块的目标是 CPython。它期望所有代码点具有相同的宽度，因此它在 U+0000..U+007F 之外的 PyPy 上行为不当，因为 PyPy 将字符串存储为 UTF-8。

多线程

regex 模块在匹配内置（不可变）字符串类的实例时会释放 GIL，从而允许其他 Python 线程并发运行。也可以通过调用匹配方法并带有关键字参数 concurrent=True 来强制 regex 模块在匹配期间释放 GIL。如果字符串在匹配期间发生更改，行为未定义，因此**仅**在确定不会发生这种情况时使用它。

Unicode

此模块支持 Unicode 17.0.0。支持完整的 Unicode 大小写折叠。

标志

有两种标志：作用域标志和全局标志。作用域标志仅适用于模式的一部分，可以打开或关闭；全局标志适用于整个模式，只能打开。

作用域标志为：ASCII (?a), FULLCASE (?f), IGNORECASE (?i), LOCALE (?L), MULTILINE (?m), DOTALL (?s), UNICODE (?u), VERBOSE (?x), WORD (?w)。

全局标志为：BESTMATCH (?b), ENHANCEMATCH (?e), POSIX (?p), REVERSE (?r), VERSION0 (?V0), VERSION1 (?V1)。

如果未指定 ASCII、LOCALE 或 UNICODE 标志中的任何一个，如果正则表达式模式是 Unicode 字符串，则默认为 UNICODE；如果是字节串，则默认为 ASCII。

ENHANCEMATCH 标志使模糊匹配尝试改进其找到的下一个匹配项。

BESTMATCH 标志使模糊匹配搜索最佳匹配项而不是下一个匹配项。

旧行为与新行为

为了与 re 模块兼容，此模块有两种行为：

版本 0 行为（旧行为，与 re 模块兼容）：

请注意，re 模块的行为可能会随着时间的推移而改变，我将努力在版本 0 中匹配该行为。
- 由 VERSION0 标志指示。
- 在 Python 3.7 之前的 re 模块中，零宽度匹配未正确处理。这些早期版本中的行为是：
  - .split 不会在零宽度匹配处拆分字符串。
  - .sub 在零宽度匹配后会前进一个字符。
- 内联标志适用于整个模式，并且无法关闭。
- 仅支持简单集。
- Unicode 中的不区分大小写匹配默认使用简单的ケース折り返し。
版本 1 行为（新行为，可能与 re 模块不同）：
- 由 VERSION1 标志指示。
- 零宽度匹配已正确处理。
- 内联标志适用于组或模式的末尾，并且可以关闭。
- 支持嵌套集和集合运算。
- Unicode 中的不区分大小写匹配默认使用完整的大小写折叠。

如果未指定版本，regex 模块将默认为 regex.DEFAULT_VERSION。

Unicode 中的不区分大小写匹配

regex 模块支持 Unicode 中不区分大小写匹配的简单和完整大小写折叠。可以使用 FULLCASE 标志打开完整大小写折叠的使用。请注意，此标志会影响 IGNORECASE 标志的工作方式；FULLCASE 标志本身不会启用不区分大小写匹配。

版本 0 行为：默认情况下该标志处于关闭状态。

版本 1 行为：默认情况下该标志处于开启状态。

嵌套集和集合运算

由于在集合中未转义的 "[" 的含义不同，因此无法同时支持 re 模块中使用的简单集和嵌套集。

例如，模式 [[a-z]--[aeiou]] 在版本 0 行为（简单集，与 re 模块兼容）中被视为：

包含 "[" 和字母 "a" 到 "z" 的集合
字面量 "--"
包含字母 "a"、"e"、"i"、"o"、"u" 的集合
字面量 "]"

但在版本 1 行为（嵌套集，增强行为）中被视为：

一个集合，它：
- 包含字母 "a" 到 "z" 的集合
但不包括：
- 包含字母 "a"、"e"、"i"、"o"、"u" 的集合

版本 0 行为：仅支持简单集。

版本 1 行为：支持嵌套集和集合运算。

关于命名组的说明

所有组都有一个组编号，从 1 开始。

具有相同组名的组将具有相同的组编号，具有不同组名的组将具有不同的组编号。

同一个名称可以被多个组使用，后面的捕获会“覆盖”前面的捕获。组的所有捕获都可以从匹配对象的 captures 方法中获得。

组编号会在不同的分支重置之间重复使用，例如 (?|(first)|(second)) 只有组 1。如果组有不同的组名，那么它们自然会有不同的组编号，例如 (?|(?P<foo>first)|(?P<bar>second)) 有组 1（“foo”）和组 2（“bar”）。

在正则表达式 (\s+)(?|(?P<foo>[A-Z]+)|(\w+) (?P<foo>[0-9]+) 中，有 2 个组：

(\s+) 是组 1。
(?P<foo>[A-Z]+) 是组 2，也称为“foo”。
(\w+) 由于分支重置是组 2。
(?P<foo>[0-9]+) 是组 2，因为它被称为“foo”。

如果你想阻止 (\w+) 成为组 2，你需要给它命名（不同的名称，不同的组编号）。

附加功能

除非另有说明，否则问题编号均指 Python 错误跟踪器。

添加了 `\p{Horiz_Space}` 和 `\p{Vert_Space}` (GitHub issue 477)

\p{Horiz_Space} 或 \p{H} 匹配水平空白字符，而 \p{Vert_Space} 或 \p{V} 匹配垂直空白字符。

在条件模式中添加了对前瞻/后顾的支持 (Hg issue 163)

条件模式的测试可以是前瞻/后顾。

>>> regex.match(r'(?(?=\d)\d+|\w+)', '123abc')
<regex.Match object; span=(0, 3), match='123'>
>>> regex.match(r'(?(?=\d)\d+|\w+)', 'abc123')
<regex.Match object; span=(0, 6), match='abc123'>

这与将前瞻/后顾放在选择项对的第一个分支中并不完全相同。

>>> print(regex.match(r'(?:(?=\d)\d+\b|\w+)', '123abc'))
<regex.Match object; span=(0, 6), match='123abc'>
>>> print(regex.match(r'(?(?=\d)\d+\b|\w+)', '123abc'))
None

在第一个示例中，前瞻/后顾匹配成功，但第一个分支的其余部分未能匹配，因此尝试了第二个分支；而在第二个示例中，前瞻/后顾匹配成功，第一个分支未能匹配，但第二个分支没有被尝试。

添加了 POSIX 匹配（最左最长）(Hg issue 150)

POSIX 标准的正则表达式是返回最左边的最长匹配。这可以通过设置 POSIX 标志来开启。

>>> # 正常匹配。
>>> regex.search(r'Mr|Mrs', 'Mrs')
<regex.Match object; span=(0, 2), match='Mr'>
>>> regex.search(r'one(self)?(selfsufficient)?', 'oneselfsufficient')
<regex.Match object; span=(0, 7), match='oneself'>
>>> # POSIX 匹配。
>>> regex.search(r'(?p)Mr|Mrs', 'Mrs')
<regex.Match object; span=(0, 3), match='Mrs'>
>>> regex.search(r'(?p)one(self)?(selfsufficient)?', 'oneselfsufficient')
<regex.Match object; span=(0, 17), match='oneselfsufficient'>

注意，这会花费更长的时间来找到匹配，因为当它在某个位置找到一个匹配时，它不会立即返回，而是会继续查找是否存在另一个更长的匹配。

添加了 `(?(DEFINE)...)` (Hg issue 152)

如果没有名为“DEFINE”的组，则 ... 将被忽略，但其中定义的任何组都可以被调用，并且分组的编号规则仍然适用。

>>> regex.search(r'(?(DEFINE)(?P<quant>\d+)(?P<item>\w+))(?&quant) (?&item)', '5 elephants')
<regex.Match object; span=(0, 11), match='5 elephants'>

添加了 `(PRUNE)`、`(SKIP)` 和 `(*FAIL)`（Hg issue 153）

(*PRUNE) 会丢弃到该点的所有回溯信息。当在原子组或lookaround中使用时，它不会影响外部模式。

(*SKIP) 与 (*PRUNE) 类似，但它还会设置下一次匹配尝试的起始位置。当在原子组或lookaround中使用时，它不会影响外部模式。

(*FAIL) 会立即导致回溯。(*F) 是允许的缩写。

添加了 `\K`（Hg issue 151）

\K 会保留整个匹配中 \K 出现位置之后的部分；之前的部分会被丢弃。

它不影响组的返回值。

>>> m = regex.search(r'(\w\w\K\w\w\w)', 'abcdef')
>>> m[0]
'cde'
>>> m[1]
'abcde'
>>>
>>> m = regex.search(r'(?r)(\w\w\K\w\w\w)', 'abcdef')
>>> m[0]
'bc'
>>> m[1]
'bcdef'

为 `expandf` 和 `subf`/`subfn` 添加了捕获组下标（Hg issue 133）

您可以使用下标来获取重复组的捕获结果。

>>> m = regex.match(r"(\w)+", "abc")
>>> m.expandf("{1}")
'c'
>>> m.expandf("{1[0]} {1[1]} {1[2]}")
'a b c'
>>> m.expandf("{1[-1]} {1[-2]} {1[-3]}")
'c b a'
>>>
>>> m = regex.match(r"(?P<letter>\w)+", "abc")
>>> m.expandf("{letter}")
'c'
>>> m.expandf("{letter[0]} {letter[1]} {letter[2]}")
'a b c'
>>> m.expandf("{letter[-1]} {letter[-2]} {letter[-3]}")
'c b a'

添加了使用 `(?P=...)` 按编号引用组的支持

这补充了现有的 \g<...>。

修正了对区域设置敏感正则表达式的处理

LOCALE 标志是为遗留代码准备的，支持有限。仍然建议使用 Unicode。

添加了部分匹配（Hg issue 102）

部分匹配是指一个匹配在字符串末尾结束，但该字符串已被截断，并且您想知道如果字符串未被截断，是否可能完成匹配。

部分匹配通过带有 `partial` 关键字参数的 match、search、fullmatch 和 finditer 来支持。

匹配对象有一个 `partial` 属性，如果它是部分匹配，则为 True。

例如，如果您希望用户输入一个 4 位数字，并在输入过程中逐个字符地检查它：

>>> pattern = regex.compile(r'\d{4}')

>>> # 最初，什么都还没输入：
>>> print(pattern.fullmatch('', partial=True))
<regex.Match object; span=(0, 0), match='', partial=True>

>>> # 空字符串是可以的，但它只是一个部分匹配。
>>> # 用户输入了一个字母：
>>> print(pattern.fullmatch('a', partial=True))
None
>>> # 永远不会匹配。

>>> # 用户删除了那个字母，然后输入了一个数字：
>>> print(pattern.fullmatch('1', partial=True))
<regex.Match object; span=(0, 1), match='1', partial=True>
>>> # 到这里匹配了，但只是部分匹配。

>>> # 用户输入了另外两个数字：
>>> print(pattern.fullmatch('123', partial=True))
<regex.Match object; span=(0, 3), match='123', partial=True>
>>> # 到这里匹配了，但只是部分匹配。

>>> # 用户输入了另一个数字：
>>> print(pattern.fullmatch('1234', partial=True))
<regex.Match object; span=(0, 4), match='1234'>
>>> # 这是一个完整匹配。

>>> # 如果用户输入了另一个数字：
>>> print(pattern.fullmatch('12345', partial=True))
None
>>> # 已经不再是匹配了。

>>> # 这是一个部分匹配：
>>> pattern.match('123', partial=True).partial
True

>>> # 这是一个完整匹配：
>>> pattern.match('1233', partial=True).partial
False

`*` 运算符与 sub() 配合不正常 (Hg issue 106)

有时我们不清楚零宽度匹配应该如何处理。例如，.* 在匹配了 >0 个字符之后，是否还应该匹配 0 个字符？

>>> regex.sub('.*', 'x', 'test')
'xx'
>>> regex.sub('.*?', '|', 'test')
'|||||||||'

添加了 `capturesdict` (Hg issue 86)

capturesdict 是 groupdict 和 captures 的组合：

groupdict 返回一个包含命名分组及其 last capture（最后一次捕获）的字典。

captures 返回一个包含分组所有 capture 的列表。

capturesdict 返回一个包含命名分组及其所有 capture 列表的字典。

>>> m = regex.match(r"(?:(?P<word>\w+) (?P<digits>\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
>>> m.groupdict()
{'word': 'three', 'digits': '3'}
>>> m.captures("word")
['one', 'two', 'three']
>>> m.captures("digits")
['1', '2', '3']
>>> m.capturesdict()
{'word': ['one', 'two', 'three'], 'digits': ['1', '2', '3']}

添加了 `allcaptures` 和 `allspans` (Git issue 474)

allcaptures 返回一个包含所有分组所有 captures 的列表。

allspans 返回一个包含所有分组所有 captures 的 span 的列表。

>>> m = regex.match(r"(?:(?P<word>\w+) (?P<digits>\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
>>> m.allcaptures()
(['one 1\ntwo 2\nthree 3\n'], ['one', 'two', 'three'], ['1', '2', '3'])
>>> m.allspans()
([(0, 20)], [(0, 3), (6, 9), (12, 17)], [(4, 5), (10, 11), (18, 19)])

允许重复的组名 (Hg issue 87)

组名可以重复。

>>> # 使用可选组：
>>>
>>> # 两个组都捕获，第二个捕获会“覆盖”第一个。
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['first', 'second']
>>> # 只有第二个组捕获。
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", " or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['second']
>>> # 只有第一个组捕获。
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or ")
>>> m.group("item")
'first'
>>> m.captures("item")
['first']
>>>
>>> # 使用强制分组：
>>>
>>> # 两个组都捕获，第二个捕获会“覆盖”第一个。
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)?", "first or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['first', 'second']
>>> # 再次，两个组都捕获，第二个捕获会“覆盖”第一个。
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", " or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['', 'second']
>>> # 再次，两个组都捕获，第二个捕获会“覆盖”第一个。
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", "first or ")
>>> m.group("item")
''
>>> m.captures("item")
['first', '']

添加了 `fullmatch` （issue #16203）

fullmatch 的行为类似于 match，但它必须匹配整个字符串。

>>> print(regex.fullmatch(r"abc", "abc").span())
(0, 3)
>>> print(regex.fullmatch(r"abc", "abcx"))
None
>>> print(regex.fullmatch(r"abc", "abcx", endpos=3).span())
(0, 3)
>>> print(regex.fullmatch(r"abc", "xabcy", pos=1, endpos=4).span())
(1, 4)
>>>
>>> regex.match(r"a.*?", "abcd").group(0)
'a'
>>> regex.fullmatch(r"a.*?", "abcd").group(0)
'abcd'

添加了 `subf` 和 `subfn`

subf 和 subfn 是 sub 和 subn 的替代方法。当传入替换字符串时，它们将其视为格式字符串。

>>> regex.subf(r"(\w+) (\w+)", "{0} => {2} {1}", "foo bar")
'foo bar => bar foo'
>>> regex.subf(r"(?P<word1>\w+) (?P<word2>\w+)", "{word2} {word1}", "foo bar")
'bar foo'

向匹配对象添加了 `expandf`

expandf 是 expand 的替代方法。当传入替换字符串时，它将其视为格式字符串。

>>> m = regex.match(r"(\w+) (\w+)", "foo bar")
>>> m.expandf("{0} => {2} {1}")
'foo bar => bar foo'
>>>
>>> m = regex.match(r"(?P<word1>\w+) (?P<word2>\w+)", "foo bar")
>>> m.expandf("{word2} {word1}")
'bar foo'

分离搜索的字符串

匹配对象通过其 string 属性包含对搜索过的字符串的引用。 detach_string 方法将“分离”该字符串，使其可用于垃圾回收，这可以节省宝贵的内存（如果字符串非常大）。

>>> m = regex.search(r"\w+", "Hello world")
>>> print(m.group())
Hello
>>> print(m.string)
Hello world
>>> m.detach_string()
>>> print(m.group())
Hello
>>> print(m.string)
None

递归模式（Hg issue 27）

支持递归和重复模式。

(?R) 或 (?0) 尝试递归匹配整个正则表达式。 (?1), (?2) 等尝试匹配相应的组。

(?&name) 尝试匹配命名组。

>>> regex.match(r"(Tarzan|Jane) loves (?1)", "Tarzan loves Jane").groups()
('Tarzan',)
>>> regex.match(r"(Tarzan|Jane) loves (?1)", "Jane loves Tarzan").groups()
('Jane',)

>>> m = regex.search(r"(\w)(?:(?R)|(\w?))\1", "kayak")
>>> m.group(0, 1, 2)
('kayak', 'k', None)

前两个示例展示了组内的子模式是如何被重用的，但它本身 _不是_ 一个组。换句话说，"(Tarzan|Jane) loves (?1)" 等同于 "(Tarzan|Jane) loves (?:Tarzan|Jane)"。

可以回溯到递归或重复的组。

如果存在多个同名的组或相同组号的组，则无法调用该组（"ambiguous group reference"）。

也支持可选形式 (?P>name) 和 (?P&name)。

支持完整的Unicode大小写折叠

在版本1的行为中，regex模块在进行Unicode不区分大小写匹配时使用完整的Unicode大小写折叠。

>>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LIGATURE SS}*/e").span()
(0, 6)
>>> regex.match(r"(?iV1)stra\N{LATIN SMALL LIGATURE SS}*/e", "STRASSE").span()
(0, 7)

在版本0的行为中，为了向后兼容re模块，它使用简单的大小写折叠。

近似“模糊”匹配（Hg issue 12, Hg issue 41, Hg issue 109）

正则通常会尝试精确匹配，但有时需要近似或“模糊”匹配，以应对文本中可能存在插入、删除或替换字符错误的情况。

模糊正则表达式指定允许的错误类型，并且可以选择性地指定每种类型的最小和最大数量，或仅指定最大数量。（您不能只指定最小值。）

3种错误类型是：

插入，用“i”表示
删除，用“d”表示
替换，用“s”表示

此外，“e”表示任何类型的错误。

正则表达式项的模糊度在项后面的“{”和“}”之间指定。

示例：

foo 精确匹配“foo”
(?:foo){i} 匹配“foo”，允许插入
(?:foo){d} 匹配“foo”，允许删除
(?:foo){s} 匹配“foo”，允许替换
(?:foo){i,s} 匹配“foo”，允许插入和替换
(?:foo){e} 匹配“foo”，允许错误

如果指定了某种类型的错误，那么未指定的任何类型将不被允许。

在以下示例中，我将省略匹配项，只写模糊度：

{d<=3} 允许最多3次删除，但不允许其他任何类型
{i<=1,s<=2} 允许最多1次插入和最多2次替换，但不允许删除
{1<=e<=3} 允许至少1次且最多3次错误
{i<=2,d<=2,e<=3} 允许最多2次插入，最多2次删除，最多3次总错误，但不允许替换

还可以指定每种错误类型的成本以及允许的最大总成本。

示例：

{2i+2d+1s<=4} 每次插入花费2，每次删除花费2，每次替换花费1，总成本不得超过4
{i<=1,d<=1,s<=1,2i+2d+1s<=4} 最多1次插入，最多1次删除，最多1次替换；每次插入花费2，每次删除花费2，每次替换花费1，总成本不得超过4

您也可以使用“<”代替“<=”来表示独占的最小值或最大值。

您可以添加一个测试来对被替换或插入的字符执行操作。

示例：

{s<=2:[a-z]} 最多2次替换，这些替换必须是字符集[a-z]中的字符。
{s<=2,i<=3:\d} 最多2次替换，最多3次插入，这些插入必须是数字。

默认情况下，模糊匹配会查找满足给定约束的第一个匹配项。ENHANCEMATCH 标志将使其尝试改进匹配项（即减少错误数量）的契合度。

BESTMATCH 标志将使其改为搜索最佳匹配项。

更多需要注意的示例：

regex.search("(dog){e}", "cat and dog")[1] 返回"cat"，因为其与"dog"匹配，有3次错误（允许无限数量的错误）。
regex.search("(dog){e<=1}", "cat and dog")[1] 返回" dog"（带前导空格），因为其与"dog"匹配，有1次错误，在允许范围内。
regex.search("(?e)(dog){e<=1}", "cat and dog")[1] 返回"dog"（无前导空格），因为模糊搜索匹配" dog"，有1次错误，在允许范围内，并且(?e)然后尝试一个更好的匹配。

在前两个示例中，字符串后面存在完美的匹配，但在两种情况下都不是第一个可能的匹配。

匹配对象有一个名为fuzzy_counts的属性，它提供了替换、插入和删除的总数。

>>> # 一个“原始”模糊匹配：
>>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 1)
>>> # 0次替换，0次插入，1次删除。

>>> # 如果使用ENHANCEMATCH标志，可能会有更好的匹配：
>>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 0)
>>> # 0次替换，0次插入，0次删除。

匹配对象还有一个名为fuzzy_changes的属性，它给出了替换、插入和删除的位置元组。

>>> m = regex.search('(fuu){i<=2,d<=2,e<=5}', 'anaconda foo bar')
>>> m
<regex.Match object; span=(7, 10), match='a f', fuzzy_counts=(0, 2, 2)>
>>> m.fuzzy_changes
([], [7, 8], [10, 11])

这意味着，如果匹配字符串的一部分是：

'anacondfuuoo bar'

原本会完全匹配。

然而，在位置 7 和 8 处发生了插入：

'anaconda fuuoo bar'
        ^^

在位置 10 和 11 处发生了删除：

'anaconda f~~oo bar'
           ^^

所以实际的字符串是：

'anaconda foo bar'

命名列表 `\L<name>` (Hg issue 11)

有时您可能希望在正则表达式中包含一个选项列表（实际上是一个集合）。

一种方法是像这样构建模式：

>> p = regex.compile(r"first|second|third|fourth|fifth")

但如果列表很大，解析生成的正则表达式可能需要很长时间，并且还必须小心确保字符串被正确转义并正确排序，例如，“cats”排在“cat”前面。

新的选择是使用命名列表：

>> option_set = ["first", "second", "third", "fourth", "fifth"]
>> p = regex.compile(r"\L<options>", options=option_set)

项目的顺序无关紧要，它们被视为一个集合。命名列表可从此模式对象的 .named_lists 属性访问：

>> print(p.named_lists)
{'options': frozenset({'third', 'first', 'fifth', 'fourth', 'second'})}

如果存在任何未使用的关键字参数，除非您另行指定，否则将引发 ValueError：

>> option_set = ["first", "second", "third", "fourth", "fifth"]
>> p = regex.compile(r"\L<options>", options=option_set, other_options=[])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
    return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
  File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
    complain_unused_args()
  File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
    raise ValueError('unused keyword argument {!a}'.format(any_one))
ValueError: unused keyword argument 'other_options'
>> p = regex.compile(r"\L<options>", options=option_set, other_options=[], ignore_unused=True)
>> p = regex.compile(r"\L<options>", options=option_set, other_options=[], ignore_unused=False)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
    return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
  File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
    complain_unused_args()
  File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
    raise ValueError('unused keyword argument {!a}'.format(any_one))
ValueError: unused keyword argument 'other_options'
>>

单词的开头和结尾

\m 匹配单词的开头。

\M 匹配单词的结尾。

请与 \b 比较，它匹配单词的开头或结尾。

Unicode 行分隔符

通常唯一的行分隔符是 \n (\x0A)，但如果开启了 WORD 标志，那么行分隔符在处理 Unicode 时将是 \x0D\x0A、\x0A、\x0B、\x0C 和 \x0D，外加 \x85、\u2028 和 \u2029。

这会影响正则表达式的点 "."，在 DOTALL 标志关闭的情况下，它匹配除行分隔符以外的任何字符。它还会影响行锚点 ^ 和 $ (在多行模式下)。

集合运算符

仅限 Version 1 的行为

已添加集合运算符，并且集合 [...] 可以包含嵌套的集合。

运算符按优先级升序排列：

|| 用于并集（"x||y" 表示 "x 或 y"）
~~（双波浪线）用于对称差集（"x~~y" 表示 "x 或 y，但不同时是两者"）
&& 用于交集（"x&&y" 表示 "x 和 y"）
--（双连字符）用于差集（"x--y" 表示 "x 但不是 y"）

隐式并集，即简单的并列，如 [ab]，优先级最高。因此，[ab&&cd] 与 [[a||b]&&[c||d]] 相同。

示例：

[ab] # 包含 'a' 和 'b' 的集合
[a-z] # 包含 'a' .. 'z' 的集合
[[a-z]--[qw]] # 包含 'a' .. 'z' 的集合，但不包含 'q' 或 'w'
[a-z--qw] # 与上面相同
[\p{L}--QW] # 包含所有字母但不包含 'Q' 和 'W' 的集合
[\p{N}--[0-9]] # 包含所有数字但不包含 '0' .. '9' 的集合
[\p{ASCII}&&\p{Letter}] # 包含所有既是 ASCII 又是字母的字符的集合

regex.escape (issue #2650)

regex.escape 有一个额外的关键字参数 special_only。当为 True 时，仅转义 'special' 正则表达式字符，如 '?'。

>>> regex.escape("foo!?", special_only=False)
'foo\\!\\?'
>>> regex.escape("foo!?", special_only=True)
'foo!\\?'

regex.escape (Hg issue 249)

regex.escape 有一个额外的关键字参数 literal_spaces。当为 True 时，空格不会被转义。

>>> regex.escape("foo bar!?", literal_spaces=False)
'foo\\ bar!\\?'
>>> regex.escape("foo bar!?", literal_spaces=True)
'foo bar!\\?'

重复捕获 (issue #7132)

匹配对象有额外的方法，这些方法返回有关重复组所有成功匹配的信息。这些方法是：

matchobject.captures([group1, ...])
- 返回捕获组或捕获组中的字符串列表。与 matchobject.group([group1, ...]) 比较。
matchobject.starts([group])
- 返回起始位置列表。与 matchobject.start([group]) 比较。
matchobject.ends([group])
- 返回结束位置列表。与 matchobject.end([group]) 比较。
matchobject.spans([group])
- 返回跨度列表。与 matchobject.span([group]) 比较。

>>> m = regex.search(r"(\w{3})+", "123456789")
>>> m.group(1)
'789'
>>> m.captures(1)
['123', '456', '789']
>>> m.start(1)
6
>>> m.starts(1)
[0, 3, 6]
>>> m.end(1)
9
>>> m.ends(1)
[3, 6, 9]
>>> m.span(1)
(6, 9)
>>> m.spans(1)
[(0, 3), (3, 6), (6, 9)]

原子分组 `(?>...)` (issue #433030)

如果随后的模式失败，则整个子模式将失败。

贪婪量词

(?:...)?+ ; (?:...)*+ ; (?:...)++ ; (?:...){min,max}+

子模式最多匹配 'max' 次。如果随后的模式失败，则所有重复的子模式将整体失败。例如，(?:...)++ 等价于 (?>(?:...)+)。

作用域标志 (issue #433028)

(flags-flags:...)

标志仅适用于子模式。标志可以打开或关闭。

“单词”字符的定义 (issue #1693050)

Unicode 的“单词”字符定义已扩展。它符合 http://www.unicode.org/reports/tr29/ 上的 Unicode 规范。

变长后行断言

后行断言可以匹配变长字符串。

regex.split, regex.sub 和 regex.subn 的 flags 参数 (issue #3482)

regex.split, regex.sub 和 regex.subn 支持 'flags' 参数。

regex.sub 和 regex.subn 的 pos 和 endpos 参数

regex.sub 和 regex.subn 支持 'pos' 和 'endpos' 参数。

regex.findall 和 regex.finditer 的 'overlapped' 参数

regex.findall 和 regex.finditer 支持 'overlapped' 标志，该标志允许重叠匹配。

Splititer

已添加 regex.splititer。它是 regex.split 的生成器等效项。

通过下标访问匹配对象以获取组

匹配对象可以通过下标和切片访问组：

>>> m = regex.search(r"(?P<before>.*?)(?P<num>\d+)(?P<after>.*)", "pqr123stu")
>>> print(m["before"])
pqr
>>> print(len(m))
4
>>> print(m[:])
('pqr123stu', 'pqr', '123', 'stu')

命名组

组可以使用 (?<name>...) 和现有的 (?P<name>...) 进行命名。

组引用

可以使用 \g<name> 在模式内引用组。这还允许存在超过 99 个组。

命名字符 `\N{name}`

支持命名字符。请注意，只有 Python 的 Unicode 数据库已知的名称才会被识别。

Unicode 码点属性，包括脚本和块

\p{property=value}; \P{property=value}; \p{value} ; \P{value}

支持许多 Unicode 属性，包括块和脚本。\p{property=value} 或 \p{property:value} 匹配属性 property 值为 value 的字符。\p{property=value} 的反义是 \P{property=value} 或 \p{^property=value}。

如果使用短形式 \p{value}，则按以下顺序检查属性：General_Category、Script、Block、二元属性：

Latin，'Latin' 脚本（Script=Latin）。
BasicLatin，'BasicLatin' 块（Block=BasicLatin）。
Alphabetic，'Alphabetic' 二元属性（Alphabetic=Yes）。

以 Is 开头的短形式表示脚本或二元属性：

IsLatin，'Latin' 脚本（Script=Latin）。
IsAlphabetic，'Alphabetic' 二元属性（Alphabetic=Yes）。

以 In 开头的短形式表示块属性：

InBasicLatin，'BasicLatin' 块（Block=BasicLatin）。

POSIX 字符类

[[:alpha:]]; [[:^alpha:]]

支持 POSIX 字符类。这些通常被视为 \p{...} 的另一种形式。

例外是 alnum、digit、punct 和 xdigit，它们的定义与 Unicode 不同。

[[:alnum:]] 等同于 \p{posix_alnum}。

[[:digit:]] 等同于 \p{posix_digit}。

[[:punct:]] 等同于 \p{posix_punct}。

[[:xdigit:]] 等同于 \p{posix_xdigit}。

搜索锚点 `\G`

已添加搜索锚点。它匹配每次搜索开始/继续的位置，并可用于连续匹配或在负向可变长度后行断言中限制后行断言的回溯距离：

>>> regex.findall(r"\w{2}", "abcd ef")
['ab', 'cd', 'ef']
>>> regex.findall(r"\G\w{2}", "abcd ef")
['ab', 'cd']

搜索从位置 0 开始并匹配 'ab'。
搜索在位置 2 继续并匹配 'cd'。
搜索在位置 4 继续，但未能匹配任何字母。
锚点阻止了搜索起始位置的前进，因此没有更多结果。

反向搜索

搜索也可以反向进行：

>>> regex.findall(r".", "abc")
['a', 'b', 'c']
>>> regex.findall(r"(?r).", "abc")
['c', 'b', 'a']

请注意，反向搜索的结果不一定是正向搜索的逆序：

>>> regex.findall(r"..", "abcde")
['ab', 'cd']
>>> regex.findall(r"(?r)..", "abcde")
['de', 'bc']

匹配单个字素 `\X`

支持字素匹配器。它符合 http://www.unicode.org/reports/tr29/ 上的 Unicode 规范。

分支重置 `(?|...|...)`

组号将在各个备选项之间重用，但具有不同名称的组将具有不同的组号。

>>> regex.match(r"(?|(first)|(second))", "first").groups()
('first',)
>>> regex.match(r"(?|(first)|(second))", "second").groups()
('second',)

请注意，只有一个组。

默认 Unicode 单词边界

WORD 标志将“单词边界”的定义更改为默认 Unicode 单词边界。这适用于 \b 和 \B。

超时

匹配方法和函数支持超时。超时（以秒为单位）适用于整个操作：

>>> from time import sleep
>>>
>>> def fast_replace(m):
...     return 'X'
...
>>> def slow_replace(m):
...     sleep(0.5)
...     return 'X'
...
>>> regex.sub(r'[a-z]', fast_replace, 'abcde', timeout=2)
'XXXXX'
>>> regex.sub(r'[a-z]', slow_replace, 'abcde', timeout=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python310\lib\site-packages\regex\regex.py", line 278, in sub
    return pat.sub(repl, string, count, pos, endpos, concurrent, timeout)
TimeoutError: regex timed out

介绍