Ranh giới từ regex Python

Đôi khi bạn muốn tìm một từ, không phải chuỗi con là một phần của từ lớn hơn. Sử dụng \b để khớp với ranh giới từ. Thông thường ranh giới từ là khoảng trắng (khoảng trống, tab và một vài ký tự khác). Nhưng ranh giới từ cũng bao gồm phần đầu và phần cuối của dòng, các trường hợp dễ bị bỏ qua khi tìm kiếm trong tệp văn bản

Để khớp với ranh giới không phải từ, hãy sử dụng \B trong biểu thức. Để tìm chuỗi con cat được nhúng trong một từ khác, hãy sử dụng \Bcat\B


Hãy cẩn thận khi cố khớp các ranh giới từ trong Python bằng cách sử dụng các biểu thức chính quy. Bạn phải chắc chắn thoát khỏi chuỗi khớp hoặc sử dụng chuỗi thô

ranh giới từ

Ranh giới từ là một cách tuyệt vời để thực hiện tìm kiếm cụm từ thông dụng cho toàn bộ từ trong khi tránh khớp một phần. Chẳng hạn, tìm kiếm cụm từ thông dụng “the” sẽ khớp với cả từ “the” và phần đầu của từ “thesaurus”

>>> import re
>>> re.match("the", "the")
# matches
>>> re.match("the", "thesaurus")
# matches 

Trong một số trường hợp, bạn có thể muốn chỉ khớp từ “the” chứ không phải khi nó được nhúng trong một từ khác

Cách khớp ranh giới từ là với '\ b', như được mô tả trong tài liệu Python. Tôi đã lãng phí vài phút vật lộn với việc cố gắng làm cho nó hoạt động

>>> re.match("\bthe\b", "the")
# no match

Hóa ra \b cũng được sử dụng làm trình tự điều khiển xóa lùi. Do đó, để công cụ biểu thức chính quy diễn giải chính xác ranh giới từ, bạn cần thoát chuỗi

>>> re.match("\\bthe\\b", "the")
# match

Bạn cũng có thể sử dụng chuỗi ký tự thô và tránh dấu gạch chéo ngược kép

>>> re.match(r"\bthe\b", "the")
# match

Trong trường hợp bạn chưa từng thấy tiền tố chuỗi thô trước đây, thì đây là tài liệu liên quan

Các chuỗi ký tự có thể tùy chọn được bắt đầu bằng một chữ cái 'r' hoặc 'R';

Phần kết luận

Đảm bảo rằng bạn đã quen thuộc với các chuỗi thoát cho chuỗi trong Python, đặc biệt nếu bạn đang xử lý các biểu thức chính quy có các ký tự đặc biệt có thể xung đột. Tài liệu Java cho các biểu thức chính quy làm cho cảnh báo này rõ ràng hơn một chút so với Python

Ví dụ: chuỗi ký tự “\b” khớp với một ký tự xóa lùi khi được diễn giải dưới dạng biểu thức chính quy, trong khi “\\b” khớp với ranh giới từ

Cả mẫu và chuỗi được tìm kiếm đều có thể là chuỗi Unicode () cũng như chuỗi 8 bit (). Tuy nhiên, không thể trộn lẫn chuỗi Unicode và chuỗi 8 bit. nghĩa là bạn không thể khớp một chuỗi Unicode với một mẫu byte hoặc ngược lại;

Biểu thức chính quy sử dụng ký tự gạch chéo ngược (_______4_______4) để biểu thị các dạng đặc biệt hoặc để cho phép sử dụng các ký tự đặc biệt mà không cần gọi ý nghĩa đặc biệt của chúng. Điều này xung đột với việc Python sử dụng cùng một ký tự cho cùng một mục đích trong chuỗi ký tự; . Ngoài ra, xin lưu ý rằng bất kỳ chuỗi thoát không hợp lệ nào trong cách sử dụng dấu gạch chéo ngược trong chuỗi ký tự của Python hiện tạo ra một và trong tương lai, điều này sẽ trở thành một. Hành vi này sẽ xảy ra ngay cả khi nó là một chuỗi thoát hợp lệ cho một biểu thức chính quy

Giải pháp là sử dụng ký hiệu chuỗi thô của Python cho các mẫu biểu thức chính quy; . Vì vậy,

result = re.match(pattern, string)
1 là chuỗi hai ký tự chứa
prog = re.compile(pattern)
result = prog.match(string)
4 và
result = re.match(pattern, string)
3, trong khi
result = re.match(pattern, string)
4 là chuỗi một ký tự chứa dòng mới. Thông thường các mẫu sẽ được thể hiện bằng mã Python bằng cách sử dụng ký hiệu chuỗi thô này

Điều quan trọng cần lưu ý là hầu hết các thao tác biểu thức chính quy đều có sẵn dưới dạng các hàm và phương thức cấp mô-đun trên. Các hàm là lối tắt không yêu cầu bạn biên dịch đối tượng biểu thức chính quy trước, nhưng bỏ lỡ một số tham số tinh chỉnh

Xem thêm

Mô-đun biểu thức chính quy của bên thứ ba, có API tương thích với mô-đun thư viện chuẩn, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode kỹ lưỡng hơn

Cú pháp biểu thức chính quy

Một biểu thức chính quy (hoặc RE) chỉ định một tập hợp các chuỗi phù hợp với nó;

Các biểu thức chính quy có thể được nối để tạo thành các biểu thức chính quy mới; . Nói chung, nếu một chuỗi p khớp với A và một chuỗi q khác khớp với B, thì chuỗi pq sẽ khớp với AB. Điều này giữ trừ khi A hoặc B chứa các hoạt động ưu tiên thấp; . Do đó, các biểu thức phức tạp có thể dễ dàng được xây dựng từ các biểu thức nguyên thủy đơn giản hơn như các biểu thức được mô tả ở đây. Để biết chi tiết về lý thuyết và cách thực hiện các biểu thức chính quy, hãy tham khảo sách Friedl hoặc hầu hết mọi sách giáo khoa về xây dựng trình biên dịch

Sau đây là giải thích ngắn gọn về định dạng của biểu thức chính quy. Để biết thêm thông tin và trình bày nhẹ nhàng hơn, hãy tham khảo

Biểu thức chính quy có thể chứa cả ký tự đặc biệt và ký tự thông thường. Hầu hết các ký tự thông thường, như

result = re.match(pattern, string)
6,
result = re.match(pattern, string)
7 hoặc
result = re.match(pattern, string)
8, là các biểu thức chính quy đơn giản nhất; . Bạn có thể nối các ký tự thông thường, do đó,
result = re.match(pattern, string)
9 khớp với chuỗi
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
0. (Trong phần còn lại của phần này, chúng ta sẽ viết RE trong
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
1, thường không có dấu ngoặc kép, và các chuỗi được khớp với nhau
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
2. )

Một số ký tự, như

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3 hoặc
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
4, là đặc biệt. Các ký tự đặc biệt đại diện cho các lớp ký tự thông thường hoặc ảnh hưởng đến cách diễn giải các biểu thức chính quy xung quanh chúng

Các toán tử hoặc bộ định lượng lặp lại (_______17_______5,

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
6,
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
7,
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
8, v.v.) không được lồng trực tiếp vào nhau. Điều này tránh sự mơ hồ với hậu tố sửa đổi không tham lam
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
7 và với các công cụ sửa đổi khác trong các triển khai khác. Để áp dụng lần lặp lại thứ hai cho lần lặp lại bên trong, dấu ngoặc đơn có thể được sử dụng. Ví dụ: biểu thức
>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
0 khớp với bất kỳ bội số nào của sáu ký tự
result = re.match(pattern, string)
7

Các ký tự đặc biệt là

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
2

(Chấm. ) Ở chế độ mặc định, ký tự này khớp với bất kỳ ký tự nào ngoại trừ ký tự xuống dòng. Nếu cờ đã được chỉ định, thì cờ này sẽ khớp với bất kỳ ký tự nào kể cả một dòng mới

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
4

(dấu mũ. ) Khớp với phần đầu của chuỗi và trong chế độ cũng khớp ngay sau mỗi dòng mới

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
6

Khớp với phần cuối của chuỗi hoặc ngay trước dòng mới ở cuối chuỗi và trong chế độ cũng khớp với trước một dòng mới.

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
8 khớp với cả 'foo' và 'foobar', trong khi biểu thức chính quy
>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
9 chỉ khớp với 'foo'. Thú vị hơn, tìm kiếm
>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']
0 trong
>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']
1 khớp với 'foo2' bình thường, nhưng 'foo1' ở chế độ; . một ngay trước dòng mới và một ở cuối chuỗi

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
5

Làm cho RE kết quả khớp với 0 hoặc nhiều lần lặp lại của RE trước đó, càng nhiều lần lặp lại càng tốt.

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']
6 sẽ khớp với 'a', 'ab' hoặc 'a' theo sau bởi bất kỳ số nào của 'b'

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
6

Làm cho RE kết quả khớp với 1 hoặc nhiều lần lặp lại của RE trước đó.

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']
8 sẽ khớp với 'a' theo sau bởi bất kỳ số nào khác 0 của 'b';

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
7

Làm cho RE kết quả khớp với 0 hoặc 1 lần lặp lại của RE trước đó.

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
00 sẽ khớp với 'a' hoặc 'ab'

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
01,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
02,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
03

Các bộ định lượng

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
04,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
05 và
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
06 đều là tham lam; . Đôi khi hành vi này không được mong muốn; . Thêm
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
7 sau bộ định lượng làm cho nó thực hiện so khớp theo kiểu không tham lam hoặc tối thiểu; . Sử dụng RE
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
11 sẽ chỉ phù hợp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
09

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
13,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
14,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
15

Giống như các bộ định lượng

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
04,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
05 và
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
06, những bộ định lượng mà
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
05 được thêm vào cũng khớp với nhau nhiều lần nhất có thể. Tuy nhiên, không giống như các bộ định lượng tham lam thực sự, chúng không cho phép theo dõi ngược khi biểu thức theo sau nó không khớp. Chúng được gọi là lượng từ sở hữu. Ví dụ:
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
20 sẽ khớp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
21 vì
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
22 sẽ khớp với tất cả 4
result = re.match(pattern, string)
7, nhưng, khi gặp
result = re.match(pattern, string)
7 cuối cùng, biểu thức được lùi lại để cuối cùng,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
22 kết thúc khớp với tổng số 3
result = re.match(pattern, string)
7 và số thứ tư
result = re.match(pattern, string)
7 được khớp với . Tuy nhiên, khi
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
29 được sử dụng để khớp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
21, thì
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
31 sẽ khớp với tất cả 4
result = re.match(pattern, string)
7, nhưng khi
result = re.match(pattern, string)
7 cuối cùng không tìm thấy bất kỳ ký tự nào khớp với nhau, biểu thức sẽ không thể được quay lại và do đó sẽ không khớp.
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
34,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
35 và
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
36 tương ứng với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
37,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
38 và
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
39

Mới trong phiên bản 3. 11

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
40

Chỉ định rằng phải khớp chính xác m bản sao của RE trước đó; . Ví dụ:

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
41 sẽ khớp chính xác với sáu ký tự
result = re.match(pattern, string)
7, nhưng không khớp với năm ký tự

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
8

Làm cho RE kết quả khớp từ m đến n lần lặp lại của RE trước đó, cố gắng khớp càng nhiều lần lặp lại càng tốt. Ví dụ:

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
44 sẽ khớp với từ 3 đến 5 ký tự
result = re.match(pattern, string)
7. Bỏ qua m chỉ định giới hạn dưới bằng 0 và bỏ qua n chỉ định giới hạn trên vô hạn. Ví dụ:
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
46 sẽ khớp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
47 hoặc một nghìn ký tự
result = re.match(pattern, string)
7 theo sau là một
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
49, nhưng không khớp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
50. Dấu phẩy không được bỏ qua nếu không công cụ sửa đổi sẽ bị nhầm lẫn với dạng được mô tả trước đó

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
51

Làm cho RE kết quả khớp từ m đến n lần lặp lại của RE trước đó, cố gắng khớp càng ít lần lặp lại càng tốt. Đây là phiên bản không tham lam của bộ định lượng trước đó. Ví dụ: trên chuỗi 6 ký tự

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
52,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
44 sẽ khớp với 5 ký tự
result = re.match(pattern, string)
7, trong khi
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
55 sẽ chỉ khớp với 3 ký tự

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
56

Làm cho RE kết quả khớp từ m đến n lần lặp lại của RE trước đó, cố gắng khớp càng nhiều lần lặp lại càng tốt mà không thiết lập bất kỳ điểm quay lui nào. Đây là phiên bản sở hữu của bộ định lượng ở trên. Ví dụ: trên chuỗi 6 ký tự

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
52,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
58 cố gắng khớp 5
result = re.match(pattern, string)
7 ký tự, sau đó, yêu cầu thêm 2 ký tự
result = re.match(pattern, string)
7, sẽ cần nhiều ký tự hơn mức có sẵn và do đó không thành công, trong khi
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
61 sẽ khớp với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
44 bắt được 5, sau đó là 4 ký tự
result = re.match(pattern, string)
7 bằng cách quay lui .
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
66 tương đương với
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
67

Mới trong phiên bản 3. 11

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
68

Thoát khỏi các ký tự đặc biệt (cho phép bạn ghép các ký tự như

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
04,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
06, v.v.) hoặc báo hiệu một chuỗi đặc biệt;

Nếu bạn không sử dụng chuỗi thô để thể hiện mẫu, hãy nhớ rằng Python cũng sử dụng dấu gạch chéo ngược làm chuỗi thoát trong chuỗi ký tự; . Tuy nhiên, nếu Python nhận ra chuỗi kết quả, dấu gạch chéo ngược phải được lặp lại hai lần. Điều này phức tạp và khó hiểu, vì vậy chúng tôi khuyên bạn nên sử dụng các chuỗi thô cho tất cả trừ các biểu thức đơn giản nhất

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
71

Được sử dụng để chỉ ra một tập hợp các ký tự. trong một bộ

  • Các ký tự có thể được liệt kê riêng lẻ, e. g.

    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    72 sẽ khớp với
    result = re.match(pattern, string)
    
    7,
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    74 hoặc
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    75

  • Phạm vi ký tự có thể được biểu thị bằng cách đưa ra hai ký tự và phân tách chúng bằng một dấu

    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    76, ví dụ:
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    77 sẽ khớp với bất kỳ chữ cái ASCII viết thường nào,
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    78 sẽ khớp với tất cả các số có hai chữ số từ
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    79 đến
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    80 và
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    81 sẽ khớp với bất kỳ chữ số thập lục phân nào. Nếu
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    82 bị thoát (e. g.
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    83) hoặc nếu nó được đặt làm ký tự đầu tiên hoặc cuối cùng (e. g.
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    84 hoặc
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    85), nó sẽ khớp với một chữ
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    76

  • Các ký tự đặc biệt mất ý nghĩa đặc biệt của chúng trong các bộ. Ví dụ:

    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    87 sẽ khớp với bất kỳ ký tự chữ nào là
    >>> re.split(r'\W+', 'Words, words, words.')
    ['Words', 'words', 'words', '']
    >>> re.split(r'(\W+)', 'Words, words, words.')
    ['Words', ', ', 'words', ', ', 'words', '.', '']
    >>> re.split(r'\W+', 'Words, words, words.', 1)
    ['Words', 'words, words.']
    >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
    ['0', '3', '9']
    
    4,
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    05,
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    04 hoặc
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    91

  • Các lớp ký tự như

    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    92 hoặc
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    93 (được định nghĩa bên dưới) cũng được chấp nhận trong một tập hợp, mặc dù các ký tự phù hợp với chúng tùy thuộc vào chế độ có hiệu lực hay không

  • Các ký tự không nằm trong phạm vi có thể được khớp bằng cách bổ sung cho bộ. Nếu ký tự đầu tiên của tập hợp là

    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    96, thì tất cả các ký tự không có trong tập hợp sẽ được so khớp. Ví dụ:
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    97 sẽ khớp với bất kỳ ký tự nào ngoại trừ
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    98 và
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    99 sẽ khớp với bất kỳ ký tự nào ngoại trừ
    >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'
    
    96.
    >>> re.split(r'(\W+)', '...words, words...')
    ['', '...', 'words', ', ', 'words', '...', '']
    
    4 không có ý nghĩa đặc biệt nếu nó không phải là ký tự đầu tiên trong tập hợp

  • Để khớp một chữ

    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    02 bên trong một tập hợp, đặt trước nó bằng dấu gạch chéo ngược hoặc đặt nó ở đầu tập hợp. Ví dụ: cả
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    03 và
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    04 đều sẽ khớp với dấu ngoặc đơn

  • Hỗ trợ các tập hợp lồng nhau và các thao tác tập hợp như trong Tiêu chuẩn kỹ thuật Unicode #18 có thể được thêm vào trong tương lai. Điều này sẽ thay đổi cú pháp, vì vậy để tạo điều kiện thuận lợi cho sự thay đổi này, tạm thời sẽ được nêu ra trong các trường hợp không rõ ràng. Điều đó bao gồm các bộ bắt đầu bằng một chữ

    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    06 hoặc chứa các chuỗi ký tự chữ
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    07,
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    08,
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    09 và
    \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    10. Để tránh cảnh báo, hãy thoát chúng bằng dấu gạch chéo ngược

Đã thay đổi trong phiên bản 3. 7. được nâng lên nếu một bộ ký tự chứa các cấu trúc sẽ thay đổi về mặt ngữ nghĩa trong tương lai.

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
12

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
13, trong đó A và B có thể là các RE tùy ý, tạo một biểu thức chính quy khớp với A hoặc B. Một số RE tùy ý có thể được phân tách bằng
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3 theo cách này. Điều này cũng có thể được sử dụng trong các nhóm (xem bên dưới). Khi chuỗi mục tiêu được quét, các RE cách nhau bởi
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3 được thử từ trái sang phải. Khi một mẫu khớp hoàn toàn, nhánh đó được chấp nhận. Điều này có nghĩa là một khi A khớp, B sẽ không được kiểm tra thêm, ngay cả khi nó sẽ tạo ra kết quả khớp tổng thể dài hơn. Nói cách khác, toán tử
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3 không bao giờ tham lam. Để khớp với một ký tự
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3, hãy sử dụng
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
18 hoặc đặt nó bên trong một lớp ký tự, như trong
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
19

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
20

Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn và cho biết điểm bắt đầu và điểm kết thúc của một nhóm; . Để khớp với các chữ

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
4 hoặc
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
91, hãy sử dụng
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
24 hoặc
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
25 hoặc đặt chúng bên trong một lớp ký tự.
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
26,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
27

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
28

Đây là một ký hiệu mở rộng (một

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
06 theo sau một
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
4 không có ý nghĩa khác). Ký tự đầu tiên sau
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
06 xác định ý nghĩa và cú pháp tiếp theo của cấu trúc là gì. Tiện ích mở rộng thường không tạo nhóm mới; . Sau đây là các tiện ích mở rộng hiện được hỗ trợ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
33

(Một hoặc nhiều chữ cái từ bộ

result = re.match(pattern, string)
7,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
35,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
36,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
74,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
38,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
39,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
40. ) Nhóm khớp với chuỗi rỗng; . (chỉ khớp ASCII), (bỏ qua chữ hoa chữ thường), (phụ thuộc vào ngôn ngữ), (nhiều dòng), (dấu chấm khớp với tất cả),
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
46 (khớp Unicode) và (dài dòng), cho toàn bộ biểu thức chính quy. (Các cờ được mô tả trong. ) Điều này hữu ích nếu bạn muốn bao gồm các cờ như một phần của biểu thức chính quy, thay vì chuyển một đối số cờ cho hàm. Cờ nên được sử dụng đầu tiên trong chuỗi biểu thức

Đã thay đổi trong phiên bản 3. 11. Cấu trúc này chỉ có thể được sử dụng ở đầu biểu thức.

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
49

Phiên bản không ghi dấu ngoặc đơn thông thường. Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn, nhưng không thể truy xuất chuỗi con được khớp bởi nhóm sau khi thực hiện khớp hoặc được tham chiếu sau này trong mẫu

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
50

(Không hoặc nhiều chữ cái từ bộ

result = re.match(pattern, string)
7,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
35,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
36,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
74,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
38,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
39,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
40, tùy ý theo sau bởi
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
76, tiếp theo là một hoặc nhiều chữ cái từ
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
35,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
74,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
38,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
40. ) Các chữ cái đặt hoặc loại bỏ các cờ tương ứng. (chỉ khớp ASCII), (bỏ qua chữ hoa chữ thường), (phụ thuộc vào ngôn ngữ), (nhiều dòng), (dấu chấm khớp với tất cả),
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
46 (khớp Unicode) và (dài dòng), cho một phần của biểu thức. (Các cờ được mô tả trong. )

Các chữ cái

result = re.match(pattern, string)
7,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
36 và
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
39 loại trừ lẫn nhau khi được sử dụng làm cờ nội tuyến, vì vậy chúng không thể được kết hợp hoặc theo sau
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
76. Thay vào đó, khi một trong số chúng xuất hiện trong một nhóm nội tuyến, nó sẽ ghi đè chế độ phù hợp trong nhóm kèm theo. Trong các mẫu Unicode,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
74 chuyển sang chỉ khớp ASCII và
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
75 chuyển sang khớp Unicode (mặc định). Trong mẫu byte,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
76 chuyển sang khớp tùy thuộc vào ngôn ngữ và
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
74 chuyển sang khớp chỉ ASCII (mặc định). Ghi đè này chỉ có hiệu lực đối với nhóm nội tuyến hẹp và chế độ khớp ban đầu được khôi phục bên ngoài nhóm

Mới trong phiên bản 3. 6

Đã thay đổi trong phiên bản 3. 7. Các chữ cái

result = re.match(pattern, string)
7,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
36 và
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
39 cũng có thể được sử dụng trong một nhóm.

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
81

Nỗ lực khớp với

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
82 như thể đó là một biểu thức chính quy riêng biệt và nếu thành công, tiếp tục khớp với phần còn lại của mẫu theo sau nó. Nếu mẫu tiếp theo không khớp, ngăn xếp chỉ có thể được mở ra ở một điểm trước
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
81 vì một khi thoát ra, biểu thức, được gọi là nhóm nguyên tử, đã loại bỏ tất cả các điểm ngăn xếp trong chính nó. Do đó,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
84 sẽ không bao giờ khớp với bất kỳ thứ gì vì đầu tiên,
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
85 sẽ khớp với tất cả các ký tự có thể, sau đó, không còn gì để khớp, cuối cùng
>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
2 sẽ không khớp. Vì không có điểm ngăn xếp nào được lưu trong Nhóm nguyên tử và không có điểm ngăn xếp nào trước nó, nên toàn bộ biểu thức sẽ không khớp

Mới trong phiên bản 3. 11

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
32

Tương tự như dấu ngoặc đơn thông thường, nhưng chuỗi con khớp với nhóm có thể truy cập thông qua tên nhóm tượng trưng. Tên nhóm phải là mã định danh Python hợp lệ và mỗi tên nhóm chỉ được xác định một lần trong biểu thức chính quy. Một nhóm tượng trưng cũng là một nhóm được đánh số, giống như nhóm không được đặt tên

Các nhóm được đặt tên có thể được tham chiếu trong ba ngữ cảnh. Nếu mẫu là

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
88 (i. e. khớp với một chuỗi được trích dẫn bằng dấu ngoặc đơn hoặc dấu ngoặc kép)

Bối cảnh tham chiếu đến nhóm “trích dẫn”

Các cách để tham khảo nó

trong cùng một mô hình chính nó

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    89 (như hình)

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    90

khi xử lý khớp đối tượng m

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    91

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    92 (v.v. )

trong một chuỗi được chuyển đến đối số thay thế của

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
93

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    94

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    95

  • \a      \b      \f      \n
    \N      \r      \t      \u
    \U      \v      \x      \\
    
    90

Không dùng nữa kể từ phiên bản 3. 11. Tên nhóm chứa các ký tự không phải ASCII trong mẫu byte.

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
97

Một phản hồi cho một nhóm được đặt tên;

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
98

Một lời bình luận;

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
99

Khớp nếu

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
82 khớp tiếp theo, nhưng không sử dụng bất kỳ chuỗi nào. Điều này được gọi là một khẳng định nhìn trước. Ví dụ:
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
01 sẽ khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
02 chỉ khi nó được theo sau bởi
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
03

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
04

Khớp nếu

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
82 không khớp tiếp theo. Đây là một khẳng định nhìn trước tiêu cực. Ví dụ:
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
06 sẽ chỉ khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
02 nếu nó không theo sau bởi
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
03

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
09

Khớp nếu vị trí hiện tại trong chuỗi được bắt đầu bằng một khớp cho

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
82 kết thúc ở vị trí hiện tại. Điều này được gọi là khẳng định cái nhìn tích cực.
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
11 sẽ tìm thấy kết quả trùng khớp trong
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
12, vì giao diện phía sau sẽ sao lưu 3 ký tự và kiểm tra xem mẫu có trong đó có khớp không. Mẫu có trong chỉ được khớp với các chuỗi có độ dài cố định, nghĩa là cho phép sử dụng
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
13 hoặc
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
14, nhưng
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
22 và
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
16 thì không. Lưu ý rằng các mẫu bắt đầu bằng xác nhận giao diện tích cực sẽ không khớp ở đầu chuỗi được tìm kiếm;

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

Ví dụ này tìm kiếm một từ sau dấu gạch nối

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

Đã thay đổi trong phiên bản 3. 5. Đã thêm hỗ trợ cho tham chiếu nhóm có độ dài cố định.

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
19

So khớp nếu vị trí hiện tại trong chuỗi không được bắt đầu bằng khớp cho

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
82. Điều này được gọi là khẳng định nhìn phía sau tiêu cực. Tương tự như xác nhận giao diện tích cực, mẫu có trong chỉ phải khớp với các chuỗi có độ dài cố định. Các mẫu bắt đầu bằng các xác nhận về giao diện phủ định có thể khớp với phần đầu của chuỗi đang được tìm kiếm

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
21

Sẽ cố gắng khớp với

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
22 nếu nhóm có id hoặc tên đã cho tồn tại và với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
23 nếu không.
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
23 là tùy chọn và có thể bỏ qua. Ví dụ:
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
25 là mẫu khớp email kém, mẫu này sẽ khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
26 cũng như
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
27, nhưng không khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
28 hay
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
29

Không dùng nữa kể từ phiên bản 3. 11. ID nhóm chứa bất kỳ thứ gì ngoại trừ các chữ số ASCII.

Các chuỗi đặc biệt bao gồm

prog = re.compile(pattern)
result = prog.match(string)
4 và một ký tự từ danh sách bên dưới. Nếu ký tự thông thường không phải là chữ số ASCII hoặc chữ cái ASCII, thì RE kết quả sẽ khớp với ký tự thứ hai. Ví dụ:
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
31 khớp với ký tự
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
32

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
21

So khớp với nội dung của nhóm cùng số. Các nhóm được đánh số bắt đầu từ 1. Ví dụ:

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
34 khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
35 hoặc
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
36, nhưng không khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
37 (lưu ý khoảng trắng sau nhóm). Trình tự đặc biệt này chỉ có thể được sử dụng để khớp với một trong 99 nhóm đầu tiên. Nếu chữ số đầu tiên của số là 0 hoặc số có 3 chữ số bát phân, thì nó sẽ không được hiểu là khớp nhóm mà là ký tự có giá trị bát phân số. Bên trong
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
06 và
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
02 của một lớp ký tự, tất cả các số thoát được coi là ký tự

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
40

Chỉ khớp ở đầu chuỗi

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41

Khớp với chuỗi trống, nhưng chỉ ở đầu hoặc cuối của một từ. Một từ được định nghĩa là một chuỗi các ký tự từ. Lưu ý rằng chính thức,

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41 được định nghĩa là ranh giới giữa ký tự
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92 và ký tự
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
44 (hoặc ngược lại), hoặc giữa ký tự
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92 và phần đầu/cuối của chuỗi. Điều này có nghĩa là
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
46 khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
47,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
48,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
49,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
50 nhưng không khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
51 hoặc
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
52

Theo mặc định, chữ và số Unicode là những chữ cái được sử dụng trong các mẫu Unicode, nhưng điều này có thể được thay đổi bằng cách sử dụng cờ. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ được sử dụng. Bên trong một phạm vi ký tự,

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41 đại diện cho ký tự xóa lùi, để tương thích với chuỗi ký tự của Python

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
56

Khớp với chuỗi trống, nhưng chỉ khi nó không ở đầu hoặc cuối của một từ. Điều này có nghĩa là

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
57 khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
58,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
59,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
60, nhưng không khớp với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
61,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
62 hoặc
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
63.
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
56 hoàn toàn ngược lại với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41, vì vậy các ký tự từ trong mẫu Unicode là chữ và số Unicode hoặc dấu gạch dưới, mặc dù điều này có thể được thay đổi bằng cách sử dụng cờ. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ được sử dụng

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
68Đối với các mẫu Unicode (str)

Khớp với bất kỳ chữ số thập phân Unicode nào (nghĩa là bất kỳ ký tự nào trong danh mục ký tự Unicode [Nd]). Điều này bao gồm

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
69 và nhiều ký tự chữ số khác. Nếu cờ chỉ được sử dụng
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
69 được khớp

Đối với mẫu 8-bit (byte)

Khớp với bất kỳ chữ số thập phân nào;

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
73

Khớp với bất kỳ ký tự nào không phải là chữ số thập phân. Điều này trái ngược với

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
68. Nếu lá cờ được sử dụng, nó sẽ trở thành tương đương với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
76

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
77Đối với các mẫu Unicode (str)

So khớp các ký tự khoảng trắng Unicode (bao gồm

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
78 và nhiều ký tự khác, ví dụ: các khoảng trắng không ngắt bắt buộc theo quy tắc kiểu chữ trong nhiều ngôn ngữ). Nếu cờ được sử dụng, chỉ có
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
78 được khớp

Đối với mẫu 8-bit (byte)

Khớp các ký tự được coi là khoảng trắng trong bộ ký tự ASCII;

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
93

Khớp với bất kỳ ký tự nào không phải là ký tự khoảng trắng. Điều này trái ngược với

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
77. Nếu lá cờ được sử dụng, nó sẽ trở thành tương đương với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
85

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92Đối với các mẫu Unicode (str)

Khớp các ký tự từ Unicode; . Nếu cờ được sử dụng, chỉ có

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
90 được khớp

Đối với mẫu 8-bit (byte)

Khớp các ký tự được coi là chữ và số trong bộ ký tự ASCII; . Nếu cờ được sử dụng, khớp với các ký tự được coi là chữ và số ở ngôn ngữ hiện tại và dấu gạch dưới

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
44

Khớp với bất kỳ ký tự nào không phải là ký tự từ. Điều này trái ngược với

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92. Nếu lá cờ được sử dụng, nó sẽ trở thành tương đương với
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
96. Nếu cờ được sử dụng, khớp với các ký tự không phải là chữ và số trong ngôn ngữ hiện tại cũng như dấu gạch dưới

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
98

Chỉ khớp ở cuối chuỗi

Hầu hết các lối thoát tiêu chuẩn được hỗ trợ bởi các chuỗi ký tự Python cũng được trình phân tích cú pháp biểu thức chính quy chấp nhận

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\

(Lưu ý rằng

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41 được sử dụng để thể hiện ranh giới từ và có nghĩa là "xóa lùi" chỉ bên trong các lớp ký tự. )

Các chuỗi thoát

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
00,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
01 và
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
02 chỉ được nhận dạng trong các mẫu Unicode. Trong các mẫu byte, chúng là lỗi. Các ký tự ASCII thoát không xác định được dành riêng để sử dụng trong tương lai và được coi là lỗi

Thoát bát phân được bao gồm trong một hình thức hạn chế. Nếu chữ số đầu tiên là 0 hoặc nếu có ba chữ số bát phân, nó được coi là thoát bát phân. Mặt khác, nó là một tài liệu tham khảo nhóm. Đối với chuỗi ký tự, các dấu thoát bát phân luôn có độ dài tối đa là ba chữ số

Đã thay đổi trong phiên bản 3. 3. Trình tự thoát

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
00 và
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
01 đã được thêm vào.

Đã thay đổi trong phiên bản 3. 6. Các lối thoát không xác định bao gồm

prog = re.compile(pattern)
result = prog.match(string)
4 và một chữ cái ASCII hiện là lỗi.

Đã thay đổi trong phiên bản 3. 8. Trình tự thoát

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
06 đã được thêm vào. Như trong chuỗi ký tự, nó mở rộng thành ký tự Unicode được đặt tên (e. g.
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
07).

Nội dung mô-đun

Mô-đun xác định một số chức năng, hằng số và một ngoại lệ. Một số chức năng là phiên bản đơn giản hóa của các phương thức đầy đủ tính năng cho các biểu thức chính quy được biên dịch. Hầu hết các ứng dụng không tầm thường luôn sử dụng biểu mẫu được biên dịch

cờ

Đã thay đổi trong phiên bản 3. 6. Hằng số cờ hiện là thể hiện của , là lớp con của.

lớp lại. RegexFlag

Một lớp chứa các tùy chọn regex được liệt kê bên dưới

Mới trong phiên bản 3. 11. - được thêm vào

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
11

lại. Alại. ASCII

Đặt

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
44,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
56,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
68,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
73,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
77 và
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
93 thực hiện so khớp chỉ ASCII thay vì khớp Unicode đầy đủ. Điều này chỉ có ý nghĩa đối với các mẫu Unicode và bị bỏ qua đối với các mẫu byte. Tương ứng với cờ nội tuyến
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
20

Lưu ý rằng để tương thích ngược, cờ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
46 vẫn tồn tại (cũng như từ đồng nghĩa của nó là
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
22 và đối tác được nhúng của nó là
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
23), nhưng những thứ này là dư thừa trong Python 3 vì các kết quả khớp là Unicode theo mặc định cho các chuỗi (và kết hợp Unicode không được phép cho các byte

lại. GỠ LỖI

Hiển thị thông tin gỡ lỗi về biểu thức đã biên dịch. Không có cờ nội tuyến tương ứng

lại. Tôilại. BỎ QUA

Thực hiện khớp không phân biệt chữ hoa chữ thường; . Đối sánh Unicode đầy đủ (chẳng hạn như đối sánh

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
25
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
26) cũng hoạt động trừ khi cờ được sử dụng để vô hiệu hóa đối sánh không phải ASCII. Ngôn ngữ hiện tại không thay đổi tác dụng của cờ này trừ khi cờ cũng được sử dụng. Tương ứng với cờ nội tuyến
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
29

Lưu ý rằng khi các mẫu Unicode

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
77 hoặc
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
24 được sử dụng kết hợp với cờ, chúng sẽ khớp với 52 chữ cái ASCII và 4 chữ cái không phải ASCII bổ sung. 'İ' (U+0130, chữ cái Latinh viết hoa I có dấu chấm ở trên), 'ı' (U+0131, chữ cái nhỏ i không có dấu chấm trong tiếng Latinh), 'ſ' (U+017F, chữ cái nhỏ Latinh dài s) và 'K' . Nếu cờ được sử dụng, chỉ các chữ cái từ 'a' đến 'z' và 'A' đến 'Z' được khớp

lại. Llại. ĐỊA ĐIỂM

Thực hiện đối sánh

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
92,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
44,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
41,
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
56 và phân biệt chữ hoa chữ thường tùy thuộc vào ngôn ngữ hiện tại. Cờ này chỉ có thể được sử dụng với các mẫu byte. Việc sử dụng cờ này không được khuyến khích vì cơ chế ngôn ngữ rất không đáng tin cậy, nó chỉ xử lý một "văn hóa" tại một thời điểm và nó chỉ hoạt động với ngôn ngữ 8 bit. Kết hợp Unicode đã được bật theo mặc định trong Python 3 cho các mẫu Unicode (str) và nó có thể xử lý các ngôn ngữ/địa phương khác nhau. Tương ứng với cờ nội tuyến
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
38

Đã thay đổi trong phiên bản 3. 6. chỉ có thể được sử dụng với các mẫu byte và không tương thích với.

Đã thay đổi trong phiên bản 3. 7. Các đối tượng biểu thức chính quy được biên dịch với cờ không còn phụ thuộc vào ngôn ngữ tại thời điểm biên dịch. Chỉ ngôn ngữ tại thời điểm khớp mới ảnh hưởng đến kết quả khớp.

lại. Mlại. ĐA DÒNG

Khi được chỉ định, ký tự mẫu

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
96 khớp ở đầu chuỗi và đầu mỗi dòng (ngay sau mỗi dòng mới); . Theo mặc định,
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
96 chỉ khớp ở đầu chuỗi và
def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
32 chỉ khớp ở cuối chuỗi và ngay trước dòng mới (nếu có) ở cuối chuỗi. Tương ứng với cờ nội tuyến
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
46

lại. NOFLAG

Cho biết không có cờ nào được áp dụng, giá trị là

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
47. Cờ này có thể được sử dụng làm giá trị mặc định cho đối số từ khóa hàm hoặc làm giá trị cơ sở sẽ được ORed có điều kiện với các cờ khác. Ví dụ về việc sử dụng làm giá trị mặc định

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)

Mới trong phiên bản 3. 11

lại. Slại. DOTALL

Làm cho ký tự đặc biệt

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
48 khớp với bất kỳ ký tự nào, kể cả ký tự xuống dòng; . Tương ứng với cờ nội tuyến
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
50

lại. Xlại. ĐÁNH GIÁ

Cờ này cho phép bạn viết các biểu thức chính quy trông đẹp hơn và dễ đọc hơn bằng cách cho phép bạn tách các phần logic của mẫu một cách trực quan và thêm nhận xét. Khoảng trắng trong mẫu được bỏ qua, ngoại trừ khi ở trong một lớp ký tự hoặc khi được đặt trước dấu gạch chéo ngược không thoát hoặc trong các mã thông báo như

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
01,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
52 hoặc
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
53. Ví dụ: không được phép sử dụng
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
54 và
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
55. Khi một dòng chứa
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
56 không thuộc lớp ký tự và không có dấu gạch chéo ngược không thoát ở trước, thì tất cả các ký tự từ ngoài cùng bên trái chẳng hạn như
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
56 đến cuối dòng đều bị bỏ qua

Điều này có nghĩa là hai đối tượng biểu thức chính quy sau khớp với một số thập phân có chức năng bằng nhau

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

Tương ứng với cờ nội tuyến

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
58

Chức năng

lại. biên dịch(mẫu , cờ=0)

Biên dịch một mẫu biểu thức chính quy thành một , có thể được sử dụng để so khớp bằng các phương thức của nó và các phương thức khác, được mô tả bên dưới

Hành vi của biểu thức có thể được sửa đổi bằng cách chỉ định giá trị cờ. Các giá trị có thể là bất kỳ biến nào sau đây, được kết hợp bằng cách sử dụng bitwise OR (toán tử

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
12)

Trình tự

prog = re.compile(pattern)
result = prog.match(string)

tương đương với

________số 8_______

nhưng việc sử dụng và lưu đối tượng biểu thức chính quy kết quả để sử dụng lại sẽ hiệu quả hơn khi biểu thức sẽ được sử dụng nhiều lần trong một chương trình

Ghi chú

Các phiên bản đã biên dịch của các mẫu gần đây nhất được chuyển đến và các hàm so khớp ở cấp độ mô-đun được lưu vào bộ đệm, vì vậy các chương trình chỉ sử dụng một vài biểu thức chính quy tại một thời điểm không cần phải lo lắng về việc biên dịch các biểu thức chính quy

lại. tìm kiếm(mẫu , chuỗi, flags=0)

Quét qua chuỗi để tìm vị trí đầu tiên nơi mẫu biểu thức chính quy tạo ra kết quả khớp và trả về giá trị tương ứng. Trả về

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu không có vị trí nào trong chuỗi khớp với mẫu;

lại. khớp(mẫu , chuỗi, flags=0)

Nếu không hoặc nhiều ký tự ở đầu chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một ký tự tương ứng. Trả về

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu chuỗi không khớp với mẫu;

Lưu ý rằng ngay cả trong chế độ, sẽ chỉ khớp ở đầu chuỗi chứ không khớp ở đầu mỗi dòng

Nếu bạn muốn xác định vị trí khớp ở bất kỳ đâu trong chuỗi, hãy sử dụng thay thế (xem thêm)

lại. trọn bộ(mẫu , chuỗi, flags=0)

Nếu toàn bộ chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một giá trị tương ứng. Trả lại

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu chuỗi không khớp với mẫu;

Mới trong phiên bản 3. 4

lại. tách(mẫu , chuỗi, maxsplit=0, flags=0)

Tách chuỗi theo số lần xuất hiện của mẫu. Nếu chụp dấu ngoặc đơn được sử dụng trong mẫu, thì văn bản của tất cả các nhóm trong mẫu cũng được trả về như một phần của danh sách kết quả. Nếu maxsplit khác không, thì tối đa các lần tách maxsplit xảy ra và phần còn lại của chuỗi được trả về dưới dạng phần tử cuối cùng của danh sách

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

Nếu có các nhóm bắt giữ trong dấu tách và nó khớp ở đầu chuỗi, thì kết quả sẽ bắt đầu bằng một chuỗi trống. Điều tương tự cũng xảy ra với phần cuối của chuỗi

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

Bằng cách đó, các thành phần phân cách luôn được tìm thấy ở cùng một chỉ số tương đối trong danh sách kết quả

Các kết quả khớp trống cho mẫu chỉ tách chuỗi khi không liền kề với kết quả khớp trống trước đó

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ tách trên một mẫu có thể khớp với một chuỗi trống.

lại. tìm tất cả(mẫu , chuỗi, flags=0)

Trả về tất cả các mẫu trùng khớp không chồng chéo trong chuỗi, dưới dạng danh sách các chuỗi hoặc bộ. Chuỗi được quét từ trái sang phải và kết quả khớp được trả về theo thứ tự tìm thấy. Các trận đấu trống được bao gồm trong kết quả

Kết quả phụ thuộc vào số lượng nhóm chụp trong mẫu. Nếu không có nhóm nào, hãy trả về danh sách các chuỗi khớp với toàn bộ mẫu. Nếu có chính xác một nhóm, hãy trả về danh sách các chuỗi khớp với nhóm đó. Nếu có nhiều nhóm, hãy trả về danh sách các bộ chuỗi khớp với các nhóm. Các nhóm không chụp không ảnh hưởng đến hình thức của kết quả

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
0

Đã thay đổi trong phiên bản 3. 7. Các trận đấu không trống giờ đây có thể bắt đầu ngay sau trận đấu trống trước đó.

lại. công cụ tìm(mẫu , chuỗi, flags=0)

Trả về năng suất trên tất cả các kết quả khớp không trùng lặp cho mẫu RE trong chuỗi. Chuỗi được quét từ trái sang phải và kết quả khớp được trả về theo thứ tự tìm thấy. Các trận đấu trống được bao gồm trong kết quả

Đã thay đổi trong phiên bản 3. 7. Các trận đấu không trống giờ đây có thể bắt đầu ngay sau trận đấu trống trước đó.

lại. phụ(mẫu , thay thế, string, count=0, flags=0)

Trả về chuỗi thu được bằng cách thay thế các lần xuất hiện mẫu không chồng chéo ngoài cùng bên trái trong chuỗi bằng thay thế thay thế. Nếu không tìm thấy mẫu, chuỗi được trả về không thay đổi. repl có thể là một chuỗi hoặc một hàm; . Nghĩa là,

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
70 được chuyển đổi thành một ký tự dòng mới,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
71 được chuyển đổi thành ký tự xuống dòng, v.v. Các ký tự ASCII thoát không xác định được dành riêng để sử dụng trong tương lai và được coi là lỗi. Các lối thoát không xác định khác như
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
72 bị bỏ lại một mình. Các tham chiếu ngược, chẳng hạn như
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
73, được thay thế bằng chuỗi con khớp với nhóm 6 trong mẫu. Ví dụ

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
1

Nếu thay thế là một chức năng, nó được gọi cho mọi lần xuất hiện mẫu không chồng chéo. Hàm nhận một đối số duy nhất và trả về chuỗi thay thế. Ví dụ

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
2

Mẫu có thể là một chuỗi hoặc một

Số lượng đối số tùy chọn là số lần xuất hiện mẫu tối đa được thay thế; . Nếu bị bỏ qua hoặc bằng không, tất cả các lần xuất hiện sẽ được thay thế. Các kết quả phù hợp trống cho mẫu chỉ được thay thế khi không liền kề với kết quả phù hợp trống trước đó, do đó,

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
74 trả về
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
75

Trong các đối số thay thế kiểu chuỗi, ngoài các ký tự thoát và tham chiếu ngược được mô tả ở trên,

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
76 sẽ sử dụng chuỗi con khớp với nhóm có tên
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
77, như được xác định bởi cú pháp
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
32.
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
79 sử dụng số nhóm tương ứng; .
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
83 sẽ được hiểu là tham chiếu đến nhóm 20, không phải tham chiếu đến nhóm 2 theo sau là ký tự chữ
result = re.match(pattern, string)
8. Tham chiếu ngược
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
85 thay thế trong toàn bộ chuỗi con khớp với RE

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 5. Các nhóm không khớp được thay thế bằng một chuỗi rỗng.

Đã thay đổi trong phiên bản 3. 6. Các lối thoát không xác định trong mẫu bao gồm

prog = re.compile(pattern)
result = prog.match(string)
4 và một chữ cái ASCII hiện là lỗi.

Đã thay đổi trong phiên bản 3. 7. Các lối thoát không xác định trong bản thay thế bao gồm

prog = re.compile(pattern)
result = prog.match(string)
4 và một chữ cái ASCII hiện là lỗi.

Đã thay đổi trong phiên bản 3. 7. Các kết quả khớp trống cho mẫu được thay thế khi liền kề với kết quả khớp không trống trước đó.

Không dùng nữa kể từ phiên bản 3. 11. ID nhóm chứa bất kỳ thứ gì ngoại trừ các chữ số ASCII. Tên nhóm chứa các ký tự không phải ASCII trong chuỗi thay thế byte.

lại. subn(mẫu , thay thế, string, count=0, flags=0)

Thực hiện thao tác tương tự như , nhưng trả về một tuple

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
89

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 5. Các nhóm không khớp được thay thế bằng một chuỗi rỗng.

lại. thoát(mẫu)

Thoát các ký tự đặc biệt trong mẫu. Điều này hữu ích nếu bạn muốn khớp một chuỗi ký tự tùy ý có thể có các ký tự đại diện của biểu thức chính quy trong đó. Ví dụ

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
3

Hàm này không được sử dụng cho chuỗi thay thế trong và , chỉ nên thoát dấu gạch chéo ngược. Ví dụ

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
4

Changed in version 3. 3. The

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
92 character is no longer escaped.

Changed in version 3. 7. Only characters that can have special meaning in a regular expression are escaped. As a result,

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
93,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
94,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
95,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
96,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
97,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
98,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
99,
prog = re.compile(pattern)
result = prog.match(string)
00,
prog = re.compile(pattern)
result = prog.match(string)
01,
prog = re.compile(pattern)
result = prog.match(string)
02,
prog = re.compile(pattern)
result = prog.match(string)
03,
prog = re.compile(pattern)
result = prog.match(string)
04, and
prog = re.compile(pattern)
result = prog.match(string)
05 are no longer escaped.

re. purge()

Clear the regular expression cache

Exceptions

exception re. error(msg , pattern=None , pos=None)

Exception raised when a string passed to one of the functions here is not a valid regular expression (for example, it might contain unmatched parentheses) or when some other error occurs during compilation or matching. It is never an error if a string contains no match for a pattern. The error instance has the following additional attributes

msg

The unformatted error message

pattern

The regular expression pattern

pos

The index in pattern where compilation failed (may be

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64)

lineno

The line corresponding to pos (may be

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64)

colno

The column corresponding to pos (may be

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64)

Changed in version 3. 5. Added additional attributes.

Regular Expression Objects

Compiled regular expression objects support the following methods and attributes

Pattern. search(string[ , pos[ , endpos]])

Scan through string looking for the first location where this regular expression produces a match, and return a corresponding . Return

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string

The optional second parameter pos gives an index in the string where the search is to start; it defaults to

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
47. This is not completely equivalent to slicing the string; the
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
96 pattern character matches at the real beginning of the string and at positions just after a newline, but not necessarily at the index where the search is to start

The optional parameter endpos limits how far the string will be searched; it will be as if the string is endpos characters long, so only the characters from pos to

prog = re.compile(pattern)
result = prog.match(string)
12 will be searched for a match. If endpos is less than pos, no match will be found; otherwise, if rx is a compiled regular expression object,
prog = re.compile(pattern)
result = prog.match(string)
13 is equivalent to
prog = re.compile(pattern)
result = prog.match(string)
14

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
5

Pattern. match(string[ , pos[ , endpos]])

If zero or more characters at the beginning of string match this regular expression, return a corresponding . Return

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 if the string does not match the pattern; note that this is different from a zero-length match

The optional pos and endpos parameters have the same meaning as for the method

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
6

Nếu bạn muốn xác định vị trí khớp ở bất kỳ đâu trong chuỗi, hãy sử dụng thay thế (xem thêm)

Pattern. fullmatch(string[ , pos[ , endpos]])

Nếu toàn bộ chuỗi khớp với biểu thức chính quy này, hãy trả về một giá trị tương ứng. Trả về

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu chuỗi không khớp với mẫu;

The optional pos and endpos parameters have the same meaning as for the method

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
7

Mới trong phiên bản 3. 4

Pattern. split(string , maxsplit=0)

Identical to the function, using the compiled pattern

Pattern. findall(string[ , pos[ , endpos]])

Similar to the function, using the compiled pattern, but also accepts optional pos and endpos parameters that limit the search region like for

Pattern. công cụ tìm(chuỗi[ , pos[, endpos]])

Similar to the function, using the compiled pattern, but also accepts optional pos and endpos parameters that limit the search region like for

Pattern. sub(repl , chuỗi, count=0)

Identical to the function, using the compiled pattern

Mẫu. subn(repl , chuỗi, count=0)

Identical to the function, using the compiled pattern

Mẫu. cờ

Các cờ phù hợp với regex. Đây là sự kết hợp của các cờ được cung cấp cho , bất kỳ cờ nội tuyến

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
28 nào trong mẫu và các cờ ẩn như
prog = re.compile(pattern)
result = prog.match(string)
29 nếu mẫu là một chuỗi Unicode

Mẫu. nhóm

Số lượng nhóm chụp trong mẫu

Mẫu. chỉ mục nhóm

Một từ điển ánh xạ bất kỳ tên nhóm tượng trưng nào được xác định bởi

prog = re.compile(pattern)
result = prog.match(string)
30 thành số nhóm. Từ điển trống nếu không có nhóm ký hiệu nào được sử dụng trong mẫu

Mẫu. mẫu

Chuỗi mẫu mà từ đó đối tượng mẫu được biên dịch

Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ và. Các đối tượng biểu thức chính quy được biên dịch được coi là nguyên tử.

đối tượng phù hợp

Các đối tượng khớp luôn có giá trị boolean là

prog = re.compile(pattern)
result = prog.match(string)
33. Vì và trả về
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 khi không có kết quả khớp, bạn có thể kiểm tra xem có kết quả khớp hay không bằng một câu lệnh
prog = re.compile(pattern)
result = prog.match(string)
37 đơn giản

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
8

Các đối tượng khớp hỗ trợ các phương thức và thuộc tính sau

Trùng khớp. mở rộng(mẫu)

Trả về chuỗi thu được bằng cách thực hiện thay thế dấu gạch chéo ngược trên mẫu chuỗi mẫu, như được thực hiện bởi phương thức. Các lối thoát như

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
70 được chuyển đổi thành các ký tự thích hợp và các tham chiếu ngược dạng số (
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
90,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
81) và các tham chiếu ngược có tên (
\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
95,
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
76) được thay thế bằng nội dung của nhóm tương ứng

Đã thay đổi trong phiên bản 3. 5. Các nhóm không khớp được thay thế bằng một chuỗi rỗng.

Trùng khớp. nhóm([nhóm1 , . ...])

Trả về một hoặc nhiều nhóm con của trận đấu. Nếu có một đối số duy nhất, kết quả là một chuỗi duy nhất; . Không có đối số, nhóm1 mặc định bằng 0 (toàn bộ kết quả khớp được trả về). Nếu đối số groupN bằng 0, thì giá trị trả về tương ứng là toàn bộ chuỗi phù hợp; . 99], đó là chuỗi khớp với nhóm được đặt trong ngoặc đơn tương ứng. Nếu số nhóm âm hoặc lớn hơn số nhóm được xác định trong mẫu, một ngoại lệ sẽ được đưa ra. Nếu một nhóm được chứa trong một phần của mẫu không khớp, thì kết quả tương ứng là

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64. Nếu một nhóm được chứa trong một phần của mẫu khớp nhiều lần, thì kết quả khớp cuối cùng sẽ được trả về

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
9

Nếu biểu thức chính quy sử dụng cú pháp

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
32, các đối số nhómN cũng có thể là các chuỗi xác định các nhóm theo tên nhóm của chúng. Nếu một đối số chuỗi không được sử dụng làm tên nhóm trong mẫu, một ngoại lệ sẽ được đưa ra

Một ví dụ phức tạp vừa phải

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
0

Các nhóm được đặt tên cũng có thể được gọi bằng chỉ số của họ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
1

Nếu một nhóm trùng khớp nhiều lần, thì chỉ có thể truy cập được lần trùng khớp cuối cùng

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
2

Trùng khớp. __getitem__(g)

Điều này giống hệt với

prog = re.compile(pattern)
result = prog.match(string)
48. Điều này cho phép truy cập dễ dàng hơn vào một nhóm riêng lẻ từ một trận đấu

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
3

Các nhóm được đặt tên cũng được hỗ trợ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
4

Mới trong phiên bản 3. 6

Trùng khớp. nhóm(mặc định=Không)

Trả về một bộ chứa tất cả các nhóm con của trận đấu, từ 1 cho đến bao nhiêu nhóm trong mẫu. Đối số mặc định được sử dụng cho các nhóm không tham gia trận đấu;

Ví dụ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
5

Nếu chúng tôi đặt vị trí thập phân và mọi thứ sau nó là tùy chọn, thì không phải tất cả các nhóm đều có thể tham gia trận đấu. Các nhóm này sẽ mặc định là

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 trừ khi đối số mặc định được đưa ra

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
6

Trùng khớp. groupdict(mặc định=Không)

Trả về một từ điển chứa tất cả các nhóm con được đặt tên của trận đấu, được khóa bởi tên nhóm con. Đối số mặc định được sử dụng cho các nhóm không tham gia trận đấu; . Ví dụ

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
7

Trùng khớp. bắt đầu([nhóm] . )Match.kết thúc([nhóm])

Trả về các chỉ số bắt đầu và kết thúc của chuỗi con được khớp theo nhóm; . Trả lại

prog = re.compile(pattern)
result = prog.match(string)
52 nếu nhóm tồn tại nhưng không đóng góp vào trận đấu. Đối với một đối tượng khớp m và một nhóm g đã đóng góp vào khớp, chuỗi con khớp với nhóm g (tương đương với
prog = re.compile(pattern)
result = prog.match(string)
48) là

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
8

Lưu ý rằng

prog = re.compile(pattern)
result = prog.match(string)
54 sẽ bằng
prog = re.compile(pattern)
result = prog.match(string)
55 nếu nhóm khớp với chuỗi rỗng. Ví dụ: sau
prog = re.compile(pattern)
result = prog.match(string)
56,
prog = re.compile(pattern)
result = prog.match(string)
57 là 1,
prog = re.compile(pattern)
result = prog.match(string)
58 là 2,
prog = re.compile(pattern)
result = prog.match(string)
59 và
prog = re.compile(pattern)
result = prog.match(string)
60 đều là 2 và
prog = re.compile(pattern)
result = prog.match(string)
61 đưa ra một ngoại lệ

Một ví dụ sẽ xóa remove_this khỏi địa chỉ email

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\
9

Trùng khớp. span([nhóm])

Đối với một trận đấu m, trả về 2-tuple

prog = re.compile(pattern)
result = prog.match(string)
63. Lưu ý rằng nếu nhóm không đóng góp vào trận đấu, đây là
prog = re.compile(pattern)
result = prog.match(string)
64. nhóm mặc định là 0, toàn bộ trận đấu

Trùng khớp. tư thế

Giá trị của pos được truyền cho phương thức hoặc của một. Đây là chỉ mục trong chuỗi mà tại đó công cụ RE bắt đầu tìm kiếm kết quả khớp

Trùng khớp. endpos

Giá trị của endpos được truyền cho phương thức hoặc của một. Đây là chỉ mục vào chuỗi mà công cụ RE sẽ không hoạt động

Trùng khớp. lastindex

Chỉ số số nguyên của nhóm bắt giữ phù hợp cuối cùng hoặc

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu không có nhóm nào phù hợp cả. Ví dụ: các biểu thức
prog = re.compile(pattern)
result = prog.match(string)
70,
prog = re.compile(pattern)
result = prog.match(string)
71 và
prog = re.compile(pattern)
result = prog.match(string)
72 sẽ có
prog = re.compile(pattern)
result = prog.match(string)
73 nếu được áp dụng cho chuỗi
prog = re.compile(pattern)
result = prog.match(string)
74, trong khi biểu thức
prog = re.compile(pattern)
result = prog.match(string)
75 sẽ có
prog = re.compile(pattern)
result = prog.match(string)
76 nếu được áp dụng cho cùng một chuỗi

Trùng khớp. nhóm cuối cùng

Tên của nhóm bắt giữ phù hợp cuối cùng hoặc

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
64 nếu nhóm không có tên hoặc nếu không có nhóm nào phù hợp cả

Trùng khớp. lại

Người hoặc phương thức đã tạo ra trường hợp đối sánh này

Trùng khớp. chuỗi

Chuỗi được chuyển đến hoặc

Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ và. Các đối tượng phù hợp được coi là nguyên tử.

Ví dụ biểu thức chính quy

Kiểm tra một cặp

Trong ví dụ này, chúng ta sẽ sử dụng hàm trợ giúp sau để hiển thị các đối tượng khớp một cách duyên dáng hơn một chút

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
0

Giả sử bạn đang viết một chương trình chơi bài xì phé trong đó ván bài của người chơi được biểu diễn dưới dạng một chuỗi 5 ký tự với mỗi ký tự đại diện cho một lá bài, “a” cho quân át, “k” cho quân vua, “q” cho quân hậu, “j” cho quân jack,

Để xem một chuỗi đã cho có phải là một ván bài hợp lệ hay không, người ta có thể làm như sau

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
1

Bàn tay cuối cùng đó,

prog = re.compile(pattern)
result = prog.match(string)
84, chứa một cặp hoặc hai quân bài có giá trị giống nhau. Để khớp điều này với một biểu thức chính quy, người ta có thể sử dụng phản hồi như vậy

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
2

Để tìm ra cặp thẻ bao gồm những gì, người ta có thể sử dụng phương thức của đối tượng khớp theo cách sau

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
3

Mô phỏng scanf()

Python hiện không có tương đương với

prog = re.compile(pattern)
result = prog.match(string)
86. Biểu thức chính quy thường mạnh hơn, mặc dù cũng dài dòng hơn, so với chuỗi định dạng
prog = re.compile(pattern)
result = prog.match(string)
86. Bảng bên dưới cung cấp một số ánh xạ tương đương ít nhiều giữa mã thông báo định dạng
prog = re.compile(pattern)
result = prog.match(string)
86 và biểu thức chính quy

prog = re.compile(pattern)
result = prog.match(string)
86 Mã thông báo

Biểu hiện thông thường

prog = re.compile(pattern)
result = prog.match(string)
90

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
2

prog = re.compile(pattern)
result = prog.match(string)
92

prog = re.compile(pattern)
result = prog.match(string)
93

prog = re.compile(pattern)
result = prog.match(string)
94

prog = re.compile(pattern)
result = prog.match(string)
95

prog = re.compile(pattern)
result = prog.match(string)
96,
prog = re.compile(pattern)
result = prog.match(string)
97,
prog = re.compile(pattern)
result = prog.match(string)
98,
prog = re.compile(pattern)
result = prog.match(string)
99

result = re.match(pattern, string)
00

result = re.match(pattern, string)
01

result = re.match(pattern, string)
02

result = re.match(pattern, string)
03

result = re.match(pattern, string)
04

result = re.match(pattern, string)
05

result = re.match(pattern, string)
06

result = re.match(pattern, string)
07

result = re.match(pattern, string)
08

result = re.match(pattern, string)
09,
result = re.match(pattern, string)
10

result = re.match(pattern, string)
11

Để trích xuất tên tệp và số từ một chuỗi như

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
4

bạn sẽ sử dụng định dạng

prog = re.compile(pattern)
result = prog.match(string)
86 như

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
5

Biểu thức chính quy tương đương sẽ là

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
6

tìm kiếm () so với. cuộc thi đấu()

Python cung cấp các hoạt động nguyên thủy khác nhau dựa trên các biểu thức chính quy

  • chỉ kiểm tra sự trùng khớp ở đầu chuỗi

  • kiểm tra sự trùng khớp ở bất kỳ đâu trong chuỗi (đây là điều mà Perl thực hiện theo mặc định)

  • kiểm tra xem toàn bộ chuỗi có khớp không

Ví dụ

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
7

Có thể sử dụng biểu thức chính quy bắt đầu bằng

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
96 để hạn chế khớp ở đầu chuỗi

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
8

Tuy nhiên, lưu ý rằng trong chế độ chỉ khớp ở đầu chuỗi, trong khi sử dụng với biểu thức chính quy bắt đầu bằng

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
96 sẽ khớp ở đầu mỗi dòng

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)
9

Lập danh bạ

tách một chuỗi thành một danh sách được phân định bởi mẫu đã truyền. Phương pháp này là vô giá để chuyển đổi dữ liệu văn bản thành cấu trúc dữ liệu mà Python có thể dễ dàng đọc và sửa đổi như được minh họa trong ví dụ sau để tạo danh bạ

Đầu tiên, đây là đầu vào. Thông thường, nó có thể đến từ một tệp, ở đây chúng tôi đang sử dụng cú pháp chuỗi trích dẫn ba lần

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
0

Các mục được phân tách bằng một hoặc nhiều dòng mới. Bây giờ chúng tôi chuyển đổi chuỗi thành một danh sách với mỗi dòng không trống có mục nhập riêng

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
1

Cuối cùng, chia từng mục thành một danh sách có tên, họ, số điện thoại và địa chỉ. Chúng tôi sử dụng tham số

result = re.match(pattern, string)
23 vì địa chỉ có dấu cách, mẫu phân tách của chúng tôi, trong đó

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
2

Mẫu

result = re.match(pattern, string)
25 khớp với dấu hai chấm sau họ, để nó không xuất hiện trong danh sách kết quả. Với
result = re.match(pattern, string)
23 của
result = re.match(pattern, string)
27, chúng tôi có thể tách số nhà khỏi tên đường

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
3

Nhắn tin

thay thế mọi lần xuất hiện của một mẫu bằng một chuỗi hoặc kết quả của một hàm. Ví dụ này minh họa việc sử dụng chức năng để “chuyển đổi” văn bản hoặc sắp xếp ngẫu nhiên thứ tự của tất cả các ký tự trong mỗi từ của câu ngoại trừ ký tự đầu tiên và ký tự cuối cùng

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
4

Tìm tất cả trạng từ

khớp với tất cả các lần xuất hiện của một mẫu, không chỉ mẫu đầu tiên như hiện tại. Ví dụ: nếu một người viết muốn tìm tất cả các trạng từ trong một số văn bản, họ có thể sử dụng theo cách sau

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
5

Tìm tất cả các trạng từ và vị trí của chúng

Nếu một người muốn biết thêm thông tin về tất cả các kết quả khớp của một mẫu so với văn bản khớp, sẽ hữu ích vì nó cung cấp thay vì các chuỗi. Tiếp tục với ví dụ trước, nếu người viết muốn tìm tất cả các trạng từ và vị trí của chúng trong một số văn bản, họ sẽ sử dụng theo cách sau

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
6

Ký hiệu chuỗi thô

Ký hiệu chuỗi thô (

result = re.match(pattern, string)
35) giữ cho biểu thức chính quy lành mạnh. Không có nó, mọi dấu gạch chéo ngược (
prog = re.compile(pattern)
result = prog.match(string)
4) trong một biểu thức chính quy sẽ phải được đặt trước bằng một dấu gạch chéo ngược khác để thoát khỏi nó. Ví dụ: hai dòng mã sau giống hệt nhau về mặt chức năng

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
7

Khi một người muốn khớp dấu gạch chéo ngược theo nghĩa đen, nó phải được thoát trong biểu thức chính quy. Với ký hiệu chuỗi thô, điều này có nghĩa là

result = re.match(pattern, string)
37. Không có ký hiệu chuỗi thô, người ta phải sử dụng
result = re.match(pattern, string)
38, làm cho các dòng mã sau giống hệt nhau về mặt chức năng

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
8

Viết mã thông báo

Trình mã thông báo hoặc trình quét phân tích một chuỗi để phân loại các nhóm ký tự. Đây là bước đầu tiên hữu ích trong việc viết trình biên dịch hoặc trình thông dịch

Các loại văn bản được chỉ định với các biểu thức chính quy. Kỹ thuật này là kết hợp chúng thành một biểu thức chính quy duy nhất và lặp lại các kết quả khớp liên tiếp

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
9

Trình mã thông báo tạo đầu ra sau

prog = re.compile(pattern)
result = prog.match(string)
0

Friedl, Jeffrey. Nắm vững các biểu thức chính quy. tái bản lần 3. , O'Reilly Media, 2009. Ấn bản thứ ba của cuốn sách không còn đề cập đến Python nữa, nhưng ấn bản đầu tiên đề cập đến việc viết các mẫu biểu thức chính quy rất chi tiết

Ranh giới từ trong regex Python là gì?

Ranh giới từ là kiểm tra độ rộng bằng 0 giữa hai ký tự . Để vượt qua bài kiểm tra, phải có một ký tự từ ở một bên và một ký tự không phải từ ở phía bên kia. Mỗi nhân vật xuất hiện ở bên nào không quan trọng, nhưng phải có một trong mỗi.

\b trong regex Python là gì?

Bên trong một phạm vi ký tự, \b đại diện cho ký tự xóa lùi , để tương thích với chuỗi ký tự của Python. Khớp với chuỗi trống, nhưng chỉ khi nó không ở đầu hoặc cuối của một từ.

\W trong regex Python là gì?

\w -- (chữ thường w) khớp với ký tự "từ" . một chữ cái hoặc chữ số hoặc gạch dưới [a-zA-Z0-9_]. Lưu ý rằng mặc dù "từ" là cách ghi nhớ cho điều này, nhưng nó chỉ khớp với một từ duy nhất char, không phải toàn bộ từ. \W (chữ hoa W) khớp với bất kỳ ký tự không phải từ nào. \b -- ranh giới giữa từ và phi từ.

\b trong biểu thức chính quy là gì?

Dấu \b siêu ký tự trùng ở đầu hoặc cuối của một từ .