同步操作将从 openKylin(孵化期)/python-regex 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality.
The re module's behaviour with zero-width matches changed in Python 3.7, and this module follows that behaviour when compiled for Python 3.7.
Python 2 is no longer supported. The last release that supported Python 2 was 2021年11月10日.
This module is targeted at CPython. It expects that all codepoints are the same width, so it won't behave properly with PyPy outside U+0000..U+007F because PyPy stores strings as UTF-8.
The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument concurrent=True. The behaviour is undefined if the string changes during matching, so use it only when it is guaranteed that that won't happen.
This module supports Unicode 15.0.0. Full Unicode case-folding is supported.
There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.
The scoped flags are: ASCII (?a), FULLCASE (?f), IGNORECASE (?i), LOCALE (?L), MULTILINE (?m), DOTALL (?s), UNICODE (?u), VERBOSE (?x), WORD (?w).
The global flags are: BESTMATCH (?b), ENHANCEMATCH (?e), POSIX (?p), REVERSE (?r), VERSION0 (?V0), VERSION1 (?V1).
If neither the ASCII, LOCALE nor UNICODE flag is specified, it will default to UNICODE if the regex pattern is a Unicode string and ASCII if it's a bytestring.
The ENHANCEMATCH flag makes fuzzy matching attempt to improve the fit of the next match that it finds.
The BESTMATCH flag makes fuzzy matching search for the best match instead of the next match.
In order to be compatible with the re module, this module has 2 behaviours:
Version 0 behaviour (old behaviour, compatible with the re module):
Please note that the re module's behaviour may change over time, and I'll endeavour to match that behaviour in version 0.
VERSION0 flag..split won't split a string at a zero-width match..sub will advance by one character after a zero-width match.Version 1 behaviour (new behaviour, possibly different from the re module):
VERSION1 flag.If no version is specified, the regex module will default to regex.DEFAULT_VERSION.
The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the FULLCASE flag. Please note that this flag affects how the IGNORECASE flag works; the FULLCASE flag itself does not turn on case-insensitive matching.
Version 0 behaviour: the flag is off by default.
Version 1 behaviour: the flag is on by default.
It's not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped "[" in a set.
For example, the pattern [[a-z]--[aeiou]] is treated in the version 0 behaviour (simple sets, compatible with the re module) as:
but in the version 1 behaviour (nested sets, enhanced behaviour) as:
Version 0 behaviour: only simple sets are supported.
Version 1 behaviour: nested sets and set operations are supported.
All groups have a group number, starting from 1.
Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.
The same name can be used by more than one group, with later captures 'overwriting' earlier captures. All the captures of the group will be available from the captures method of the match object.
Group numbers will be reused across different branches of a branch reset, eg. (?|(first)|(second)) has only group 1. If groups have different group names then they will, of course, have different group numbers, eg. (?|(?P<foo>first)|(?P<bar>second)) has group 1 ("foo") and group 2 ("bar").
In the regex (\s+)(?|(?P<foo>[A-Z]+)|(\w+) (?P<foo>[0-9]+) there are 2 groups:
(\s+) is group 1.(?P<foo>[A-Z]+) is group 2, also called "foo".(\w+) is group 2 because of the branch reset.(?P<foo>[0-9]+) is group 2 because it's called "foo".If you want to prevent (\w+) from being group 2, you need to name it (different name, different group number).
The issue numbers relate to the Python bug tracker, except where listed otherwise.
\p{Horiz_Space} and \p{Vert_Space} (Added support for lookaround in conditional pattern (
>>> 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'>
This is not quite the same as putting a lookaround in the first branch of a pair of alternatives.
>>> 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
In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was not attempted.
Note that it will take longer to find matches because when it finds a match at a certain position, it won't return that immediately, but will keep looking to see if there's another longer match there.
(?(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) and (*FAIL) (Added \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 and subf/subfn (
>>> 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=...)
This is in addition to the existing \g<...>.
The LOCALE flag is intended for legacy code and has limited support. You're still recommended to use Unicode instead.
* operator not working correctly with sub() (
# Python 3.7 and later
>>> regex.sub('.*', 'x', 'test')
'xx'
>>> regex.sub('.*?', '|', 'test')
'|||||||||'
# Python 3.6 and earlier
>>> regex.sub('(?V0).*', 'x', 'test')
'x'
>>> regex.sub('(?V1).*', 'x', 'test')
'xx'
>>> regex.sub('(?V0).*?', '|', 'test')
'|t|e|s|t|'
>>> regex.sub('(?V1).*?', '|', 'test')
'|||||||||'
capturesdict (
>>> 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 and allspans (
>>> 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)])
fullmatch (
>>> 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 and subfn
subf and subfn are alternatives to sub and subn respectively. When passed a replacement string, they treat it as a format string.
>>> 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 to match objectexpandf is an alternative to expand. When passed a replacement string, it treats it as a format string.
>>> 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'
A match object contains a reference to the string that was searched, via its string attribute. The detach_string method will 'detach' that string, making it available for garbage collection, which might save valuable memory if that string is very large.
>>> 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
The first two examples show how the subpattern within the group is reused, but is _not_ itself a group. In other words, "(Tarzan|Jane) loves (?1)" is equivalent to "(Tarzan|Jane) loves (?:Tarzan|Jane)".
It's possible to backtrack into a recursed or repeated group.
You can't call a group if there is more than one group with that group name or group number ("ambiguous group reference").
The alternative forms (?P>name) and (?P&name) are also supported.
In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode.
>>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LETTER SHARP S}e").span()
(0, 6)
>>> regex.match(r"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e", "STRASSE").span()
(0, 7)
In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module.
A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.)
The 3 types of error are:
In addition, "e" indicates any type of error.
The fuzziness of a regex item is specified between "{" and "}" after the item.
Examples:
foo match "foo" exactly(?:foo){i} match "foo", permitting insertions(?:foo){d} match "foo", permitting deletions(?:foo){s} match "foo", permitting substitutions(?:foo){i,s} match "foo", permitting insertions and substitutions(?:foo){e} match "foo", permitting errorsIf a certain type of error is specified, then any type not specified will not be permitted.
In the following examples I'll omit the item and write only the fuzziness:
{d<=3} permit at most 3 deletions, but no other types{i<=1,s<=2} permit at most 1 insertion and at most 2 substitutions, but no deletions{1<=e<=3} permit at least 1 and at most 3 errors{i<=2,d<=2,e<=3} permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutionsIt's also possible to state the costs of each type of error and the maximum permitted total cost.
Examples:
{2i+2d+1s<=4} each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4{i<=1,d<=1,s<=1,2i+2d+1s<=4} at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4You can also use "<" instead of "<=" if you want an exclusive minimum or maximum.
You can add a test to perform on a character that's substituted or inserted.
Examples:
{s<=2:[a-z]} at most 2 substitutions, which must be in the character set [a-z].{s<=2,i<=3:\d} at most 2 substitutions, at most 3 insertions, which must be digits.By default, fuzzy matching searches for the first match that meets the given constraints. The ENHANCEMATCH flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found.
The BESTMATCH flag will make it search for the best match instead.
Further examples to note:
regex.search("(dog){e}", "cat and dog")[1] returns "cat" because that matches "dog" with 3 errors (an unlimited number of errors is permitted).regex.search("(dog){e<=1}", "cat and dog")[1] returns " dog" (with a leading space) because that matches "dog" with 1 error, which is within the limit.regex.search("(?e)(dog){e<=1}", "cat and dog")[1] returns "dog" (without a leading space) because the fuzzy search matches " dog" with 1 error, which is within the limit, and the (?e) then it attempts a better fit.In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match.
The match object has an attribute fuzzy_counts which gives the total number of substitutions, insertions and deletions.
>>> # A 'raw' fuzzy match:
>>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 1)
>>> # 0 substitutions, 0 insertions, 1 deletion.
>>> # A better match might be possible if the ENHANCEMATCH flag used:
>>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 0)
>>> # 0 substitutions, 0 insertions, 0 deletions.
The match object also has an attribute fuzzy_changes which gives a tuple of the positions of the substitutions, insertions and deletions.
>>> 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])
What this means is that if the matched part of the string had been:
'anacondfuuoo bar'
it would've been an exact match.
However, there were insertions at positions 7 and 8:
'anaconda fuuoo bar'
^^
and deletions at positions 10 and 11:
'anaconda f~~oo bar'
^^
So the actual string was:
'anaconda foo bar'
\L<name> (
>>> p = regex.compile(r"first|second|third|fourth|fifth")
but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, "cats" before "cat".
The new alternative is to use a named list:
>>> option_set = ["first", "second", "third", "fourth", "fifth"]
>>> p = regex.compile(r"\L<options>", options=option_set)
The order of the items is irrelevant, they are treated as a set. The named lists are available as the .named_lists attribute of the pattern object :
>>> print(p.named_lists)
{'options': frozenset({'third', 'first', 'fifth', 'fourth', 'second'})}
If there are any unused keyword arguments, ValueError will be raised unless you tell it otherwise:
>>> 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 matches at the start of a word.
\M matches at the end of a word.
Compare with \b, which matches at the start or end of a word.
Normally the only line separator is \n (\x0A), but if the WORD flag is turned on then the line separators are \x0D\x0A, \x0A, \x0B, \x0C and \x0D, plus \x85, \u2028 and \u2029 when working with Unicode.
This affects the regex dot ".", which, with the DOTALL flag turned off, matches any character except a line separator. It also affects the line anchors ^ and $ (in multiline mode).
Version 1 behaviour only
Set operators have been added, and a set [...] can include nested sets.
The operators, in order of increasing precedence, are:
|| for union ("x||y" means "x or y")~~ (double tilde) for symmetric difference ("x~~y" means "x or y, but not both")&& for intersection ("x&&y" means "x and y")-- (double dash) for difference ("x--y" means "x but not y")Implicit union, ie, simple juxtaposition like in [ab], has the highest precedence. Thus, [ab&&cd] is the same as [[a||b]&&[c||d]].
Examples:
[ab] # Set containing 'a' and 'b'[a-z] # Set containing 'a' .. 'z'[[a-z]--[qw]] # Set containing 'a' .. 'z', but not 'q' or 'w'[a-z--qw] # Same as above[\p{L}--QW] # Set containing all letters except 'Q' and 'W'[\p{N}--[0-9]] # Set containing all numbers except '0' .. '9'[\p{ASCII}&&\p{Letter}] # Set containing all characters which are ASCII and letter(?>...) (Possessive quantifiers(?:...)?+ ; (?:...)*+ ; (?:...)++ ; (?:...){min,max}+
The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all the repeated subpatterns will fail as a whole. For example, (?:...)++ is equivalent to (?>(?:...)+).
A lookbehind can match a variable-length string.
regex.sub and regex.subn support 'pos' and 'endpos' arguments.
regex.findall and regex.finditer support an 'overlapped' flag which permits overlapped matches.
regex.splititer has been added. It's a generator equivalent of regex.split.
A match object accepts access to the groups via subscripting and slicing:
>>> 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')
Groups can be named with (?<name>...) as well as the existing (?P<name>...).
Groups can be referenced within a pattern with \g<name>. This also allows there to be more than 99 groups.
\N{name}
Named characters are supported. Note that only those known by Python's Unicode database will be recognised.
\p{property=value}; \P{property=value}; \p{value} ; \P{value}
Many Unicode properties are supported, including blocks and scripts. \p{property=value} or \p{property:value} matches a character whose property property has value value. The inverse of \p{property=value} is \P{property=value} or \p{^property=value}.
If the short form \p{value} is used, the properties are checked in the order: General_Category, Script, Block, binary property:
Latin, the 'Latin' script (Script=Latin).BasicLatin, the 'BasicLatin' block (Block=BasicLatin).Alphabetic, the 'Alphabetic' binary property (Alphabetic=Yes).A short form starting with Is indicates a script or binary property:
IsLatin, the 'Latin' script (Script=Latin).IsAlphabetic, the 'Alphabetic' binary property (Alphabetic=Yes).A short form starting with In indicates a block property:
InBasicLatin, the 'BasicLatin' block (Block=BasicLatin).[[:alpha:]]; [[:^alpha:]]
POSIX character classes are supported. These are normally treated as an alternative form of \p{...}.
The exceptions are alnum, digit, punct and xdigit, whose definitions are different from those of Unicode.
[[:alnum:]] is equivalent to \p{posix_alnum}.
[[:digit:]] is equivalent to \p{posix_digit}.
[[:punct:]] is equivalent to \p{posix_punct}.
[[:xdigit:]] is equivalent to \p{posix_xdigit}.
\G
A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:
>>> regex.findall(r"\w{2}", "abcd ef")
['ab', 'cd', 'ef']
>>> regex.findall(r"\G\w{2}", "abcd ef")
['ab', 'cd']
Searches can also work backwards:
>>> regex.findall(r".", "abc")
['a', 'b', 'c']
>>> regex.findall(r"(?r).", "abc")
['c', 'b', 'a']
Note that the result of a reverse search is not necessarily the reverse of a forward search:
>>> regex.findall(r"..", "abcde")
['ab', 'cd']
>>> regex.findall(r"(?r)..", "abcde")
['de', 'bc']
\X
The grapheme matcher is supported. It conforms to the Unicode specification at http://www.unicode.org/reports/tr29/.
(?|...|...)
Group numbers will be reused across the alternatives, but groups with different names will have different group numbers.
>>> regex.match(r"(?|(first)|(second))", "first").groups()
('first',)
>>> regex.match(r"(?|(first)|(second))", "second").groups()
('second',)
Note that there is only one group.
The WORD flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to \b and \B.
The matching methods and functions support timeouts. The timeout (in seconds) applies to the entire operation:
>>> 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
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。