`re` --- Hoạt động biểu thức chính quy¶

Source code: Lib/re/

Mô-đun này cung cấp các hoạt động khớp biểu thức chính quy tương tự như các hoạt động được tìm thấy trong Perl.

Cả mẫu và chuỗi cần tìm kiếm đều có thể là chuỗi Unicode (str) cũng như chuỗi 8 bit (bytes). 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 chuỗi Unicode với mẫu byte hoặc ngược lại; tương tự, khi yêu cầu thay thế, chuỗi thay thế phải cùng loại với cả mẫu và chuỗi tìm kiếm.

Biểu thức chính quy sử dụng ký tự dấu gạch chéo ngược ('\') để 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ự; ví dụ: để khớp với dấu gạch chéo ngược theo nghĩa đen, người ta có thể phải viết '\\\\' làm chuỗi mẫu, vì biểu thức chính quy phải là \\ và mỗi dấu gạch chéo ngược phải được biểu thị dưới dạng \\ bên trong một chuỗi ký tự Python thông thường. Ngoài ra, xin lưu ý rằng bất kỳ chuỗi thoát không hợp lệ nào trong việc sử dụng dấu gạch chéo ngược trong chuỗi ký tự của Python giờ đây sẽ tạo ra một SyntaxWarning và trong tương lai, nó sẽ trở thành một SyntaxError. Hành vi này sẽ xảy ra ngay cả khi đó là chuỗi thoát hợp lệ cho 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; dấu gạch chéo ngược không được xử lý theo bất kỳ cách đặc biệt nào trong một chuỗi ký tự có tiền tố là 'r'. Vì vậy, r"\n" là chuỗi hai ký tự chứa '\' và 'n', trong khi "\n" 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 compiled regular expressions. Các hàm này là các phím tắt không yêu cầu bạn phải 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 regex của bên thứ ba, có API tương thích với mô-đun re của thư viện tiêu 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¶

Biểu thức chính quy (hoặc RE) chỉ định một tập hợp các chuỗi khớp với nó; Các hàm trong mô-đun này cho phép bạn kiểm tra xem một chuỗi cụ thể có khớp với một biểu thức chính quy nhất định hay không (hoặc liệu một biểu thức chính quy đã cho có khớp với một chuỗi cụ thể hay không, dẫn đến cùng một điều).

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ếu A và B đều là biểu thức chính quy thì AB cũng là biểu thức chính quy. Nói chung, nếu một chuỗi p khớp với A và một chuỗi khác q 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 có mức độ ưu tiên thấp; điều kiện biên giữa A và B; hoặc có tài liệu tham khảo nhóm được đánh số. 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ư những 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 [Frie09], 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à phần 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 HOWTO.

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ư 'A', 'a' hoặc '0', là những biểu thức chính quy đơn giản nhất; họ chỉ đơn giản là phù hợp với chính mình. Bạn có thể ghép các ký tự thông thường để last khớp với chuỗi 'last'. (Trong phần còn lại của phần này, chúng ta sẽ viết RE bằng this special style, thường không có dấu ngoặc kép và các chuỗi phải khớp với 'in single quotes'.)

Một số ký tự, như '|' hoặc '(', rất đặ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 (*, +, ?, {m,n}, v.v.) không thể đượ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 ? và với cá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, có thể sử dụng dấu ngoặc đơn. Ví dụ: biểu thức (?:a{6})* khớp với bất kỳ bội số nào trong số sáu ký tự 'a'.

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

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

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

$: 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à ở chế độ MULTILINE cũng khớp trước một dòng mới. foo khớp với cả 'foo' và 'foobar', trong khi biểu thức chính quy foo$ chỉ khớp với 'foo'. Thú vị hơn, việc tìm kiếm foo.$ trong 'foo1\nfoo2\n' thường khớp với 'foo2', nhưng 'foo1' ở chế độ MULTILINE; tìm kiếm một $ duy nhất trong 'foo\n' sẽ tìm thấy hai kết quả phù hợp (trống): một kết quả ngay trước dòng mới và một kết quả ở cuối chuỗi.

*: 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. ab* sẽ khớp với 'a', 'ab' hoặc 'a' theo sau là bất kỳ số 'b' nào.

+: 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 đó. ab+ sẽ khớp với 'a' theo sau là bất kỳ số 'b' nào khác 0; nó sẽ không khớp với chỉ 'a'.

?: 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 đó. ab? sẽ khớp với 'a' hoặc 'ab'.

*?, +?, ??: Các bộ định lượng '*', '+' và '?' đều là greedy; chúng khớp với càng nhiều văn bản càng tốt. Đôi khi hành vi này không được mong muốn; nếu RE <.*> được khớp với '<a> b <c>', nó sẽ khớp với toàn bộ chuỗi chứ không chỉ '<a>'. Việc thêm ? sau bộ định lượng sẽ làm cho nó thực hiện khớp theo kiểu non-greedy hoặc minimal; càng nhiều ký tự few càng tốt sẽ được khớp. Sử dụng RE <.*?> sẽ chỉ khớp với '<a>'.

*+, ++, ?+: Giống như các bộ định lượng '*', '+' và '?', những bộ định lượng mà '+' được thêm vào cũng khớp nhiều lần nhất có thể. Tuy nhiên, không giống như các bộ lượng hóa tham lam thực sự, các bộ lượng hóa tham lam này 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à bộ định lượng possessive. Ví dụ: a*a sẽ khớp với 'aaaa' vì a* sẽ khớp với tất cả 4 'a', nhưng khi gặp 'a' cuối cùng, biểu thức sẽ được quay lui để cuối cùng a* khớp với tổng cộng 3 'a' và 'a' thứ tư được khớp với 'a' cuối cùng. Tuy nhiên, khi a*+a được sử dụng để khớp với 'aaaa' thì a*+ sẽ khớp với cả 4 'a', nhưng khi 'a' cuối cùng không tìm thấy thêm ký tự nào để khớp thì biểu thức không thể quay lui và do đó sẽ không khớp. x*+, x++ và x?+ tương ứng với (?>x*), (?>x+) và (?>x?).

Added in version 3.11.

{m}: Chỉ định rằng các bản sao m của RE trước đó phải khớp chính xác; ít trận đấu hơn khiến toàn bộ RE không khớp. Ví dụ: a{6} sẽ khớp chính xác sáu ký tự 'a' chứ không phải năm ký tự.
{m,n}: Làm cho RE kết quả khớp từ các lần lặp lại m đến n 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ụ: a{3,5} sẽ khớp từ 3 đến 5 ký tự 'a'. Bỏ qua m chỉ định giới hạn dưới của 0 và bỏ qua n chỉ định giới hạn trên vô hạn. Ví dụ: a{4,}b sẽ khớp với 'aaaab' hoặc một nghìn ký tự 'a' theo sau là 'b', nhưng không khớp với 'aaab'. Không được bỏ qua dấu phẩy nếu không từ bổ nghĩa sẽ bị nhầm lẫn với dạng được mô tả trước đó.
{m,n}?: Làm cho RE kết quả khớp từ các lần lặp lại m đến n của RE trước đó, cố gắng khớp càng nhiều lần lặp lại few 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ự 'aaaaaa', a{3,5} sẽ khớp 5 ký tự 'a', trong khi a{3,5}? sẽ chỉ khớp 3 ký tự.
{m,n}+: Làm cho RE kết quả khớp từ các lần lặp lại m đến n của RE trước đó, cố gắng khớp nhiều lần lặp lại nhất có thể without 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ự 'aaaaaa', a{3,5}+aa cố gắng khớp 5 ký tự 'a', sau đó, yêu cầu thêm 2 'a's, sẽ cần nhiều ký tự hơn mức có sẵn và do đó không thành công, trong khi a{3,5}aa sẽ khớp với a{3,5} bắt được 5, sau đó là 4 'a's bằng cách quay lui và sau đó 2 'a's cuối cùng được khớp bởi aa cuối cùng trong mẫu. x{m,n}+ tương đương với (?>x{m,n}).

Added in version 3.11.

\

Hoặc thoát khỏi các ký tự đặc biệt (cho phép bạn khớp các ký tự như '*', '?', v.v.) hoặc báo hiệu một chuỗi đặc biệt; trình tự đặc biệt được thảo luận dưới đây.

Nếu bạn không sử dụng chuỗi thô để biểu thị 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ự; nếu trình phân tích cú pháp của Python không nhận ra chuỗi thoát thì dấu gạch chéo ngược và ký tự tiếp theo sẽ được đưa vào chuỗi kết quả. Tuy nhiên, nếu Python nhận ra chuỗi kết quả thì dấu gạch chéo ngược sẽ đượ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 chuỗi thô cho tất cả trừ những biểu thức đơn giản nhất.

[]

Dùng để chỉ 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ẻ, ví dụ: [amk] sẽ khớp với 'a', 'm' hoặc 'k'.

Phạm vi ký tự có thể được biểu thị bằng cách cho hai ký tự và phân tách chúng bằng '-', ví dụ: [a-z] sẽ khớp với bất kỳ chữ cái ASCII viết thường nào, [0-5][0-9] sẽ khớp với tất cả các số có hai chữ số từ 00 đến 59 và [0-9A-Fa-f] sẽ khớp với bất kỳ chữ số thập lục phân nào. Nếu - được thoát (ví dụ: [a\-z]) hoặc nếu nó được đặt làm ký tự đầu tiên hoặc cuối cùng (ví dụ: [-a] hoặc [a-]), thì nó sẽ khớp với '-' theo nghĩa đen.
Các ký tự đặc biệt ngoại trừ dấu gạch chéo ngược sẽ mất ý nghĩa đặc biệt bên trong các bộ. Ví dụ: [(+*)] sẽ khớp với bất kỳ ký tự chữ nào '(', '+', '*' hoặc ')'.

Dấu gạch chéo ngược thoát khỏi các ký tự có ý nghĩa đặc biệt trong một tập hợp, chẳng hạn như '-', ']', '^' và '\\' hoặc báo hiệu một chuỗi đặc biệt đại diện cho một ký tự đơn lẻ như \xa0 hoặc \n hoặc một lớp ký tự như \w hoặc \S (được xác định bên dưới). Lưu ý rằng \b đại diện cho một ký tự "backspace" duy nhất, không phải là ranh giới từ như bên ngoài một tập hợp và các ký tự thoát số như \1 luôn là ký tự thoát bát phân, không phải tham chiếu nhóm. Không được phép sử dụng các chuỗi đặc biệt không khớp với một ký tự đơn lẻ như \A và \z.

Các ký tự không nằm trong phạm vi có thể được khớp bằng complementing trong bộ. Nếu ký tự đầu tiên của bộ là '^' thì tất cả các ký tự là not trong bộ sẽ được khớp. Ví dụ: [^5] sẽ khớp với bất kỳ ký tự nào ngoại trừ '5' và [^^] sẽ khớp với bất kỳ ký tự nào ngoại trừ '^'. ^ không có ý nghĩa đặc biệt nếu nó không phải là ký tự đầu tiên trong bộ.
Để khớp một ']' theo nghĩa đen bên trong một tập hợp, hãy đặt dấu gạch chéo ngược trước nó hoặc đặt nó ở đầu tập hợp. Ví dụ: cả [()[\]{}] và []()[{}] sẽ khớp với khung bên phải, cũng như khung bên trái, dấu ngoặc nhọn và 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 Unicode Technical Standard #18 có thể được thêm vào trong tương lai. Điều này sẽ thay đổi cú pháp, do đó, để tạo điều kiện thuận lợi cho sự thay đổi này, FutureWarning sẽ được nêu ra trong các trường hợp không rõ ràng vào thời điểm hiện tại. Điều đó bao gồm các bộ bắt đầu bằng '[' theo nghĩa đen hoặc chứa các chuỗi ký tự theo nghĩa đen '--', '&&', '~~' và '||'. Để 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: FutureWarning được nâng lên nếu 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, trong đó A và B có thể là RE tùy ý, tạo ra một biểu thức chính quy khớp với A hoặc B. Một số lượng RE tùy ý có thể được phân tách bằng '|' 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 phân tách bằng '|' sẽ được thử từ trái sang phải. Khi một mẫu hoàn toàn khớp, 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ó tạo ra một kết quả khớp tổng thể dài hơn. Nói cách khác, toán tử '|' không bao giờ tham lam. Để khớp với '|' theo nghĩa đen, hãy sử dụng \| hoặc đặt nó bên trong một lớp ký tự, như trong [|].

(...): 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 phần bắt đầu và kết thúc của một nhóm; nội dung của một nhóm có thể được truy xuất sau khi thực hiện so khớp và có thể được so khớp sau này trong chuỗi bằng chuỗi đặc biệt \number, được mô tả bên dưới. Để khớp với các chữ '(' hoặc ')', hãy sử dụng $ hoặc $ hoặc đặt chúng bên trong một lớp ký tự: [(], [)].

(?...)

Đây là ký hiệu mở rộng ('?' theo sau '(' không có ý nghĩa gì khác). Ký tự đầu tiên sau '?' 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; (?P<name>...) là ngoại lệ duy nhất cho quy tắc này. Sau đây là các tiện ích mở rộng hiện được hỗ trợ.

(?aiLmsux)

(Một hoặc nhiều chữ cái từ tập hợp 'a', 'i', 'L', 'm', 's', 'u', 'x'.) Nhóm khớp với chuỗi trống; các chữ cái đặt cờ tương ứng cho toàn bộ biểu thức chính quy:

re.A (chỉ khớp với ASCII)
re.I (bỏ qua trường hợp)
re.L (phụ thuộc vào miền địa phương)
re.M (nhiều dòng)
re.S (dấu chấm khớp với tất cả)
re.U (Khớp Unicode)
re.X (dài dòng)

(Các cờ được mô tả bằng Nội dung mô-đun.) Đ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 đối số flag cho hàm re.compile(). 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 khi bắt đầu biểu thức.

(?:...)

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

(?aiLmsux-imsx:...)

(Không hoặc nhiều chữ cái trong bộ 'a', 'i', 'L', 'm', 's', 'u', 'x', tùy chọn theo sau là '-', theo sau là một hoặc nhiều chữ cái từ 'i', 'm', 's', 'x'.) Các chữ cái đặt hoặc xóa cờ tương ứng cho phần đó của biểu thức:

re.A (chỉ khớp với ASCII)
re.I (bỏ qua trường hợp)
re.L (phụ thuộc vào miền địa phương)
re.M (nhiều dòng)
re.S (dấu chấm khớp với tất cả)
re.U (Khớp Unicode)
re.X (dài dòng)

(Các cờ được mô tả bằng Nội dung mô-đun.)

Các chữ cái 'a', 'L' và 'u' 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 '-'. Thay vào đó, khi một trong số chúng xuất hiện trong nhóm nội tuyến, nó sẽ ghi đè chế độ khớp trong nhóm kèm theo. Trong các mẫu Unicode, (?a:...) chuyển sang khớp chỉ ASCII và (?u:...) chuyển sang khớp Unicode (mặc định). Trong các mẫu byte, (?L:...) chuyển sang khớp phụ thuộc miền địa phương và (?a:...) chuyển sang khớp chỉ ASCII (mặc định). Việc 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.

Added in version 3.6.

Thay đổi trong phiên bản 3.7: Các chữ cái 'a', 'L' và 'u' cũng có thể được sử dụng trong một nhóm.

(?>...)

Cố gắng khớp ... như thể đó là một biểu thức chính quy riêng biệt và nếu thành công, sẽ 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 hủy liên kết đến một điểm before ((?>...)) vì sau khi thoát ra, biểu thức, được gọi là atomic group, sẽ loại bỏ tất cả các điểm ngăn xếp bên trong chính nó. Do đó, (?>.*). sẽ không bao giờ khớp với bất kỳ thứ gì vì đầu tiên, .* 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 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.

Added in version 3.11.

(?P<name>...)

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 được thông qua tên nhóm tượng trưng name. Tên nhóm phải là mã định danh Python hợp lệ và trong mẫu bytes, chúng chỉ có thể chứa byte trong phạm vi ASCII. Mỗi tên nhóm chỉ được xác định một lần trong một biểu thức chính quy. 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 bối cảnh. Nếu mẫu là (?P<quote>['"]).*?(?P=quote) (tức là khớp 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 khuôn mẫu	`(?P=quote)` (như hình) `\1`
khi xử lý đối tượng khớp m	`m.group('quote')` `m.end('quote')` (v.v.)
trong một chuỗi được truyền tới đối số repl của `re.sub()`	`\g<quote>` `\g<1>` `\1`

Thay đổi trong phiên bản 3.12: Trong các mẫu bytes, nhóm name chỉ có thể chứa các byte trong phạm vi ASCII (b'\x00'-b'\x7f').

(?P=name): Một phản hồi cho một nhóm được đặt tên; nó khớp với bất kỳ văn bản nào được khớp bởi nhóm trước đó có tên name.

(?#...): Một bình luận; nội dung của dấu ngoặc đơn đơn giản bị bỏ qua.

(?=...): Khớp nếu ... khớp tiếp theo, nhưng không tiêu tốn bất kỳ chuỗi nào. Đây được gọi là lookahead assertion. Ví dụ: Isaac (?=Asimov) sẽ chỉ khớp với 'Isaac ' nếu theo sau nó là 'Asimov'.

(?!...): Phù hợp nếu ... không khớp tiếp theo. Đây là một negative lookahead assertion. Ví dụ: Isaac (?!Asimov) sẽ chỉ khớp với 'Isaac ' nếu not theo sau là 'Asimov'.

(?<=...)

Khớp nếu vị trí hiện tại trong chuỗi bắt đầu bằng một kết quả khớp cho ... kết thúc ở vị trí hiện tại. Đây được gọi là positive lookbehind assertion. (?<=abc)def sẽ tìm thấy kết quả khớp trong 'abcdef', vì giao diện sẽ sao lưu 3 ký tự và kiểm tra xem mẫu có khớp hay không. Mẫu được chứa chỉ phải khớp với các chuỗi có độ dài cố định nào đó, nghĩa là cho phép abc hoặc a|b nhưng a* và a{3,4} thì không. Lưu ý rằng các mẫu bắt đầu bằng xác nhận nhìn sau tích cực sẽ không khớp ở đầu chuỗi đang được tìm kiếm; rất có thể bạn sẽ muốn sử dụng hàm search() thay vì hàm match():

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

Ví dụ này tìm kiếm một từ theo 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 các tham chiếu nhóm có độ dài cố định.

(?<!...): Phù hợp nếu vị trí hiện tại trong chuỗi không nằm trước vị trí khớp của .... Đây được gọi là negative lookbehind assertion. Tương tự như các xác nhận nhìn phía sau tích cực, mẫu được chứa 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 xác nhận nhìn sau phủ định có thể khớp ở đầu chuỗi đang được tìm kiếm.

(?(id/name)yes-pattern|no-pattern): Sẽ cố gắng khớp với yes-pattern nếu nhóm có id hoặc name tồn tại và với no-pattern nếu không. no-pattern là tùy chọn và có thể bỏ qua. Ví dụ: (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) là mẫu khớp email kém, mẫu này sẽ khớp với '<user@host.com>' cũng như 'user@host.com', nhưng không khớp với '<user@host.com' hay 'user@host.com>'.

Thay đổi trong phiên bản 3.12: Nhóm id chỉ có thể chứa các chữ số ASCII. Trong các mẫu bytes, nhóm name chỉ có thể chứa các byte trong phạm vi ASCII (b'\x00'-b'\x7f').

Các chuỗi đặc biệt bao gồm '\' và một ký tự trong 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ụ: \$ khớp với ký tự '$'.

\number: Khớp với nội dung của nhóm có cùng số. Các nhóm được đánh số bắt đầu từ 1. Ví dụ: (.+) \1 khớp với 'the the' hoặc '55 55' nhưng không khớp với 'thethe' (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 number là 0 hoặc number dài 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 number. Bên trong '[' và ']' của một lớp ký tự, tất cả các ký tự thoát số đều được coi là ký tự.

\A: Chỉ khớp ở đầu chuỗi.

\b

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 về mặt hình thức, \b được định nghĩa là ranh giới giữa ký tự \w và \W (hoặc ngược lại) hoặc giữa \w và phần đầu hoặc phần cuối của chuỗi. Điều này có nghĩa là r'\bat\b' khớp với 'at', 'at.', '(at)' và 'as at ay' nhưng không khớp với 'attempt' hoặc 'atlas'.

Các ký tự từ mặc định trong mẫu Unicode (str) là chữ và số Unicode và dấu gạch dưới, nhưng điều này có thể được thay đổi bằng cách sử dụng cờ ASCII. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu sử dụng cờ LOCALE.

Ghi chú

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 các chuỗi ký tự của Python.

\B: Khớp với chuỗi trống, nhưng chỉ khi nó là not ở đầu hoặc cuối một từ. Điều này có nghĩa là r'at\B' khớp với 'athens', 'atom', 'attorney', nhưng không khớp với 'at', 'at.' hoặc 'at!'. \B đối lập với \b, vì vậy các ký tự từ trong mẫu Unicode (str) 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ờ ASCII. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu sử dụng cờ LOCALE.

Thay đổi trong phiên bản 3.14: \B hiện khớp với chuỗi đầu vào trống.

\d

Đố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 [0-9] và nhiều ký tự chữ số khác.

Khớp với [0-9] nếu cờ ASCII được sử dụng.

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

Khớp với bất kỳ chữ số thập phân nào trong bộ ký tự ASCII; điều này tương đương với [0-9].

\D

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 \d.

Khớp với [^0-9] nếu cờ ASCII được sử dụng.

\s

Đối với các mẫu Unicode (str):

Khớp với các ký tự khoảng trắng Unicode (như được xác định bởi str.isspace()). Điều này bao gồm [ \t\n\r\f\v] và nhiều ký tự khác, ví dụ như các khoảng trắng không ngắt được quy định bởi quy tắc kiểu chữ trong nhiều ngôn ngữ.

Khớp với [ \t\n\r\f\v] nếu cờ ASCII được sử dụng.

Đố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; điều này tương đương với [ \t\n\r\f\v].

\S

So 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 \s.

Khớp với [^ \t\n\r\f\v] nếu cờ ASCII được sử dụng.

\w

Đối với các mẫu Unicode (str):

Khớp các ký tự từ Unicode; điều này bao gồm tất cả các ký tự chữ và số Unicode (như được xác định bởi str.isalnum()), cũng như dấu gạch dưới (_).

Khớp với [a-zA-Z0-9_] nếu cờ ASCII được sử dụng.

Đố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; cái này tương đương với [a-zA-Z0-9_]. Nếu cờ LOCALE đượ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.

\W

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 \w. Theo mặc định, khớp với các ký tự không được gạch dưới (_) mà str.isalnum() trả về False.

Khớp với [^a-zA-Z0-9_] nếu cờ ASCII được sử dụng.

Nếu cờ LOCALE đượ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.

\z: Chỉ khớp ở cuối chuỗi.

Added in version 3.14.
\Z: Tương tự với \z Để tương thích với các phiên bản Python cũ.

Hầu hết escape sequences được hỗ trợ bởi 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 \b được sử dụng để biểu thị ranh giới từ và chỉ có nghĩa là "xóa lùi" bên trong các lớp ký tự.)

Các chuỗi thoát '\u', '\U' và '\N' chỉ được nhận dạng ở dạng Unicode (str). Trong các mẫu byte, chúng là lỗi. Các chữ cái 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 bát phân được bao gồm ở dạng giới hạn. Nếu chữ số đầu tiên là 0 hoặc nếu có ba chữ số bát phân thì nó được coi là thoát bát phân. Ngược lại, đó là tham chiếu nhóm. Đối với các chuỗi ký tự, các ký tự thoát bát phân luôn có độ dài tối đa ba chữ số.

Thay đổi trong phiên bản 3.3: Chuỗi thoát '\u' và '\U' đã đượ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 '\' 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 '\N{name}' đã được thêm vào. Như trong chuỗi ký tự, nó mở rộng thành ký tự Unicode được đặt tên (ví dụ: '\N{EM DASH}').

Nội dung mô-đun¶

Mô-đun này xác định một số hàm, hằng số và một ngoại lệ. Một số hàm là phiên bản đơn giản hóa của các phương thức đầy đủ tính năng dành 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 đã biên dịch.

Cờ¶

Thay đổi trong phiên bản 3.6: Các hằng cờ hiện là phiên bản của RegexFlag, là một lớp con của enum.IntFlag.

class re.RegexFlag¶: Lớp enum.IntFlag chứa các tùy chọn biểu thức chính quy được liệt kê bên dưới.

Added in version 3.11: - added to __all__

re.A¶

re.ASCII¶

Đặt \w, \W, \b, \B, \d, \D, \s và \S thực hiện đối sánh chỉ ASCII thay vì đối sánh Unicode đầy đủ. Điều này chỉ có ý nghĩa đối với các mẫu Unicode (str) và bị bỏ qua đối với các mẫu byte.

Tương ứng với cờ nội tuyến (?a).

Ghi chú

Cờ U vẫn tồn tại để tương thích ngược, nhưng không cần thiết trong Python 3 vì các kết quả khớp là Unicode theo mặc định cho các mẫu str và không cho phép kết hợp Unicode cho các mẫu byte. UNICODE và cờ nội tuyến (?u) đều dư thừa tương tự.

re.DEBUG¶

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.

re.I¶

re.IGNORECASE¶

Thực hiện khớp không phân biệt chữ hoa chữ thường; các biểu thức như [A-Z] cũng sẽ khớp với các chữ cái viết thường. Đối sánh Unicode đầy đủ (chẳng hạn như đối sánh Ü với ü) cũng hoạt động trừ khi cờ ASCII được sử dụng để vô hiệu hóa các kết quả khớp không phải ASCII. Ngôn ngữ hiện tại không thay đổi hiệu ứng của cờ này trừ khi cờ LOCALE cũng được sử dụng.

Tương ứng với cờ nội tuyến (?i).

Lưu ý rằng khi sử dụng mẫu Unicode [a-z] hoặc [A-Z] kết hợp với cờ IGNORECASE, 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ữ in hoa Latinh I có dấu chấm ở trên), 'ı' (U+0131, chữ nhỏ Latinh không có dấu chấm i), 'ſ' (U+017F, chữ nhỏ Latinh dài s) và 'K' (U+212A, ký hiệu Kelvin). Nếu cờ ASCII được sử dụng, chỉ các chữ cái 'a' đến 'z' và 'A' đến 'Z' được khớp.

re.L¶

re.LOCALE¶

Tạo đối sánh \w, \W, \b, \B và không 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.

Tương ứng với cờ nội tuyến (?L).

Cảnh báo

Cờ này không được khuyến khích; thay vào đó hãy xem xét kết hợp Unicode. Cơ chế ngôn ngữ rất không đáng tin cậy vì nó chỉ xử lý một "nền văn hóa" tại một thời điểm và chỉ hoạt động với các ngôn ngữ 8 bit. Kết hợp Unicode được bật theo mặc định cho các mẫu Unicode (str) và nó có thể xử lý các ngôn ngữ và ngôn ngữ khác nhau.

Thay đổi trong phiên bản 3.6: LOCALE chỉ có thể được sử dụng với các mẫu byte và không tương thích với ASCII.

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 bằng cờ LOCALE 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.

re.M¶

re.MULTILINE¶

Khi được chỉ định, ký tự mẫu '^' khớp ở đầu chuỗi và ở đầu mỗi dòng (ngay sau mỗi dòng mới); và ký tự mẫu '$' khớp ở cuối chuỗi và ở cuối mỗi dòng (ngay trước mỗi dòng mới). Theo mặc định, '^' chỉ khớp ở đầu chuỗi và '$' 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 (?m).

re.NOFLAG¶

Cho biết không có cờ nào được áp dụng, giá trị là 0. 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 OR có điều kiện với các cờ khác. Ví dụ về sử dụng làm giá trị mặc định:

def myfunc(văn bản, flag=re.NOFLAG):
    trả về re.match(văn bản, cờ)

Added in version 3.11.

re.S¶

re.DOTALL¶

Làm cho ký tự đặc biệt '.' khớp với bất kỳ ký tự nào, kể cả dòng mới; không có cờ này, '.' sẽ khớp với bất kỳ dòng nào của except.

Tương ứng với cờ nội tuyến (?s).

re.U¶

re.UNICODE¶

Trong Python 3, các ký tự Unicode được khớp theo mặc định cho các mẫu str. Do đó, cờ này không cần thiết với no effect và chỉ được giữ lại để tương thích ngược.

Thay vào đó, hãy xem ASCII để hạn chế khớp với các ký tự ASCII.

re.X¶

re.VERBOSE¶

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 phân tách trực quan các phần logic của mẫu và thêm nhận xét. Khoảng trắng trong mẫu bị bỏ qua, ngoại trừ khi ở trong một lớp ký tự hoặc khi đứng 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ư *?, (?: hoặc (?P<...>. Ví dụ: (? : và * ? không được phép. Khi một dòng chứa # 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, tất cả các ký tự từ # ngoài cùng bên trái cho đế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 số thập phân có chức năng bằng nhau:

a = re.compile(r"""\d + phần tích phân # the
                   \.    dấu thập phân # the
                   \d * # some chữ số phân số""", re.X)
b = re.compile(r"\d+\.\d*")

Tương ứng với cờ nội tuyến (?x).

Chức năng¶

re.compile(pattern, flags=0)¶

Biên dịch mẫu biểu thức chính quy thành regular expression object, mẫu này có thể được sử dụng để khớp bằng cách sử dụng match(), search() và các phương thức khác của nó, đượ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ị flags. Các giá trị có thể là bất kỳ biến flags nào, được kết hợp bằng cách sử dụng bitwise OR (toán tử |).

Trình tự

prog = re.compile(mẫu)
kết quả = prog.match(chuỗi)

tương đương với

kết quả = re.match(mẫu, chuỗi)

nhưng việc sử dụng re.compile() và lưu đối tượng biểu thức chính quy thu được để 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 tới re.compile() và các hàm khớp cấp mô-đun được lưu vào bộ nhớ đệm, do đó 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.

re.search(pattern, string, flags=0)¶

Quét qua string để tìm vị trí đầu tiên mà biểu thức chính quy pattern tạo ra kết quả khớp và trả về Match tương ứng. Trả về None nếu không có vị trí nào trong chuỗi khớp với mẫu; lưu ý rằng điều này khác với việc tìm kết quả khớp có độ dài bằng 0 tại một điểm nào đó trong chuỗi.

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

re.match(pattern, string, flags=0)¶

Nếu không hoặc nhiều ký tự ở đầu string khớp với biểu thức chính quy pattern, hãy trả về Match tương ứng. Trả về None nếu chuỗi không khớp với mẫu; lưu ý rằng điều này khác với kết quả khớp có độ dài bằng 0.

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

Nếu bạn muốn tìm kết quả trùng khớp ở bất kỳ đâu trong string, hãy sử dụng search() thay thế (xem thêm tìm kiếm() so với trận đấu()).

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

re.fullmatch(pattern, string, flags=0)¶

Nếu toàn bộ string khớp với biểu thức chính quy pattern, hãy trả về Match tương ứng. Trả về None nếu chuỗi không khớp với mẫu; lưu ý rằng điều này khác với kết quả khớp có độ dài bằng 0.

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

Added in version 3.4.

re.split(pattern, string, maxsplit=0, flags=0)¶

Chia string cho số lần xuất hiện của pattern. Nếu sử dụng dấu ngoặc đơn trong pattern 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 0 thì nhiều nhất là xảy ra sự phân tách maxsplit và phần còn lại của chuỗi được trả về làm phần tử cuối cùng của danh sách.

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

Nếu có các nhóm bắt giữ trong dấu phân cá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 ở phần cuối của chuỗi

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

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

Không thể có các kết quả trùng khớp trống liền kề, nhưng một kết quả khớp trống có thể xảy ra ngay sau một kết quả không trống.

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

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

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ợ phân tách trên một mẫu có thể khớp với một chuỗi trống.

Sắp loại bỏ từ phiên bản 3.13: Việc chuyển maxsplit và flags làm đối số vị trí không được dùng nữa. Trong các phiên bản Python tương lai, chúng sẽ là keyword-only parameters.

re.findall(pattern, string, flags=0)¶

Trả về tất cả các kết quả trùng khớp không chồng chéo của pattern trong string, dưới dạng danh sách các chuỗi hoặc bộ dữ liệu. Z002zz đượ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 bắt không ảnh hưởng đến hình thức của kết quả.

>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
[('width', '20'), ('height', '10')]

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

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

re.finditer(pattern, string, flags=0)¶

Trả về một đối tượng iterator mang lại Match trên tất cả các kết quả khớp không trùng lặp cho RE pattern trong string. Zz004zz được quét từ trái sang phải và kết quả trùng 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ả.

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

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

re.sub(pattern, repl, 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 không chồng chéo ngoài cùng bên trái của pattern trong string bằng repl thay thế. Nếu không tìm thấy mẫu, string sẽ được trả về không thay đổi. repl có thể là một chuỗi hoặc một hàm; nếu đó là một chuỗi, bất kỳ dấu gạch chéo ngược nào thoát ra trong đó đều được xử lý. Nghĩa là, \n được chuyển đổi thành một ký tự dòng mới, \r được chuyển đổi thành ký tự đầu dòng, v.v. Các chữ cái 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. Những lối thoát không xác định khác như \& đều bị bỏ lại một mình. Các tham chiếu ngược, chẳng hạn như \6, được thay thế bằng chuỗi con khớp với nhóm 6 trong mẫu. Ví dụ:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
... r'static PyObject*\npy_\1(void)\n{',
... 'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

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

>>> def dashrepl(matchobj):
... if matchobj.group(0) == '-': return ' '
... khác: quay lại '-'
...
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'các tập tin chương trình'
>>> re.sub(r'\sAND\s', ' & ', 'Đậu nướng và thư rác', flags=re.IGNORECASE)
'Đậu nướng & thư rác'

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

Đối số tùy chọn count là số lần xuất hiện mẫu tối đa được thay thế; count phải là số nguyên không âm. Nếu bị bỏ qua hoặc bằng 0, tất cả các lần xuất hiện sẽ được thay thế.

Không thể có các kết quả trùng khớp trống liền kề, nhưng một kết quả khớp trống có thể xảy ra ngay sau một kết quả không trống. Kết quả là sub('x*', '-', 'abxd') trả về '-a-b--d-' thay vì '-a-b-d-'.

Trong các đối số repl kiểu chuỗi, ngoài ký tự thoát và tham chiếu ngược được mô tả ở trên, \g<name> sẽ sử dụng chuỗi con khớp với nhóm có tên name, như được xác định bởi cú pháp (?P<name>...). \g<number> sử dụng số nhóm tương ứng; Do đó, \g<2> tương đương với \2, nhưng không mơ hồ khi thay thế như \g<2>0. \20 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ữ '0'. \g<0> phản hồi thay thế trong toàn bộ chuỗi con khớp với RE.

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

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 trống.

Thay đổi trong phiên bản 3.6: Các lối thoát không xác định trong pattern bao gồm '\' 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 repl bao gồm '\' và một chữ cái ASCII hiện là lỗi. Trận đấu trống có thể xảy ra ngay sau trận đấu không trống.

Thay đổi trong phiên bản 3.12: Nhóm id chỉ có thể chứa các chữ số ASCII. Trong chuỗi thay thế bytes, nhóm name chỉ có thể chứa các byte trong phạm vi ASCII (b'\x00'-b'\x7f').

Sắp loại bỏ từ phiên bản 3.13: Việc chuyển count và flags làm đối số vị trí không được dùng nữa. Trong các phiên bản Python tương lai, chúng sẽ là keyword-only parameters.

re.subn(pattern, repl, string, count=0, flags=0)¶

Thực hiện thao tác tương tự như sub(), nhưng trả về một bộ (new_string, number_of_subs_made).

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

re.escape(pattern)¶

Thoát ký tự đặc biệt trong pattern. Đ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ể chứa các siêu ký tự biểu thức chính quy trong đó. Ví dụ:

>>> print(re.escape('https://www.python.org'))
https://www\.python\.org

>>> legal_chars = string.ascii_lowcase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+

>>> toán tử = ['+', '-', '*', '/', '**']
>>> print('|'.join(map(re.escape, đã sắp xếp(toán tử, Reverse=True))))
/|\-|\+|\zz002zz|\*

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

>>> chữ số_re = r'\d+'
>>> sample = '/usr/sbin/sendmail - 0 lỗi, 12 cảnh báo'
>>> print(re.sub(digits_re, signatures_re.replace('\\', r'\\'), sample))
/usr/sbin/sendmail - lỗi \d+, cảnh báo \d+

Thay đổi trong phiên bản 3.3: Ký tự '_' không còn thoát được nữa.

Thay đổi trong phiên bản 3.7: Chỉ những ký tự có thể có ý nghĩa đặc biệt trong biểu thức chính quy mới được thoát. Kết quả là, '!', '"', '%', "'", ',', '/', ':', ';', '<', '=', '>', '@' và "`" không còn thoát được nữa.

re.purge()¶: Xóa bộ đệm biểu thức chính quy.

Ngoại lệ¶

exception re.PatternError(msg, pattern=None, pos=None)¶

Ngoại lệ nảy sinh khi một chuỗi được truyền tới một trong các hàm ở đây không phải là biểu thức chính quy hợp lệ (ví dụ: nó có thể chứa dấu ngoặc đơn không khớp) hoặc khi xảy ra một số lỗi khác trong quá trình biên dịch hoặc khớp. Sẽ không bao giờ có lỗi nếu một chuỗi không chứa mẫu phù hợp. Phiên bản PatternError có các thuộc tính bổ sung sau:

msg¶: Thông báo lỗi không được định dạng.

pattern¶: Mẫu biểu thức chính quy.

pos¶: Chỉ mục trong pattern nơi quá trình biên dịch không thành công (có thể là None).

lineno¶: Dòng tương ứng với pos (có thể là None).

colno¶: Cột tương ứng với pos (có thể là None).

Thay đổi trong phiên bản 3.5: Đã thêm thuộc tính bổ sung.

Thay đổi trong phiên bản 3.13: PatternError ban đầu được đặt tên là error; cái sau được giữ làm bí danh để tương thích ngược.

Đối tượng biểu thức chính quy¶

class re.Pattern¶: Đối tượng biểu thức chính quy được biên dịch được trả về bởi re.compile().

Thay đổi trong phiên bản 3.9: re.Pattern hỗ trợ [] để biểu thị mẫu Unicode (str) hoặc byte. Xem Loại bí danh chung.

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

Quét qua string để tìm vị trí đầu tiên mà biểu thức chính quy này tạo ra kết quả khớp và trả về Match tương ứng. Trả về None nếu không có vị trí nào trong chuỗi khớp với mẫu; lưu ý rằng điều này khác với việc tìm kết quả khớp có độ dài bằng 0 tại một điểm nào đó trong chuỗi.

Tham số thứ hai tùy chọn pos đưa ra một chỉ mục trong chuỗi nơi bắt đầu tìm kiếm; nó mặc định là 0. Điều này không hoàn toàn tương đương với việc cắt chuỗi; ký tự mẫu '^' khớp với phần đầu thực của chuỗi và tại các vị trí ngay sau dòng mới, nhưng không nhất thiết phải ở chỉ mục nơi bắt đầu tìm kiếm.

Tham số tùy chọn endpos giới hạn khoảng cách tìm kiếm trong chuỗi; nó sẽ giống như chuỗi dài endpos ký tự, vì vậy chỉ các ký tự từ pos đến endpos - 1 mới được tìm kiếm để khớp. Nếu endpos nhỏ hơn pos thì sẽ không tìm thấy kết quả phù hợp; mặt khác, nếu rx là một đối tượng biểu thức chính quy được biên dịch thì rx.search(string, 0, 50) tương đương với rx.search(string[:50], 0).

>>> mẫu = re.compile("d")
>>> mẫu.search("dog") # Match ở chỉ số 0
<re.Match đối tượng; span=(0, 1), match='d'>
>>> mẫu.search("dog", 1) # No khớp; tìm kiếm không bao gồm "d"

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

Nếu không hoặc nhiều ký tự ở beginning của string khớp với biểu thức chính quy này, hãy trả về Match tương ứng. Trả về None nếu chuỗi không khớp với mẫu; lưu ý rằng điều này khác với kết quả khớp có độ dài bằng 0.

Các tham số pos và endpos tùy chọn có ý nghĩa tương tự như đối với phương thức search().

>>> mẫu = re.compile("o")
>>> mẫu.match("dog") # No khớp vì "o" không ở đầu "dog".
>>> sample.match("dog", 1) # Match vì "o" là ký tự thứ 2 của "dog".
<re.Match đối tượng; span=(1, 2), match='o'>

Nếu bạn muốn tìm kết quả trùng khớp ở bất kỳ đâu trong string, hãy sử dụng search() thay thế (xem thêm tìm kiếm() so với trận đấu()).

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

Nếu toàn bộ string khớp với biểu thức chính quy này, hãy trả về Match tương ứng. Trả về None nếu chuỗi không khớp với mẫu; lưu ý rằng điều này khác với kết quả khớp có độ dài bằng 0.

Các tham số pos và endpos tùy chọn có ý nghĩa tương tự như đối với phương thức search().

>>> mẫu = re.compile("o[gh]")
>>> mẫu.fullmatch("dog") # No khớp vì "o" không ở đầu "dog".
>>> khớp mẫu.fullmatch("ogre") # No không khớp với toàn bộ chuỗi.
>>> sample.fullmatch("doggie", 1, 3) # Matches trong giới hạn nhất định.
<re.Match đối tượng; span=(1, 3), match='og'>

Added in version 3.4.

Pattern.split(string, maxsplit=0)¶: Giống hệt hàm split(), sử dụng mẫu đã biên dịch.

Pattern.findall(string[, pos[, endpos]])¶: Tương tự như hàm findall(), sử dụng mẫu đã biên dịch nhưng cũng chấp nhận các tham số pos và endpos tùy chọn giới hạn vùng tìm kiếm như đối với search().

Pattern.finditer(string[, pos[, endpos]])¶: Tương tự như hàm finditer(), sử dụng mẫu đã biên dịch nhưng cũng chấp nhận các tham số pos và endpos tùy chọn giới hạn vùng tìm kiếm như đối với search().

Pattern.sub(repl, string, count=0)¶: Giống hệt hàm sub(), sử dụng mẫu đã biên dịch.

Pattern.subn(repl, string, count=0)¶: Giống hệt hàm subn(), sử dụng mẫu đã biên dịch.

Pattern.flags¶: Cờ phù hợp với biểu thức chính quy. Đây là sự kết hợp của các cờ được cấp cho compile(), bất kỳ cờ nội tuyến (?...) nào trong mẫu và các cờ ẩn như UNICODE nếu mẫu là chuỗi Unicode.

Pattern.groups¶: Số lượng nhóm chụp trong mẫu.

Pattern.groupindex¶: Một từ điển ánh xạ bất kỳ tên nhóm biểu tượng nào được xác định bởi (?P<id>) 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.

Pattern.pattern¶: 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ợ copy.copy() và copy.deepcopy(). 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¶

Đối tượng khớp luôn có giá trị boolean là True. Vì match() và search() trả về None khi không có kết quả trùng 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 if đơn giản:

match = re.search(mẫu, chuỗi)
nếu khớp:
    quá trình (khớp)

class re.Match¶: Đối tượng khớp được trả về bởi matches và searches thành công.

Thay đổi trong phiên bản 3.9: re.Match hỗ trợ [] để biểu thị sự trùng khớp Unicode (str) hoặc byte. Xem Loại bí danh chung.

Match.expand(template)¶: 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 chuỗi mẫu template, như được thực hiện bằng phương thức sub(). Các lối thoát như \n được chuyển đổi thành các ký tự thích hợp và các tham chiếu ngược số (\1, \2) và các tham chiếu ngược có tên (\g<1>, \g<name>) được thay thế bằng nội dung của nhóm tương ứng. Phản hồi \g<0> sẽ được thay thế bằng toàn bộ trận đấu.

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 trống.

Match.group([group1, ...])¶

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 thì kết quả là một chuỗi đơn; nếu có nhiều đối số, kết quả là một bộ dữ liệu có một mục cho mỗi đối số. Không có đối số, group1 mặc định là 0 (toàn bộ kết quả khớp được trả về). Nếu đối số groupN bằng 0, giá trị trả về tương ứng là toàn bộ chuỗi khớp; nếu là số nguyên dương thì đó là chuỗi khớp với nhóm được 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 thì ngoại lệ IndexError sẽ xuất hiện. 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à None. 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.match(r"(\w+) (\w+)", "Isaac Newton, nhà vật lý")
>>> m.group(0) # The toàn bộ trận đấu
'Isaac Newton'
>>> m.group(1) # The nhóm con được ngoặc đơn đầu tiên.
'Isaac'
>>> m.group(2) # The nhóm con được ngoặc đơn thứ hai.
'Newton'
>>> đối số m.group(1, 2) # Multiple cho chúng ta một bộ dữ liệu.
('Isaac', 'Newton')

Nếu biểu thức chính quy sử dụng cú pháp (?P<name>...) thì các đối số groupN 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 đối số chuỗi không được sử dụng làm tên nhóm trong mẫu thì ngoại lệ IndexError sẽ xuất hiện.

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+), "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

Các nhóm được đặt tên cũng có thể được gọi theo chỉ mục của họ:

>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'

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

>>> m = re.match(r"(..)+", "a1b2c3") # Matches 3 lần.
>>> m.group(1) # Returns chỉ có trận cuối cùng.
'c3'

Match.__getitem__(g)¶

Điều này giống hệt với m.group(g). Đ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:

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, nhà vật lý")
>>> m[0] # The toàn bộ trận đấu
'Isaac Newton'
>>> m[1] # The nhóm con được ngoặc đơn đầu tiên.
'Isaac'
>>> m[2] # The nhóm con được ngoặc đơn thứ hai.
'Newton'

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+), "Isaac Newton")
>>> m['first_name']
'Isaac'
>>> m['last_name']
'Newton'

Added in version 3.6.

Match.groups(default=None)¶

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

Ví dụ:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

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à None trừ khi đối số default được đưa ra

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> nhóm m.groups() # Second mặc định là Không.
('24', Không có)
>>> m.groups('0') # Now, nhóm thứ 2 mặc định là '0'.
('24', '0')

Match.groupdict(default=None)¶

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+), "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

Match.start([group])¶

Match.end([group])¶

Trả về chỉ số bắt đầu và kết thúc của chuỗi con khớp với group; group mặc định là 0 (có nghĩa là toàn bộ chuỗi con phù hợp). Trả về -1 nếu group tồn tại nhưng không đóng góp vào trận đấu. Đối với đối tượng khớp m và nhóm g đã đóng góp vào trận đấu, chuỗi con khớp với nhóm g (tương đương với m.group(g)) là

m.string[m.start(g):m.end(g)]

Lưu ý rằng m.start(group) sẽ bằng m.end(group) nếu group khớp với chuỗi rỗng. Ví dụ: sau m = re.search('b(c?)', 'cba'), m.start(0) là 1, m.end(0) là 2, m.start(1) và m.end(1) đều là 2 và m.start(2) đưa ra một ngoại lệ IndexError.

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

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'

Match.span([group])¶: Đối với m khớp, trả về (m.start(group), m.end(group)) 2 bộ. Lưu ý rằng nếu group không đóng góp gì cho trận đấu thì đây là (-1, -1). group mặc định là 0, toàn bộ trận đấu.

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

Match.endpos¶: Giá trị của endpos được truyền cho phương thức search() hoặc match() của regex object. Đây là chỉ mục trong chuỗi mà công cụ RE sẽ không đi tới.

Match.lastindex¶: Chỉ số nguyên của nhóm chụp phù hợp cuối cùng hoặc None nếu không có nhóm nào khớp. Ví dụ: các biểu thức (a)b, ((a)(b)) và ((ab)) sẽ có lastindex == 1 nếu được áp dụng cho chuỗi 'ab', trong khi biểu thức (a)(b) sẽ có lastindex == 2 nếu được áp dụng cho cùng một chuỗi.

Match.lastgroup¶: Tên của nhóm bắt giữ trùng khớp cuối cùng hoặc None nếu nhóm không có tên hoặc nếu không có nhóm nào trùng khớp.

Match.re¶: regular expression object có phương thức match() hoặc search() tạo ra phiên bản khớp này.

Match.string¶: Chuỗi được chuyển tới match() hoặc search().

Thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ copy.copy() và copy.deepcopy(). Đối tượng phù hợp được coi là nguyên tử.

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

Kiểm tra một cặp¶

Trong ví dụ này, chúng tôi 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 displaymatch(match):
    nếu trận đấu là Không:
        trả về Không có
    return '<Match: %r,groups=%r>' % (match.group(), match.groups())

Giả sử bạn đang viết một chương trình poker trong đó ván bài của người chơi được biểu thị 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 jack, "t" cho 10 và "2" đến "9" đại diện cho quân bài có giá trị đó.

Để xem liệu 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

>>> hợp lệ = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q")) # Valid.
"<Trận đấu: 'akt5q', nhóm=()>"
>>> displaymatch(valid.match("akt5e")) # Invalid.
>>> displaymatch(valid.match("akt")) # Invalid.
>>> displaymatch(valid.match("727ak")) # Valid.
"<Trận đấu: '727ak', nhóm=()>"

Ván bài cuối cùng đó, "727ak", chứa một cặp hoặc hai lá bài có giá trị như 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 các phản hồi ngược như sau

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak")) # Pair trong 7 giây.
"<Trận đấu: '717', nhóm=('7',)>"
>>> cặp displaymatch(pair.match("718ak")) # No.
>>> displaymatch(pair.match("354aa")) # Pair của quân Át.
"<Trận đấu: '354aa', nhóm=('a',)>"

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

>>> pair = re.compile(r".*(.).*\1")
>>> pair.match("717ak").group(1)
'7'

# Error vì re.match() trả về Không, không có phương thức group():
>>> pair.match("718ak").group(1)
Traceback (cuộc gọi gần đây nhất):
  Tệp "<pyshell#23>", dòng 1, trong <module>
    re.match(r".*(.).*\1", "718ak").group(1)
AttributionError: Đối tượng 'NoneType' không có thuộc tính 'nhóm'

>>> pair.match("354aa").group(1)
'a'

Mô phỏng scanf()¶

Python hiện không có phiên bản tương đương với scanf(). Các biểu thức chính quy thường mạnh hơn, mặc dù cũng dài dòng hơn các chuỗi định dạng scanf(). Bảng bên dưới cung cấp một số ánh xạ ít nhiều tương đương giữa mã thông báo định dạng scanf() và biểu thức chính quy.

Mã thông báo `scanf()`	Biểu thức chính quy
`%c`	`.`
`%5c`	`.{5}`
`%d`	`[-+]?\d+`
`%e`, `%E`, `%f`, `%g`	`[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?`
`%i`	`[-+]?(0[xX][\dA-Fa-f]+\|0[0-7]*\|\d+)`
`%o`	`[-+]?[0-7]+`
`%s`	`\S+`
`%u`	`\d+`
`%x`, `%X`	`[-+]?(0[xX])?[\dA-Fa-f]+`

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

/usr/sbin/sendmail - 0 lỗi, 4 cảnh báo

bạn sẽ sử dụng định dạng scanf() như

%s - %d lỗi, %d cảnh báo

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

(\S+) - (\d+) lỗi, (\d+) cảnh báo

tìm kiếm() so với trận đấ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:

re.match() chỉ kiểm tra sự trùng khớp ở đầu chuỗi
re.search() kiểm tra sự trùng khớp ở bất kỳ đâu trong chuỗi (đây là điều Perl thực hiện theo mặc định)
re.fullmatch() kiểm tra toàn bộ chuỗi có khớp không

Ví dụ:

>>> trận đấu re.match("c", "abcdef") # No
>>> re.search("c", "abcdef") # Match
<re.Match đối tượng; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Match
<re.Match đối tượng; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") trận đấu # No

Bạn có thể sử dụng các biểu thức chính quy bắt đầu bằng '^' với search() để hạn chế kết quả khớp ở đầu chuỗi:

>>> trận đấu re.match("c", "abcdef") # No
>>> re.search("^c", "abcdef") trận đấu # No
>>> re.search("^a", "abcdef") # Match
<re.Match đối tượng; span=(0, 1), match='a'>

Tuy nhiên, hãy lưu ý rằng ở chế độ MULTILINE, match() chỉ khớp ở đầu chuỗi, trong khi sử dụng search() với biểu thức chính quy bắt đầu bằng '^' sẽ khớp ở đầu mỗi dòng.

>>> re.match("X", "A\nB\nX", re.MULTILINE) trận đấu # No
>>> re.search("^X", "A\nB\nX", re.MULTILINE) # Match
<re.Match đối tượng; span=(4, 5), match='X'>

Làm danh bạ¶

split() chia một chuỗi thành một danh sách được phân tách bằng mẫu đã truyền. Phương pháp này rất có giá trị trong việc 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ư minh họa trong ví dụ tạo danh bạ sau đây.

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

>>> text = """Ross McFluff: 834.345.1254 155 Phố Elm
...
... Ronald Heathmore: 892.345.3428 436 Đại lộ Finley
... Frank Burger: 925.541.7625 662 Đường Nam Dogwood
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""

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:

>>> mục = re.split("\n+", văn bản)
>>> mục
['Ross McFluff: 834.345.1254 155 Phố Elm',
'Ronald Heathmore: 892.345.3428 436 Đại lộ Finley',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']

Cuối cùng, chia mỗi 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ố maxsplit của split() vì địa chỉ có dấu cách, mẫu phân tách của chúng tôi trong đó:

>>> [re.split(":? ", entry, maxsplit=3) để nhập vào các mục]
[['Ross', 'McFluff', '834.345.1254', '155 Phố Elm'],
['Ronald', 'Heathmore', '892.345.3428', '436 Đại lộ Finley'],
['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

Mẫu :? 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 maxsplit của 4, chúng ta có thể tách số nhà khỏi tên đường:

>>> [re.split(":? ", entry, maxsplit=4) để nhập vào các mục]
[['Ross', 'McFluff', '834.345.1254', '155', 'Phố Elm'],
['Ronald', 'Heathmore', '892.345.3428', '436', 'Đại lộ Finley'],
['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919', 'Địa điểm công viên']]

Trộn văn bản¶

sub() thay thế mọi lần xuất hiện của mẫu bằng một chuỗi hoặc kết quả của hàm. Ví dụ này minh họa việc sử dụng sub() với chức năng "ngộp" 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:

>>> thay thế def(m):
... bên trong_word = danh sách (m.group(2))
... ngẫu nhiên.shuffle(inner_word)
... return m.group(1) + "".join(inner_word) + m.group(3)
...
>>> text = "Giáo sư Abdolmalek, vui lòng báo cáo sự vắng mặt của bạn ngay lập tức."
>>> re.sub(r"(\w)(\w+)(\w)", thay thế, văn bản)
'Poefsrosr Aealmlobdk, xin vui lòng tái hiện lại sự vắng mặt của bạn.'
>>> re.sub(r"(\w)(\w+)(\w)", thay thế, văn bản)
'Pofsroser Aodlambelk, xin vui lòng giới thiệu lại cho bạn hoặc asnebces potlmrpy.'

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

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

>>> text = "Anh ta đã cải trang cẩn thận nhưng bị cảnh sát bắt nhanh chóng."
>>> re.findall(r"\w+ly\b", văn bản)
['cẩn thận', 'nhanh chóng']

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 hơn là văn bản phù hợp, finditer() rất hữu ích vì nó cung cấp các đối tượng Match 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ừ and their positions trong một số văn bản, họ sẽ sử dụng finditer() theo cách sau:

>>> text = "Anh ta đã cải trang cẩn thận nhưng bị cảnh sát bắt nhanh chóng."
>>> for m in re.finditer(r"\w+ly\b", text):
... print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: cẩn thận
40-47: nhanh

Ký hiệu chuỗi thô¶

Ký hiệu chuỗi thô (r"text") giữ cho các biểu thức chính quy luôn hợp lý. Nếu không có nó, mọi dấu gạch chéo ngược ('\') trong một biểu thức chính quy sẽ phải được thêm tiền tố 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 có chức năng giống hệt nhau:

>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match đối tượng; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match đối tượng; span=(0, 4), match=' ff '>

Khi muốn khớp một 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à r"\\". Nếu không có ký hiệu chuỗi thô, người ta phải sử dụng "\\\\", làm cho các dòng mã sau đây giống hệt nhau về mặt chức năng:

>>> re.match(r"\\", r"\\")
<re.Match đối tượng; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match đối tượng; span=(0, 1), match='\\'>

Viết mã thông báo¶

Zz000zz 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 mộ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 bằng các biểu thức thông thường. Kỹ thuật này là kết hợp chúng thành một biểu thức chính quy chính duy nhất và lặp qua các kết quả khớp liên tiếp

từ việc nhập nhập NamedTuple
nhập lại

Mã thông báo lớp (NamedTuple):
    loại: str
    giá trị: str
    dòng: int
    cột: int

def tokenize(mã):
    từ khóa = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specization = [
        ('NUMBER', r'\d+(\.\d*)?'), # Integer hoặc số thập phân
        ('ASSIGN', r':='), toán tử # Assignment
        ('END', r';'), bộ kết thúc # Statement
        ('ID', r'[A-Za-z]+'), # Identifiers
        ('OP', r'[+\-*/]'), toán tử # Arithmetic
        ('NEWLINE', r'\n'), phần cuối của # Line
        ('SKIP', r'[ \t]+'), # Skip trên dấu cách và tab
        ('MISMATCH', r'.'), # Any nhân vật khác
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % cặp cho cặp trong token_specation)
    dòng_num = 1
    dòng_bắt đầu = 0
    cho mo trong re.finditer(tok_regex, code):
        loại = mo.lastgroup
        giá trị = mo.group()
        cột = mo.start() - line_start
        nếu loại == 'NUMBER':
            value = float(value) if '.' trong giá trị khác int(value)
        elif kind == 'ID' và giá trị trong từ khóa:
            loại = giá trị
        loại elif == 'NEWLINE':
            line_start = mo.end()
            dòng_num += 1
            tiếp tục
        loại elif == 'SKIP':
            tiếp tục
        loại Elif == 'MISMATCH':
            raise RuntimeError(f'{value!r} không mong muốn trên dòng {line_num}')
        Mã thông báo năng suất (loại, giá trị, dòng_num, cột)

câu lệnh = '''
    NẾU số lượng THEN
        tổng cộng := tổng cộng + giá * số lượng;
        thuế := giá * 0,05;
    ENDIF;
'''

cho mã thông báo trong tokenize(câu lệnh):
    in (mã thông báo)

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

Mã thông báo(loại='IF', giá trị='IF', dòng=2, cột=4)
Mã thông báo(loại='ID', giá trị='số lượng', dòng=2, cột=7)
Token(type='THEN', value='THEN', line=2, cột=16)
Mã thông báo(loại='ID', giá trị='tổng', dòng=3, cột=8)
Token(type='ASSIGN', value=':=', line=3, cột=14)
Mã thông báo(loại='ID', giá trị='tổng', dòng=3, cột=17)
Mã thông báo(loại='OP', giá trị='+', dòng=3, cột=23)
Mã thông báo(loại='ID', giá trị='giá', dòng=3, cột=25)
Token(type='OP', value='*', line=3, cột=31)
Mã thông báo(loại='ID', giá trị='số lượng', dòng=3, cột=33)
Token(type='END', value=';', line=3, cột=41)
Mã thông báo(loại='ID', giá trị='thuế', dòng=4, cột=8)
Token(type='ASSIGN', value=':=', line=4, cột=12)
Mã thông báo(loại='ID', giá trị='giá', dòng=4, cột=15)
Token(type='OP', value='*', line=4, cột=21)
Mã thông báo(loại='NUMBER', giá trị=0,05, dòng=4, cột=23)
Token(type='END', value=';', line=4, cột=27)
Token(type='ENDIF', value='ENDIF', line=5, cột=4)
Token(type='END', value=';', line=5, cột=9)

[Frie09]

Friedl, Jeffrey. Làm chủ biểu thức chính quy. Tái bản lần thứ 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 tốt một cách rất chi tiết.

`re` --- Hoạt động biểu thức chính quy¶

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

Nội dung mô-đun¶

Cờ¶

Chức năng¶

Ngoại lệ¶

Đối tượng biểu thức chính quy¶

Đối tượng phù hợp¶

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

Kiểm tra một cặp¶

Mô phỏng scanf()¶

tìm kiếm() so với trận đấu()¶

Làm danh bạ¶

Trộn văn bản¶

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

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

Ký hiệu chuỗi thô¶

Viết mã thông báo¶

Table of Contents

Chủ đề trước

Chủ đề tiếp

Trang này

re --- Hoạt động biểu thức chính quy¶

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

Nội dung mô-đun¶

Cờ¶

Chức năng¶

Ngoại lệ¶

Đối tượng biểu thức chính quy¶

Đối tượng phù hợp¶

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

Kiểm tra một cặp¶

Mô phỏng scanf()¶

tìm kiếm() so với trận đấu()¶

Làm danh bạ¶

Trộn văn bản¶

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

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

Ký hiệu chuỗi thô¶

Viết mã thông báo¶

`re` --- Hoạt động biểu thức chính quy¶