Hướng dẫn how do i download re in python? - làm cách nào để tải xuống lại trong python?

Tính năng bổ sung

Các số vấn đề liên quan đến Trình theo dõi lỗi Python, ngoại trừ nơi được liệt kê khác.

Show

Đã thêm \ p {horiz_space} và \ p {vert_space} (GitHub vấn đề 477)\p{Horiz_Space} and \p{Vert_Space} (GitHub issue 477)

\ p {horiz_space} hoặc \ p {h} khớp với khoảng trắng ngang và \ p {vert_space} hoặc \ p {v} khớp với khoảng trắng dọc. or \p{H} matches horizontal whitespace and \p{Vert_Space} or \p{V} matches vertical whitespace.

Đã thêm hỗ trợ cho Lookaround trong mô hình có điều kiện (HG Số 163)

Việc kiểm tra một mô hình có điều kiện có thể là một cái nhìn.

>>> 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'>

Điều này không hoàn toàn giống như đặt một cái nhìn vào nhánh đầu tiên của một cặp thay thế.

>>> 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

Trong ví dụ đầu tiên, Lookaround phù hợp, nhưng phần còn lại của nhánh đầu tiên không khớp, và do đó, nhánh thứ hai đã được cố gắng đã không cố gắng.not attempted.

Đã thêm phù hợp POSIX (dài nhất bên trái) (HG Số 150)

Tiêu chuẩn POSIX cho Regex là trả về trận đấu dài nhất bên trái. Điều này có thể được bật bằng cách sử dụng cờ POSIX.POSIX flag.

>>> # Normal matching.
>>> 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 matching.
>>> 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'>

Lưu ý rằng sẽ mất nhiều thời gian hơn để tìm các trận đấu bởi vì khi tìm thấy một trận đấu ở một vị trí nhất định, nó đã giành được sự trở lại ngay lập tức, nhưng sẽ tiếp tục tìm cách xem nếu có một trận đấu dài hơn ở đó.

Đã thêm (? (Xác định) ...) (HG Số 152)(?(DEFINE)...) (Hg issue 152)

Nếu không có nhóm nào được gọi là xác định, thì sẽ bị bỏ qua ngoại trừ bất kỳ nhóm nào được xác định trong đó có thể được gọi và các quy tắc thông thường để đánh số các nhóm vẫn được áp dụng.

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

Đã thêm (*Prune), (*bỏ qua) và (*FAIL) (HG Số 153)(*PRUNE), (*SKIP) and (*FAIL) (Hg issue 153)

(*Prune) loại bỏ thông tin quay lại cho đến điểm đó. Khi được sử dụng trong một nhóm nguyên tử hoặc một cái nhìn, nó đã giành được ảnh hưởng đến mô hình kèm theo. discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won’t affect the enclosing pattern.

. Khi được sử dụng trong một nhóm nguyên tử hoặc một cái nhìn, nó đã giành được ảnh hưởng đến mô hình kèm theo. is similar to (*PRUNE), except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won’t affect the enclosing pattern.

(*Thất bại) gây ra việc quay lại ngay lập tức. (*F) là một chữ viết tắt được phép. causes immediate backtracking. (*F) is a permitted abbreviation.

Đã thêm \ K (HG Số 151)\K (Hg issue 151)

Giữ phần của toàn bộ trận đấu sau vị trí xảy ra \ k; Phần trước khi nó bị loại bỏ.\K occurred; the part before it is discarded.

Nó không ảnh hưởng đến những gì các nhóm trở lại.

>>> 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'

Đã thêm đăng ký bắt giữ cho ExpandF và Subf/Subfn (HG Số 133)expandf and subf/subfn (Hg issue 133)

Bạn có thể sử dụng đăng ký để có được sự bắt giữ của một nhóm lặp đi lặp lại.

>>> 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\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'

Đã thêm hỗ trợ để tham khảo một nhóm theo số bằng cách sử dụng (? P = ...)(?P=...)

Đây là ngoài các \ g hiện có.\g<...>.

Đã sửa lỗi xử lý các regexes nhạy cảm với địa phương

Cờ Locale được dành cho mã kế thừa và có hỗ trợ hạn chế. Thay vào đó, bạn vẫn khuyến nghị sử dụng Unicode.LOCALE flag is intended for legacy code and has limited support. You’re still recommended to use Unicode instead.

Đã thêm các trận đấu một phần (HG ISSUE 102)

Một kết hợp một phần là một phần phù hợp với kết thúc của chuỗi, nhưng chuỗi đó đã bị cắt ngắn và bạn muốn biết liệu một trận đấu hoàn chỉnh có thể là có thể nếu chuỗi không bị cắt ngắn hay không.

Các trận đấu một phần được hỗ trợ bởi khớp, tìm kiếm, fullmatch và finditer với đối số từ khóa một phần.match, search, fullmatch and finditer with the partial keyword argument.

Các đối tượng khớp có một thuộc tính một phần, đó là đúng nếu nó là một kết hợp một phần.partial attribute, which is True if it’s a partial match.

Ví dụ: nếu bạn muốn người dùng nhập số 4 chữ số và kiểm tra nó theo ký tự khi nó được nhập:

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

>>> # Initially, nothing has been entered:
>>> print(pattern.fullmatch('', partial=True))
<regex.Match object; span=(0, 0), match='', partial=True>

>>> # An empty string is OK, but it's only a partial match.
>>> # The user enters a letter:
>>> print(pattern.fullmatch('a', partial=True))
None
>>> # It'll never match.

>>> # The user deletes that and enters a digit:
>>> print(pattern.fullmatch('1', partial=True))
<regex.Match object; span=(0, 1), match='1', partial=True>
>>> # It matches this far, but it's only a partial match.

>>> # The user enters 2 more digits:
>>> print(pattern.fullmatch('123', partial=True))
<regex.Match object; span=(0, 3), match='123', partial=True>
>>> # It matches this far, but it's only a partial match.

>>> # The user enters another digit:
>>> print(pattern.fullmatch('1234', partial=True))
<regex.Match object; span=(0, 4), match='1234'>
>>> # It's a complete match.

>>> # If the user enters another digit:
>>> print(pattern.fullmatch('12345', partial=True))
None
>>> # It's no longer a match.

>>> # This is a partial match:
>>> pattern.match('123', partial=True).partial
True

>>> # This is a complete match:
>>> pattern.match('1233', partial=True).partial
False

* Người vận hành không hoạt động chính xác với Sub () (HG ISSUE 106) operator not working correctly with sub() (Hg issue 106)

Đôi khi, nó không rõ làm thế nào các trận đấu có chiều rộng bằng không nên được xử lý. Ví dụ: nên.* Kết hợp 0 ​​ký tự trực tiếp sau khi khớp> 0 ký tự?.* match 0 characters directly after matching >0 characters?

# 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')
'|||||||||'

Đã thêm CapturesDict (HG ISSUE 86)capturesdict (Hg issue 86)

CapturesDict là sự kết hợp giữa GroupDict và bắt giữ: is a combination of groupdict and captures:

GroupDict trả về một bản quyền của các nhóm được đặt tên và vụ bắt giữ cuối cùng của các nhóm đó. returns a dict of the named groups and the last capture of those groups.

Các vụ bắt giữ trả lại một danh sách tất cả các vụ bắt giữ của một nhóm returns a list of all the captures of a group

CaptureSdict trả về một quyền của các nhóm được đặt tên và danh sách tất cả các vụ bắt giữ của các nhóm đó. returns a dict of the named groups and lists of all the captures of those groups.

>>> m = regex.match(r"(?:(?P\w+) (?P\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']}

Đã thêm allcaptures và allspans (Git vấn đề 474)allcaptures and allspans (Git issue 474)

Allcaptures trả về một danh sách tất cả các vụ bắt giữ của tất cả các nhóm. returns a list of all the captures of all the groups.

Allspans trả về một danh sách tất cả các nhịp của tất cả các bản ghi của tất cả các nhóm. returns a list of all the spans of the all captures of all the groups.

>>> m = regex.match(r"(?:(?P\w+) (?P\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)])

Cho phép tên trùng lặp của các nhóm (số HG 87)

Tên nhóm có thể được nhân đôi.

>>> 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
0

Đã thêm FullMatch (Số 16203)fullmatch (issue #16203)

FullMatch hoạt động giống như khớp, ngoại trừ việc nó phải khớp với tất cả các chuỗi. behaves like match, except that it must match all of the string.

>>> 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
1

Đã thêm Subf và Subfnsubf and subfn

Subf và subfn là lựa chọn thay thế cho phụ và subn tương ứng. Khi truyền một chuỗi thay thế, họ coi nó như một chuỗi định dạng. and subfn are alternatives to sub and subn respectively. When passed a replacement string, they treat it as a format string.

>>> 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
2

Đã thêm ExpandF để khớp với đối tượngexpandf to match object

ExpandF là một thay thế để mở rộng. Khi truyền một chuỗi thay thế, nó coi nó là một chuỗi định dạng. is an alternative to expand. When passed a replacement string, it treats it as a format string.

>>> 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
3

Tách chuỗi tìm kiếm

Một đối tượng khớp chứa một tham chiếu đến chuỗi đã được tìm kiếm, thông qua thuộc tính chuỗi của nó. Phương pháp Detach_String sẽ tách chuỗi đó, làm cho nó có sẵn cho bộ sưu tập rác, có thể lưu bộ nhớ có giá trị nếu chuỗi đó rất lớn.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.

>>> 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
4

Các mẫu đệ quy (HG phát hành 27)

Các mẫu đệ quy và lặp lại được hỗ trợ.

(? R) hoặc (? 0) cố gắng phù hợp với toàn bộ regex đệ quy. (? 1), (? 2), vv, cố gắng khớp với nhóm có liên quan. or (?0) tries to match the entire regex recursively. (?1), (?2), etc, try to match the relevant group.

(? & Tên) cố gắng phù hợp với nhóm được đặt tên. tries to match the named group.

>>> 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
5

Hai ví dụ đầu tiên cho thấy cách trình bày tiểu trong nhóm được sử dụng lại, nhưng bản thân nó là một nhóm. Nói cách khác, "(Tarzan | Jane) yêu (? 1)" tương đương với "(Tarzan | Jane) yêu (?: Tarzan | Jane)"."(Tarzan|Jane) loves (?1)" is equivalent to "(Tarzan|Jane) loves (?:Tarzan|Jane)".

Nó có thể quay lại thành một nhóm đệ quy hoặc lặp đi lặp lại.

Bạn có thể gọi một nhóm nếu có nhiều hơn một nhóm có tên nhóm hoặc số nhóm đó ("Tham chiếu nhóm mơ hồ")."ambiguous group reference").

Các biểu mẫu thay thế (? P> name) và (? P & name) cũng được hỗ trợ.(?P>name) and (?P&name) are also supported.

Hỗ trợ trang web toàn bộ trường hợp Unicode được hỗ trợ

Trong hành vi phiên bản 1, mô-đun Regex sử dụng cài đặt toàn bộ trường hợp khi thực hiện các kết quả kết hợp không phân biệt chữ hoa chữ thường trong Unicode.

>>> 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
6

Trong hành vi phiên bản 0, nó sử dụng các chữ cái đơn giản để tương thích ngược với mô-đun RE.

Phù hợp gần đúng của Fuzzy (HG ISSUE 12, HG ISSUE 41, HG ISSUE 109)

Regex thường cố gắng phù hợp chính xác, nhưng đôi khi cần phải có gần đúng, hoặc mờ, đối với những trường hợp mà văn bản được tìm kiếm có thể chứa lỗi dưới dạng các ký tự được chèn, xóa hoặc thay thế.

Một regex mờ chỉ định loại lỗi nào được cho phép và, tùy chọn, tối thiểu và tối đa hoặc chỉ số lượng tối đa được phép của mỗi loại. (Bạn không thể chỉ định tối thiểu.)

3 loại lỗi là:

  • Chèn, được chỉ định bởi "i"

  • Xóa, được chỉ định bởi "D"

  • Thay thế, được chỉ định bởi "s"

Ngoài ra, trên mạng E, chỉ ra bất kỳ loại lỗi nào.

Độ mờ của một mục regex được chỉ định giữa {{và và}} sau mục.

Examples:

  • Foo phù hợp chính xác match “foo” exactly

  • (?: foo) {i} khớp với foo, cho phép chèn match “foo”, permitting insertions

  • (?: foo) {d} khớp với foo, cho phép xóa match “foo”, permitting deletions

  • (?: foo) {s} khớp match “foo”, permitting substitutions

  • (? match “foo”, permitting insertions and substitutions

  • (?: foo) {e} khớp với foo, cho phép lỗi match “foo”, permitting errors

Nếu một loại lỗi nhất định được chỉ định, thì bất kỳ loại nào không được chỉ định sẽ không được phép.not be permitted.

Trong các ví dụ sau, tôi sẽ bỏ qua mục và chỉ viết sự mờ nhạt:

  • {d permit at most 3 deletions, but no other types

  • {i permit at most 1 insertion and at most 2 substitutions, but no deletions

  • {1 permit at least 1 and at most 3 errors

  • {i permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions

Nó cũng có thể nêu chi phí của từng loại lỗi và tổng chi phí được phép tối đa.

Examples:

  • {2i+2d+1s each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4

  • {i 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 4

Bạn cũng có thể dùng "

Bạn có thể thêm một bài kiểm tra để thực hiện trên một ký tự mà thay thế hoặc chèn.

Examples:

  • {s at most 2 substitutions, which must be in the character set [a-z].

  • {s at most 2 substitutions, at most 3 insertions, which must be digits.

Theo mặc định, các tìm kiếm phù hợp mờ cho trận đấu đầu tiên đáp ứng các ràng buộc đã cho. Cờ nâng cao sẽ khiến nó cố gắng cải thiện sự phù hợp (nghĩa là giảm số lượng lỗi) của trận đấu mà nó đã tìm thấy.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.

Cờ BestMatch sẽ làm cho nó tìm kiếm cho trận đấu tốt nhất thay thế.BESTMATCH flag will make it search for the best match instead.

Ví dụ thêm để lưu ý:

  • Regex.Search ("(Dog) {e}", "Cat and Dog") [1] Trả về "Cat" vì phù hợp với "con chó" với 3 lỗi (số lỗi không giới hạn được cho phép). "cat and dog")[1] returns "cat" because that matches "dog" with 3 errors (an unlimited number of errors is permitted).

  • regex.search("(dog){e "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 "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.

Trong hai ví dụ đầu tiên, có các kết quả hoàn hảo sau này trong chuỗi, nhưng trong cả hai trường hợp, đây là trận đấu đầu tiên có thể.

Đối tượng khớp có một thuộc tính fuzzy_counts cung cấp tổng số lượng thay thế, chèn và xóa.fuzzy_counts which gives the total number of substitutions, insertions and deletions.

>>> 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
7

Đối tượng Match cũng có một thuộc tính fuzzy_changes cung cấp một vị trí của các vị trí của sự thay thế, chèn và xóa.fuzzy_changes which gives a tuple of the positions of the substitutions, insertions and deletions.

>>> 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
8

Điều này có nghĩa là nếu phần phù hợp của chuỗi là:

>>> 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
9

Nó sẽ là một trận đấu chính xác.

Tuy nhiên, đã có các chèn tại các vị trí 7 và 8:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
0

và xóa tại các vị trí 10 và 11:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
1

Vì vậy, chuỗi thực tế là:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
2

Danh sách được đặt tên \ l (HG ISSUE 11)\L (Hg issue 11)

Có những lúc bạn có thể muốn bao gồm một danh sách (thực tế, một bộ) các tùy chọn trong Regex.

Một cách là xây dựng mô hình như thế này:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
3

Nhưng nếu danh sách này lớn, việc phân tích các regex kết quả có thể mất thời gian đáng kể, và cũng phải cẩn thận rằng các chuỗi được thoát ra đúng cách và đặt hàng đúng cách, ví dụ, mèo mèo trước khi mèo mèo.

Giải pháp thay thế mới là sử dụng danh sách được đặt tên:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
4

Thứ tự của các mặt hàng là không liên quan, chúng được coi là một bộ. Các danh sách được đặt tên có sẵn dưới dạng thuộc tính .named_lists của đối tượng mẫu:.named_lists attribute of the pattern object :

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
5

Nếu có bất kỳ đối số từ khóa chưa sử dụng nào, ValueError sẽ được nâng lên trừ khi bạn nói với nó khác:ValueError will be raised unless you tell it otherwise:

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
6

Bắt đầu và kết thúc từ

\ m phù hợp khi bắt đầu một từ. matches at the start of a word.

\ M phù hợp ở cuối một từ. matches at the end of a word.

So sánh với \ B, khớp với đầu hoặc cuối của một từ.\b, which matches at the start or end of a word.

Dòng phân tách dòng Unicode

Thông thường, bộ tách dòng duy nhất là \ n (\ x0a), nhưng nếu cờ từ được bật thì các dấu phân cách dòng là \ x0d \ x0a, \ x0a, \ x0b, \ x0c và \ x0d, cộng với \ x85, \ u2028 và \ u2029 Khi làm việc với Unicode.\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.

Điều này ảnh hưởng đến dấu chấm regex ".", Với cờ Dotall đã tắt, khớp với bất kỳ ký tự nào ngoại trừ một dấu phân cách dòng. Nó cũng ảnh hưởng đến các mỏ neo ^ và $ (ở chế độ đa dòng).".", which, with the DOTALL flag turned off, matches any character except a line separator. It also affects the line anchors ^ and $ (in multiline mode).

Đặt nhà khai thác

Chỉ có hành vi phiên bản 1

Các toán tử đã được thêm vào và một tập hợp [...] có thể bao gồm các bộ lồng nhau.[...] can include nested sets.

Các nhà khai thác, theo thứ tự tăng ưu tiên, là:

  • || Đối với Liên minh (Hồi x || y có nghĩa là x hoặc y for union (“x||y” means “x or y”)

  • ~ ~ (gấp đôi tilde) cho sự khác biệt đối xứng (Hồi x ~ ~ y có nghĩa là x hoặc y, nhưng không phải cả hai) (double tilde) for symmetric difference (“x~~y” means “x or y, but not both”)

  • && cho giao lộ (Hồi X && y có nghĩa là X X và Y)) for intersection (“x&&y” means “x and y”)

  • - (Double Dash) cho sự khác biệt ( (double dash) for difference (“x–y” means “x but not y”)

Liên minh ngầm, tức là, sự kết hợp đơn giản như trong [AB], có ưu tiên cao nhất. Do đó, [ab && cd] giống như [[a || b] && [c || d]].[ab], has the highest precedence. Thus, [ab&&cd] is the same as [[a||b]&&[c||d]].

Examples:

  • [ab] # set chứa ’a và’ b # Set containing ‘a’ and ‘b’

  • [A-Z] # Set chứa ‘A, ..’ Z # Set containing ‘a’ .. ‘z’

  • [[A-Z]-[QW]] # Bộ chứa ‘A, ..’ Z, nhưng không phải ‘ # Set containing ‘a’ .. ‘z’, but not ‘q’ or ‘w’

  • [A-Z-QW] # giống như trên # Same as above

  • [\ p {l}-qw] # set chứa tất cả các chữ cái ngoại trừ ‘q, và w W # Set containing all letters except ‘Q’ and ‘W’

  • [\ p {n}-[0-9]] # Đặt chứa tất cả các số ngoại trừ ‘0, ..’ 9 # Set containing all numbers except ‘0’ .. ‘9’

  • [\ p {ascii} && \ p {letter}] # set chứa tất cả các ký tự là ascii và chữ cái # Set containing all characters which are ASCII and letter

regex.escape (số #2650)

regex.escape có một tham số từ khóa bổ sung đặc biệt_only. Khi đúng, chỉ có các nhân vật Regex đặc biệt, chẳng hạn như ‘?,, được trốn thoát.special_only. When True, only ‘special’ regex characters, such as ‘?’, are escaped.

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
7

regex.escape (HG số 249)

Regex.escape có một tham số từ khóa bổ sung. Khi đúng, không gian không được thoát ra.literal_spaces. When True, spaces are not escaped.

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
8

Bị bắt lặp đi lặp lại (Vấn đề #7132)

Một đối tượng Match có các phương thức bổ sung trả về thông tin trên tất cả các trận đấu thành công của một nhóm lặp lại. Những phương pháp này là:

  • matchobject.captures([group1,...]) ...])

    • Trả về một danh sách các chuỗi được khớp trong một nhóm hoặc nhóm. So sánh với MatchObject.group ([Group1, ...]).matchobject.group([group1, ...]).

  • matchobject.starts([group])

    • Trả về một danh sách các vị trí bắt đầu. So sánh với matchObject.start ([nhóm]).matchobject.start([group]).

  • matchobject.ends([group])

    • Trả về một danh sách các vị trí cuối. So sánh với MatchObject.end ([Nhóm]).matchobject.end([group]).

  • matchobject.spans([group])

    • Trả về một danh sách các nhịp. So sánh với matchObject.span ([nhóm]).matchobject.span([group]).

>>> # Normal matching.
>>> 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 matching.
>>> 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'>
9

Nhóm nguyên tử (?> ...) (Vấn đề #433030)(?>...) (issue #433030)

Nếu sau đó mẫu sau đó thất bại, thì toàn bộ trình bày tiểu sẽ thất bại.

Định lượng sở hữu

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

Các tiểu mẫu được khớp với thời gian tối đa. Nếu các mẫu sau đây không thành công, thì tất cả các nhà mạng được lặp lại sẽ thất bại toàn bộ. Ví dụ: (?: ...) ++ tương đương với (?> (?: ...)+).(?:...)++ is equivalent to (?>(?:...)+).

Cờ phạm vi (Vấn đề #433028)

(?flags-flags:...)

Các cờ sẽ chỉ áp dụng cho SubPotye. Cờ có thể được bật hoặc tắt.

Định nghĩa của ‘từ ngữ nhân vật (số 1693050)

Định nghĩa của một ký tự ‘từ đã được mở rộng cho Unicode. Nó phù hợp với đặc tả Unicode tại http://www.unicode.org/reports/tr29/.http://www.unicode.org/reports/tr29/.

Lookbehind có độ dài thay đổi

Một cái nhìn có thể khớp với một chuỗi có độ dài thay đổi.

Đối số cờ cho regex.split, regex.sub và regex.subn (Số phát hành #3482)

Regex.Split, Regex.Sub và Regex.Sub hỗ trợ một đối số ‘cờ., regex.sub and regex.subn support a ‘flags’ argument.

Đối số POS và Endpos cho regex.sub và regex.subn

Regex.Sub và Regex.Sub hỗ trợ ‘POS, và‘ endpos. and regex.subn support ‘pos’ and ‘endpos’ arguments.

Đối số chồng chéo cho regex.findall và regex.finditer

regex.findall và regex.finditer hỗ trợ một cờ ‘chồng chéo cho phép các trận đấu chồng chéo. and regex.finditer support an ‘overlapped’ flag which permits overlapped matches.

Chia ra

Regex.Splititer đã được thêm vào. Nó có một máy phát tương đương với regex.split. has been added. It’s a generator equivalent of regex.split.

Đăng ký các đối tượng khớp cho các nhóm

Một đối tượng khớp chấp nhận quyền truy cập vào các nhóm thông qua đăng ký và cắt lát:

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

Các nhóm được đặt tên

Các nhóm có thể được đặt tên bằng (? ...) cũng như hiện tại (? P ...).(?...) as well as the existing (?P...).

Tài liệu tham khảo nhóm

Các nhóm có thể được tham chiếu trong một mẫu với \ g. Điều này cũng cho phép có hơn 99 nhóm.\g. This also allows there to be more than 99 groups.

Ký tự được đặt tên \ n {name}\N{name}

Các ký tự được đặt tên được hỗ trợ. Lưu ý rằng chỉ những người được biết đến bởi cơ sở dữ liệu Unicode của Python sẽ được công nhận.

Các thuộc tính của Unicode CodePoint, bao gồm các tập lệnh và khối

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

Nhiều thuộc tính Unicode được hỗ trợ, bao gồm các khối và tập lệnh. \ p {property = value} hoặc \ p {property: value} khớp với một ký tự có thuộc tính có giá trị. Nghịch đảo của \ p {property = value} là \ p {property = value} hoặc \ p {^property = value}.\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}.

Nếu biểu mẫu ngắn \ p {value} được sử dụng, các thuộc tính được kiểm tra theo thứ tự: General_c Category, script, khối, thuộc tính nhị phân:\p{value} is used, the properties are checked in the order: General_Category, Script, Block, binary property:

  • Latin, tập lệnh ‘tiếng Latin (script = latin)., the ‘Latin’ script (Script=Latin).

  • Basiclatin, khối ‘basiclatin (block = basiclatin)., the ‘BasicLatin’ block (Block=BasicLatin).

  • Bảng chữ cái, thuộc tính nhị phân ‘chữ cái (chữ cái = có)., the ‘Alphabetic’ binary property (Alphabetic=Yes).

Một biểu mẫu ngắn bắt đầu bằng IS chỉ ra một tập lệnh hoặc thuộc tính nhị phân:Is indicates a script or binary property:

  • Islatin, tập lệnh ‘tiếng Latin (script = latin)., the ‘Latin’ script (Script=Latin).

  • Isalphabetic, thuộc tính nhị phân ‘chữ cái (chữ cái = có)., the ‘Alphabetic’ binary property (Alphabetic=Yes).

Một biểu mẫu ngắn bắt đầu bằng trong chỉ định thuộc tính khối:In indicates a block property:

  • Inbasiclatin, khối ‘basiclatin (block = basiclatin)., the ‘BasicLatin’ block (Block=BasicLatin).

Các lớp nhân vật Posix

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

Các lớp nhân vật POSIX được hỗ trợ. Chúng thường được coi là một dạng thay thế của \ p {...}.\p{...}.

Các trường hợp ngoại lệ là alnum, chữ số, dấu chấm câu và xdigit, có định nghĩa khác với unicode.alnum, digit, punct and xdigit, whose definitions are different from those of Unicode.

[[: alnum:]] tương đương với \ p {posix_alnum}. is equivalent to \p{posix_alnum}.

[[: Digit:]] tương đương với \ p {posix_digit}. is equivalent to \p{posix_digit}.

[[: punct:]] tương đương với \ p {posix_punc}. is equivalent to \p{posix_punct}.

[[: xdigit:]] tương đương với \ p {posix_xdigit}. is equivalent to \p{posix_xdigit}.

Tìm kiếm neo \ g\G

Một mỏ neo tìm kiếm đã được thêm vào. Nó phù hợp ở vị trí mà mỗi tìm kiếm bắt đầu/tiếp tục và có thể được sử dụng cho các kết quả liên tục hoặc trong các giao diện có độ dài biến số tiêu cực để giới hạn thời gian nhìn lại của Lookbehind:

>>> regex.search(r'(?(DEFINE)(?P\d+)(?P\w+))(?&quant) (?&item)', '5 elephants')
<regex.Match object; span=(0, 11), match='5 elephants'>
1
  • Tìm kiếm bắt đầu ở vị trí 0 và khớp với ‘AB.

  • Việc tìm kiếm tiếp tục ở vị trí 2 và khớp với ‘CD.

  • Tìm kiếm tiếp tục ở vị trí 4 và không phù hợp với bất kỳ chữ cái nào.

  • Neo dừng vị trí bắt đầu tìm kiếm không được nâng cao, vì vậy không còn kết quả nữa.

Tìm kiếm ngược

Tìm kiếm cũng có thể làm việc ngược:

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

Lưu ý rằng kết quả của một tìm kiếm ngược không nhất thiết là ngược lại một tìm kiếm phía trước:

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

Phù hợp với một grapheme \ x\X

Trình kết hợp Grapheme được hỗ trợ. Nó phù hợp với đặc tả Unicode tại http://www.unicode.org/reports/tr29/.http://www.unicode.org/reports/tr29/.

Đặt lại chi nhánh (? | ... | ...)(?|...|...)

Số nhóm sẽ được sử dụng lại trên các lựa chọn thay thế, nhưng các nhóm có tên khác nhau sẽ có các số nhóm khác nhau.

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

Lưu ý rằng chỉ có một nhóm.

Biên giới từ Unicode mặc định

Cờ từ thay đổi định nghĩa của một ranh giới ‘từ thành ranh giới từ Unicode mặc định. Điều này áp dụng cho \ b và \ b.WORD flag changes the definition of a ‘word boundary’ to that of a default Unicode word boundary. This applies to \b and \B.

Hết giờ

Các phương pháp và chức năng phù hợp hỗ trợ thời gian chờ. Thời gian chờ (tính bằng giây) áp dụng cho toàn bộ hoạt động:

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

Gói nào là RE trong Python?

Regex Module Python có một gói tích hợp có tên Re, có thể được sử dụng để làm việc với các biểu thức thông thường. Python has a built-in package called re , which can be used to work with Regular Expressions.

Có phải là một thư viện Python tiêu chuẩn?

Mô -đun RE - Thư viện tiêu chuẩn Python [Sách]Python Standard Library [Book]