Mã nguồn: lib/re/ Lib/re/
Mô -đun này cung cấp các hoạt động khớp biểu thức thường xuyên tương tự như các hoạt động được tìm thấy trong Perl.
Cả hai mẫu và chuỗi sẽ được tìm kiếm có thể là chuỗi Unicode [
prog = re.compile[pattern] result = prog.match[string]1] cũng như các chuỗi 8 bit [
prog = re.compile[pattern] result = prog.match[string]2]. Tuy nhiên, các chuỗi unicode và chuỗi 8 bit không thể được trộn lẫn: nghĩa là, bạn không thể khớp với một 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 [
prog = re.compile[pattern] result = prog.match[string]3] để biểu thị các hình thức đặc biệt hoặc cho phép các ký tự đặc biệt được sử dụng mà không cần gọi ý nghĩa đặc biệt của chúng. Điều này va chạm với việc sử dụng Python sườn của cùng một nhân vật cho cùng một mục đích trong các chữ viết; Ví dụ, để phù hợp với một dấu gạch chéo ngược theo nghĩa đen, người ta có thể phải viết
prog = re.compile[pattern] result = prog.match[string]4 dưới dạng chuỗi mẫu, bởi vì biểu thức thông thường phải là
prog = re.compile[pattern] result = prog.match[string]5 và mỗi dấu gạch chéo ngược phải được biểu thị dưới dạng
prog = re.compile[pattern] result = prog.match[string]5 bên trong một chuỗi python thông thường theo nghĩa đen. Ngoài ra, xin lưu ý rằng bất kỳ trình tự thoát hiểm không hợp lệ nào trong việc sử dụng Python, của dấu gạch chéo ngược trong các chuỗi chữ hiện tại sẽ tạo ra một
prog = re.compile[pattern] result = prog.match[string]7 và trong tương lai, điều này sẽ trở thành
prog = re.compile[pattern] result = prog.match[string]8. Hành vi này sẽ xảy ra ngay cả khi đó 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ô Python sườn cho các mẫu biểu thức thông thường; Backslashes không được xử lý theo bất kỳ cách đặc biệt nào trong một chuỗi theo nghĩa đen được đặt trước với
prog = re.compile[pattern] result = prog.match[string]9. Vì vậy,
result = re.match[pattern, string]0 là một chuỗi hai ký tự chứa
prog = re.compile[pattern] result = prog.match[string]3 và
result = re.match[pattern, string]2, trong khi
result = re.match[pattern, string]3 là một chuỗi một ký tự có chứa một dòng mới. Thông thường các mẫu sẽ được thể hiện trong 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 hoạt động 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 biểu thức được biên dịch thông thường. Các chức năng là các phím tắt mà don don yêu cầu bạn biên dịch một đối tượng Regex trước, nhưng bỏ lỡ một số tham số tinh chỉnh.compiled regular expressions. The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters.
Xem thêm
Mô-đun Regex của bên thứ ba, có API tương thích với mô-đun thư viện tiêu chuẩn
result = re.match[pattern, string]4, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode kỹ lưỡng hơn.
Biểu thức thông thường cú pháp
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 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 biểu thức chính quy nhất định không [hoặc nếu một biểu thức chính quy nhất định khớp với một chuỗi cụ thể, đi xuống cùng một điều].
Biểu thức thông thường có thể được nối để tạo thành các biểu thức thường xuyên mới; Nếu A và B đều là biểu thức chính quy, thì AB cũng là một biểu thức chính quy. Nói chung, nếu chuỗi P khớp với A và một chuỗi Q khác khớp với B, 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; điều kiện biên giữa a và b; hoặc đã đánh số tài liệu tham khảo nhóm. 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à thực hiện các biểu thức thường xuyên, hãy tham khảo cuốn sách Friedl [FRIE09] hoặc gần như bất kỳ cuốn sách giáo khoa nào về xây dựng trình biên dịch.[Frie09], or almost any textbook about compiler construction.
Một lời giải thích ngắn gọn về định dạng của các biểu thức thường xuyên sau. Để biết thêm thông tin và một bài thuyết trình nhẹ nhàng hơn, hãy tham khảo ý kiến biểu thức thường xuyên.Regular Expression HOWTO.
Biểu thức chính quy có thể chứa cả các ký tự đặc biệt và thông thường. Hầu hết các ký tự thông thường, như
result = re.match[pattern, string]5,
result = re.match[pattern, string]6 hoặc
result = re.match[pattern, string]7, là các 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 họ. Bạn có thể kết hợp các ký tự thông thường, vì vậy
result = re.match[pattern, string]8 khớp với chuỗi
result = re.match[pattern, string]9. .
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']2 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']3, là đặc biệt. Các ký tự đặc biệt là đại diện cho các lớp các ký tự thông thường hoặc ảnh hưởng đến cách các biểu thức chính quy xung quanh chúng được giải thích.
Các toán tử hoặc định lượng lặp lạ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']4,
>>> 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,
>>> 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, v.v.] không thể được lồng trực tiếp. Điều này tránh sự mơ hồ với hậu tố biến đổi không màu xanh lá cây
>>> 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 và với các công cụ sửa đổi khác trong các triển khai khác. Để áp dụng sự lặp lại thứ hai cho sự 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', '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']9 khớp với bất kỳ bội số nào của sáu
result = re.match[pattern, string]6 ký tự.
Các nhân vật đặc biệt là:
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']1
[Dot.] Trong chế độ mặc định, điều này phù hợp với bất kỳ ký tự nào ngoại trừ dòng mới. Nếu cờ
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']2 đã được chỉ định, điều này phù hợp với bất kỳ ký tự nào bao gồm cả dòng mới.
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']3
.
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']5
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ế độ
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']4 cũng khớp với một dòng mới.
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']7 phù hợp với cả ‘foo, và‘ foobar, trong khi biểu thức thông thường
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']8 chỉ khớp với ‘foo. Thú vị hơn, việc tìm kiếm
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']9 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', '...', '', '', '']0 phù hợp với foo2, thông thường, nhưng ‘foo1, ở chế độ
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']4; Tìm kiếm một
>>> re.split[r'[\W+]', '...words, words...'] ['', '...', 'words', ', ', 'words', '...', '']5 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', '...', '', '', '']3 sẽ tìm thấy hai đối sánh [trống]: 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']4
Làm cho RE kết quả khớp với 0 hoặc nhiều sự 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', '...', '', '', '']5 sẽ phù hợp với ’A,’ ab, hoặc ‘A, sau đó là bất kỳ số lượng‘ Biên.
>>> 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ả phù hợp với 1 hoặc nhiều sự 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', '...', '', '', '']7 sẽ phù hợp với ’A, sau đó là bất kỳ số lượng‘ Biên nào; Nó sẽ không chỉ phù hợp với ’a.
>>> 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 kết quả RE khớp với 0 hoặc 1 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', '...', '', '', '']9 sẽ phù hợp với ‘A, hoặc‘ AB.
>>> m = re.search[r'[?>> m = re.search[r'[?