Trong ví dụ cụ thể này, câu lệnh slice
prog = re.compile[pattern] result = prog.match[string]38 có nghĩa là bắt đầu ở cuối chuỗi và kết thúc ở vị trí 0, di chuyển theo bước
prog = re.compile[pattern] result = prog.match[string]39, âm một, có nghĩa là lùi một bước
Cắt chuỗi
txt = "Xin chào thế giới"[. -1]
in[txt]
Bây giờ chúng tôi có một ________ 640 mạnh mẽ đọc ngược "Xin chào thế giới"
In Chuỗi để chứng minh kết quả
In danh sách
txt = "Xin chào thế giới"[. -1]
in[txt]
Tạo một chức năng
Nếu bạn muốn có một hàm mà bạn có thể gửi các chuỗi của mình và trả về ngược lại, bạn có thể tạo một hàm và chèn mã từ ví dụ trên
Cả mẫu và chuỗi được tìm kiếm đều có thể là chuỗi Unicode [_______02] cũng như chuỗi 8 bit [
prog = re.compile[pattern] result = prog.match[string]3]. 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 [_______04] để 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
prog = re.compile[pattern] result = prog.match[string]8 và trong tương lai, điều này sẽ trở thành một
prog = re.compile[pattern] result = prog.match[string]9. 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 một 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 biểu thức chính quy được biên dịch . 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 regex của bên thứ ba, có API tương thích với mô-đun
prog = re.compile[pattern] result = prog.match[string]1 của thư viện chuẩn, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode toàn diện 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 [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à 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à cách 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ư
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
prog = re.compile[pattern] result = prog.match[string]80. [Trong phần còn lại của phần này, chúng tôi sẽ viết RE trong
prog = re.compile[pattern] result = prog.match[string]81, thường không có dấu ngoặc kép và các chuỗi được khớp với
prog = re.compile[pattern] result = prog.match[string]82. ]
Một số ký tự, như
prog = re.compile[pattern] result = prog.match[string]83 hoặc
prog = re.compile[pattern] result = prog.match[string]84, 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 [
prog = re.compile[pattern] result = prog.match[string]85,
prog = re.compile[pattern] result = prog.match[string]86,
prog = re.compile[pattern] result = prog.match[string]87,
prog = re.compile[pattern] result = prog.match[string]88, 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
prog = re.compile[pattern] result = prog.match[string]87 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
prog = re.compile[pattern] result = prog.match[string]80 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à
prog = re.compile[pattern] result = prog.match[string]82
[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ờ
prog = re.compile[pattern] result = prog.match[string]83 đã được chỉ định, thì cờ này khớp với bất kỳ ký tự nào kể cả ký tự xuống dòng
prog = re.compile[pattern] result = prog.match[string]84
[dấu mũ. ] Khớp với phần đầu của chuỗi và ở chế độ
prog = re.compile[pattern] result = prog.match[string]85 cũng khớp ngay sau mỗi dòng mới
prog = re.compile[pattern] result = prog.match[string]86
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ế độ
prog = re.compile[pattern] result = prog.match[string]85 cũng khớp với trước một dòng mới.
prog = re.compile[pattern] result = prog.match[string]88 khớp với cả 'foo' và 'foobar', trong khi biểu thức chính quy
prog = re.compile[pattern] result = prog.match[string]89 chỉ khớp với 'foo'. Thú vị hơn, tìm kiếm
prog = re.compile[pattern] result = prog.match[string]80 trong
prog = re.compile[pattern] result = prog.match[string]81 khớp với 'foo2' bình thường, nhưng 'foo1' ở chế độ
prog = re.compile[pattern] result = prog.match[string]85; . một ngay trước dòng mới và một ở cuối chuỗi
prog = re.compile[pattern] result = prog.match[string]85
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.
prog = re.compile[pattern] result = prog.match[string]86 sẽ khớp với 'a', 'ab' hoặc 'a' theo sau bởi bất kỳ số lượng 'b' nào
prog = re.compile[pattern] result = prog.match[string]86
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 đó.
prog = re.compile[pattern] result = prog.match[string]88 sẽ khớp với 'a' theo sau bởi bất kỳ số nào khác 0 của 'b';
prog = re.compile[pattern] result = prog.match[string]87
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 đó.
prog = re.compile[pattern] result = prog.match[string]800 sẽ khớp với 'a' hoặc 'ab'
prog = re.compile[pattern] result = prog.match[string]801,
prog = re.compile[pattern] result = prog.match[string]802,
prog = re.compile[pattern] result = prog.match[string]803
Các bộ định lượng
prog = re.compile[pattern] result = prog.match[string]804,
prog = re.compile[pattern] result = prog.match[string]805 và
prog = re.compile[pattern] result = prog.match[string]806 đều tham lam; . Đôi khi hành vi này không được mong muốn; . Việc thêm
prog = re.compile[pattern] result = prog.match[string]87 sau bộ định lượng làm cho nó thực hiện khớp theo kiểu không tham lam hoặc tối thiểu; . Sử dụng RE
prog = re.compile[pattern] result = prog.match[string]811 sẽ chỉ khớp với
prog = re.compile[pattern] result = prog.match[string]809
prog = re.compile[pattern] result = prog.match[string]813,
prog = re.compile[pattern] result = prog.match[string]814,
prog = re.compile[pattern] result = prog.match[string]815
Giống như các bộ định lượng
prog = re.compile[pattern] result = prog.match[string]804,
prog = re.compile[pattern] result = prog.match[string]805 và
prog = re.compile[pattern] result = prog.match[string]806, những bộ định lượng mà
prog = re.compile[pattern] result = prog.match[string]805 đượ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ụ:
prog = re.compile[pattern] result = prog.match[string]820 sẽ khớp với
prog = re.compile[pattern] result = prog.match[string]821 vì
prog = re.compile[pattern] result = prog.match[string]822 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 quay lại để cuối cùng,
prog = re.compile[pattern] result = prog.match[string]822 khớp với tổng số 3
result = re.match[pattern, string]7 và
result = re.match[pattern, string]7 thứ tư được khớp với . Tuy nhiên, khi
prog = re.compile[pattern] result = prog.match[string]829 được sử dụng để khớp với
prog = re.compile[pattern] result = prog.match[string]821, thì
prog = re.compile[pattern] result = prog.match[string]831 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.
prog = re.compile[pattern] result = prog.match[string]834,
prog = re.compile[pattern] result = prog.match[string]835 và
prog = re.compile[pattern] result = prog.match[string]836 tương ứng với
prog = re.compile[pattern] result = prog.match[string]837,
prog = re.compile[pattern] result = prog.match[string]838 và
prog = re.compile[pattern] result = prog.match[string]839
Mới trong phiên bản 3. 11
prog = re.compile[pattern] result = prog.match[string]840
Chỉ định rằng phải khớp chính xác m bản sao của RE trước đó; . Ví dụ:
prog = re.compile[pattern] result = prog.match[string]841 sẽ khớp chính xác sáu ký tự
result = re.match[pattern, string]7, nhưng không phải năm ký tự
prog = re.compile[pattern] result = prog.match[string]88
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ụ:
prog = re.compile[pattern] result = prog.match[string]844 sẽ khớp 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ụ:
prog = re.compile[pattern] result = prog.match[string]846 sẽ khớp với
prog = re.compile[pattern] result = prog.match[string]847 hoặc một nghìn ký tự
result = re.match[pattern, string]7 theo sau bởi một
prog = re.compile[pattern] result = prog.match[string]849, nhưng không khớp với
prog = re.compile[pattern] result = prog.match[string]850. Không được bỏ dấu phẩy nếu không từ bổ nghĩa sẽ bị nhầm lẫn với dạng đã mô tả trước đó
prog = re.compile[pattern] result = prog.match[string]851
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ự
prog = re.compile[pattern] result = prog.match[string]852,
prog = re.compile[pattern] result = prog.match[string]844 sẽ khớp với 5 ký tự
result = re.match[pattern, string]7, trong khi
prog = re.compile[pattern] result = prog.match[string]855 sẽ chỉ khớp với 3 ký tự
prog = re.compile[pattern] result = prog.match[string]856
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ự
prog = re.compile[pattern] result = prog.match[string]852,
prog = re.compile[pattern] result = prog.match[string]858 cố gắng khớp 5 ký tự
result = re.match[pattern, string]7, 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
prog = re.compile[pattern] result = prog.match[string]861 sẽ khớp với
prog = re.compile[pattern] result = prog.match[string]844 bắt 5, sau đó là 4 ký tự
result = re.match[pattern, string]7 bằng cách quay lui .
prog = re.compile[pattern] result = prog.match[string]866 tương đương với
prog = re.compile[pattern] result = prog.match[string]867
Mới trong phiên bản 3. 11
prog = re.compile[pattern] result = prog.match[string]868
Thoát khỏi các ký tự đặc biệt [cho phép bạn khớp các ký tự như
prog = re.compile[pattern] result = prog.match[string]804,
prog = re.compile[pattern] result = prog.match[string]806, 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 trình tự 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
prog = re.compile[pattern] result = prog.match[string]871
Đượ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.
prog = re.compile[pattern] result = prog.match[string]
872 sẽ khớp vớiresult = re.match[pattern, string]
7,prog = re.compile[pattern] result = prog.match[string]
874 hoặcprog = re.compile[pattern] result = prog.match[string]
875
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
prog = re.compile[pattern] result = prog.match[string]
876, ví dụ:prog = re.compile[pattern] result = prog.match[string]
877 sẽ khớp với bất kỳ chữ cái ASCII viết thường nào,prog = re.compile[pattern] result = prog.match[string]
878 sẽ khớp với tất cả các số có hai chữ số từprog = re.compile[pattern] result = prog.match[string]
879 đếnprog = re.compile[pattern] result = prog.match[string]
880 vàprog = re.compile[pattern] result = prog.match[string]
881 sẽ khớp với bất kỳ chữ số thập lục phân nào. Nếuprog = re.compile[pattern] result = prog.match[string]
882 bị thoát [e. g.prog = re.compile[pattern] result = prog.match[string]
883] hoặc nếu nó được đặt làm ký tự đầu tiên hoặc cuối cùng [e. g.prog = re.compile[pattern] result = prog.match[string]
884 hoặcprog = re.compile[pattern] result = prog.match[string]
885], nó sẽ khớp với một chữprog = re.compile[pattern] result = prog.match[string]
876Các ký tự đặc biệt mất ý nghĩa đặc biệt của chúng trong các bộ. Ví dụ:
prog = re.compile[pattern] result = prog.match[string]
887 sẽ khớp với bất kỳ ký tự chữ nàoprog = re.compile[pattern] result = prog.match[string]
84,prog = re.compile[pattern] result = prog.match[string]
805,prog = re.compile[pattern] result = prog.match[string]
804 hoặcprog = re.compile[pattern] result = prog.match[string]
891
Các lớp ký tự như
prog = re.compile[pattern] result = prog.match[string]
892 hoặcprog = re.compile[pattern] result = prog.match[string]
893 [đượ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ự khớp với chúng phụ thuộc vào việc chế độprog = re.compile[pattern] result = prog.match[string]
894 hoặcprog = re.compile[pattern] result = prog.match[string]
895 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à
prog = re.compile[pattern] result = prog.match[string]
896, tất cả các ký tự không có trong tập hợp sẽ được so khớp. Ví dụ:prog = re.compile[pattern] result = prog.match[string]
897 sẽ khớp với bất kỳ ký tự nào ngoại trừprog = re.compile[pattern] result = prog.match[string]
898 vàprog = re.compile[pattern] result = prog.match[string]
899 sẽ khớp với bất kỳ ký tự nào ngoại trừprog = re.compile[pattern] result = prog.match[string]
896.prog = re.compile[pattern] result = prog.match[string]
84 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ữ
prog = re.compile[pattern] result = prog.match[string]
5002 bên trong một tập hợp, hãy thêm dấu gạch chéo ngược vào trước nó hoặc đặt nó ở đầu tập hợp. Ví dụ: cảprog = re.compile[pattern] result = prog.match[string]
5003 vàprog = re.compile[pattern] result = prog.match[string]
5004 đề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, do đó, để tạo điều kiện cho sự thay đổi này, một
prog = re.compile[pattern] result = prog.match[string]
5005 sẽ được nêu ra trong các trường hợp không rõ ràng vào lúc này. Điều đó bao gồm các bộ bắt đầu bằng một chữprog = re.compile[pattern] result = prog.match[string]
5006 hoặc chứa các chuỗi ký tự chữprog = re.compile[pattern] result = prog.match[string]
5007,prog = re.compile[pattern] result = prog.match[string]
5008,prog = re.compile[pattern] result = prog.match[string]
5009 vàprog = re.compile[pattern] result = prog.match[string]
5010. Để 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. ______15005 đượ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.
prog = re.compile[pattern] result = prog.match[string]5012
prog = re.compile[pattern] result = prog.match[string]5013, 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
prog = re.compile[pattern] result = prog.match[string]83 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
prog = re.compile[pattern] result = prog.match[string]83 đượ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ử
prog = re.compile[pattern] result = prog.match[string]83 không bao giờ tham lam. Để khớp với một chữ
prog = re.compile[pattern] result = prog.match[string]83, hãy sử dụng
prog = re.compile[pattern] result = prog.match[string]5018 hoặc đặt nó bên trong một lớp ký tự, như trong
prog = re.compile[pattern] result = prog.match[string]5019
prog = re.compile[pattern] result = prog.match[string]5020
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ữ
prog = re.compile[pattern] result = prog.match[string]84 hoặc
prog = re.compile[pattern] result = prog.match[string]891, hãy sử dụng
prog = re.compile[pattern] result = prog.match[string]5024 hoặc
prog = re.compile[pattern] result = prog.match[string]5025 hoặc đặt chúng bên trong một lớp ký tự.
prog = re.compile[pattern] result = prog.match[string]5026,
prog = re.compile[pattern] result = prog.match[string]5027
prog = re.compile[pattern] result = prog.match[string]5028
Đây là một ký hiệu mở rộng [một
prog = re.compile[pattern] result = prog.match[string]806 theo sau một
prog = re.compile[pattern] result = prog.match[string]84 không có ý nghĩa khác]. Ký tự đầu tiên sau
prog = re.compile[pattern] result = prog.match[string]806 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ợ
prog = re.compile[pattern] result = prog.match[string]5033
[Một hoặc nhiều chữ cái từ tập hợp
result = re.match[pattern, string]7,
prog = re.compile[pattern] result = prog.match[string]5035,
prog = re.compile[pattern] result = prog.match[string]5036,
prog = re.compile[pattern] result = prog.match[string]874,
prog = re.compile[pattern] result = prog.match[string]5038,
prog = re.compile[pattern] result = prog.match[string]5039,
prog = re.compile[pattern] result = prog.match[string]5040. ] Nhóm khớp với chuỗi rỗng; .
prog = re.compile[pattern] result = prog.match[string]5041 [chỉ khớp ASCII],
prog = re.compile[pattern] result = prog.match[string]5042 [bỏ qua chữ hoa chữ thường],
prog = re.compile[pattern] result = prog.match[string]5043 [phụ thuộc vào ngôn ngữ],
prog = re.compile[pattern] result = prog.match[string]5044 [nhiều dòng],
prog = re.compile[pattern] result = prog.match[string]5045 [dấu chấm khớp với tất cả],
prog = re.compile[pattern] result = prog.match[string]5046 [khớp Unicode] và
prog = re.compile[pattern] result = prog.match[string]5047 [dài dòng], cho toàn bộ thông thường . [Các cờ được mô tả trong 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 một đối số cờ cho hàm
prog = re.compile[pattern] result = prog.match[string]5048. 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.
prog = re.compile[pattern] result = prog.match[string]5049
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 trong mẫu
prog = re.compile[pattern] result = prog.match[string]5050
[Không hoặc nhiều chữ cái từ tập hợp
result = re.match[pattern, string]7,
prog = re.compile[pattern] result = prog.match[string]5035,
prog = re.compile[pattern] result = prog.match[string]5036,
prog = re.compile[pattern] result = prog.match[string]874,
prog = re.compile[pattern] result = prog.match[string]5038,
prog = re.compile[pattern] result = prog.match[string]5039,
prog = re.compile[pattern] result = prog.match[string]5040, tùy ý theo sau bởi
prog = re.compile[pattern] result = prog.match[string]876, tiếp theo là một hoặc nhiều chữ cái từ
prog = re.compile[pattern] result = prog.match[string]5035,
prog = re.compile[pattern] result = prog.match[string]874,
prog = re.compile[pattern] result = prog.match[string]5038,
prog = re.compile[pattern] result = prog.match[string]5040. ] Các chữ cái đặt hoặc loại bỏ các cờ tương ứng.
prog = re.compile[pattern] result = prog.match[string]5041 [chỉ khớp ASCII],
prog = re.compile[pattern] result = prog.match[string]5042 [bỏ qua chữ hoa chữ thường],
prog = re.compile[pattern] result = prog.match[string]5043 [phụ thuộc vào ngôn ngữ],
prog = re.compile[pattern] result = prog.match[string]5044 [nhiều dòng],
prog = re.compile[pattern] result = prog.match[string]5045 [dấu chấm khớp với tất cả],
prog = re.compile[pattern] result = prog.match[string]5046 [khớp Unicode] và
prog = re.compile[pattern] result = prog.match[string]5047 [dài dòng], đối với một phần của . [Các cờ được mô tả trong Nội dung mô-đun . ]
Các chữ cái
result = re.match[pattern, string]7,
prog = re.compile[pattern] result = prog.match[string]5036 và
prog = re.compile[pattern] result = prog.match[string]5039 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
prog = re.compile[pattern] result = prog.match[string]876. 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,
prog = re.compile[pattern] result = prog.match[string]5074 chuyển sang khớp chỉ ASCII và
prog = re.compile[pattern] result = prog.match[string]5075 chuyển sang khớp Unicode [mặc định]. Trong mẫu byte,
prog = re.compile[pattern] result = prog.match[string]5076 chuyển sang khớp tùy theo ngôn ngữ và
prog = re.compile[pattern] result = prog.match[string]5074 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,
prog = re.compile[pattern] result = prog.match[string]5036 và
prog = re.compile[pattern] result = prog.match[string]5039 cũng có thể được sử dụng trong một nhóm.
prog = re.compile[pattern] result = prog.match[string]5081
Các nỗ lực khớp với
prog = re.compile[pattern] result = prog.match[string]5082 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
prog = re.compile[pattern] result = prog.match[string]5081 vì một khi đã thoát, 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 đó,
prog = re.compile[pattern] result = prog.match[string]5084 sẽ không bao giờ khớp với bất kỳ thứ gì vì đầu tiên,
prog = re.compile[pattern] result = prog.match[string]5085 sẽ khớp với tất cả các ký tự có thể, sau đó, không còn gì để khớp,
prog = re.compile[pattern] result = prog.match[string]82 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
Mới trong phiên bản 3. 11
prog = re.compile[pattern] result = prog.match[string]5032
Tương tự như dấu ngoặc đơn thông thường, nhưng chuỗi con phù hợp với nhóm có thể truy cập thông qua tên nhóm ký hiệu. 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à
prog = re.compile[pattern] result = prog.match[string]5088 [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ó
prog = re.compile[pattern] result = prog.match[string]
5089 [như hình]prog = re.compile[pattern] result = prog.match[string]
5090
khi xử lý khớp đối tượng m
prog = re.compile[pattern] result = prog.match[string]
5091prog = re.compile[pattern] result = prog.match[string]
5092 [v.v. ]
trong một chuỗi được chuyển đến đối số thay thế của
prog = re.compile[pattern] result = prog.match[string]5093
prog = re.compile[pattern] result = prog.match[string]
5094prog = re.compile[pattern] result = prog.match[string]
5095prog = re.compile[pattern] result = prog.match[string]
5090
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.
prog = re.compile[pattern] result = prog.match[string]5097
Một phản hồi cho một nhóm được đặt tên;
prog = re.compile[pattern] result = prog.match[string]5098
Một lời bình luận;
prog = re.compile[pattern] result = prog.match[string]5099
Khớp nếu
prog = re.compile[pattern] result = prog.match[string]5082 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ụ:
prog = re.compile[pattern] result = prog.match[string]4901 sẽ chỉ khớp với
prog = re.compile[pattern] result = prog.match[string]4902 nếu theo sau nó là
prog = re.compile[pattern] result = prog.match[string]4903
prog = re.compile[pattern] result = prog.match[string]4904
Khớp nếu
prog = re.compile[pattern] result = prog.match[string]5082 không khớp tiếp theo. Đây là một khẳng định nhìn trước tiêu cực. Ví dụ:
prog = re.compile[pattern] result = prog.match[string]4906 sẽ khớp với
prog = re.compile[pattern] result = prog.match[string]4902 chỉ khi nó không theo sau bởi
prog = re.compile[pattern] result = prog.match[string]4903
prog = re.compile[pattern] result = prog.match[string]4909
Khớp nếu vị trí hiện tại trong chuỗi được bắt đầu bằng một khớp cho
prog = re.compile[pattern] result = prog.match[string]5082 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.
prog = re.compile[pattern] result = prog.match[string]4911 sẽ tìm thấy một kết quả phù hợp trong
prog = re.compile[pattern] result = prog.match[string]4912, vì giao diện 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
prog = re.compile[pattern] result = prog.match[string]4913 hoặc
prog = re.compile[pattern] result = prog.match[string]4914 nhưng
prog = re.compile[pattern] result = prog.match[string]822 và
prog = re.compile[pattern] result = prog.match[string]4916 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;
prog = re.compile[pattern] result = prog.match[string]67
Ví dụ này tìm kiếm một từ sau dấu gạch nối
prog = re.compile[pattern] result = prog.match[string]8
Đã thay đổi trong phiên bản 3. 5. Đã thêm hỗ trợ cho tham chiếu nhóm có độ dài cố định.
prog = re.compile[pattern] result = prog.match[string]4919
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
prog = re.compile[pattern] result = prog.match[string]5082. Đ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
prog = re.compile[pattern] result = prog.match[string]4921
Sẽ cố gắng khớp với
prog = re.compile[pattern] result = prog.match[string]4922 nếu nhóm có id hoặc tên đã cho tồn tại và với
prog = re.compile[pattern] result = prog.match[string]4923 nếu không.
prog = re.compile[pattern] result = prog.match[string]4923 là tùy chọn và có thể bỏ qua. Ví dụ:
prog = re.compile[pattern] result = prog.match[string]4925 là mẫu khớp email kém, sẽ khớp với
prog = re.compile[pattern] result = prog.match[string]4926 cũng như
prog = re.compile[pattern] result = prog.match[string]4927, nhưng không khớp với
prog = re.compile[pattern] result = prog.match[string]4928 và
prog = re.compile[pattern] result = prog.match[string]4929
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 dãy số đặc biệt bao gồm
prog = re.compile[pattern] result = prog.match[string]4 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ụ:
prog = re.compile[pattern] result = prog.match[string]4931 khớp với ký tự
prog = re.compile[pattern] result = prog.match[string]4932
prog = re.compile[pattern] result = prog.match[string]5021
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ụ:
prog = re.compile[pattern] result = prog.match[string]4934 khớp với
prog = re.compile[pattern] result = prog.match[string]4935 hoặc
prog = re.compile[pattern] result = prog.match[string]4936, nhưng không khớp với
prog = re.compile[pattern] result = prog.match[string]4937 [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
prog = re.compile[pattern] result = prog.match[string]5006 và
prog = re.compile[pattern] result = prog.match[string]5002 của một lớp ký tự, tất cả các số thoát được coi là ký tự
prog = re.compile[pattern] result = prog.match[string]4940
Chỉ khớp ở đầu chuỗi
prog = re.compile[pattern] result = prog.match[string]4941
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,
prog = re.compile[pattern] result = prog.match[string]4941 được định nghĩa là ranh giới giữa ký tự
prog = re.compile[pattern] result = prog.match[string]892 và ký tự
prog = re.compile[pattern] result = prog.match[string]4944 [hoặc ngược lại] hoặc giữa
prog = re.compile[pattern] result = prog.match[string]892 và phần đầu/cuối của chuỗi. Điều này có nghĩa là
prog = re.compile[pattern] result = prog.match[string]4946 khớp với
prog = re.compile[pattern] result = prog.match[string]4947,
prog = re.compile[pattern] result = prog.match[string]4948,
prog = re.compile[pattern] result = prog.match[string]4949,
prog = re.compile[pattern] result = prog.match[string]4950 nhưng không khớp với
prog = re.compile[pattern] result = prog.match[string]4951 hoặc
prog = re.compile[pattern] result = prog.match[string]4952
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ờ
prog = re.compile[pattern] result = prog.match[string]894. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ
prog = re.compile[pattern] result = prog.match[string]895 được sử dụng. Bên trong một phạm vi ký tự,
prog = re.compile[pattern] result = prog.match[string]4941 đại diện cho ký tự xóa lùi, để tương thích với chuỗi ký tự của Python
prog = re.compile[pattern] result = prog.match[string]4956
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à
prog = re.compile[pattern] result = prog.match[string]4957 khớp với
prog = re.compile[pattern] result = prog.match[string]4958,
prog = re.compile[pattern] result = prog.match[string]4959,
prog = re.compile[pattern] result = prog.match[string]4960, nhưng không khớp với
prog = re.compile[pattern] result = prog.match[string]4961,
prog = re.compile[pattern] result = prog.match[string]4962 hoặc
prog = re.compile[pattern] result = prog.match[string]4963.
prog = re.compile[pattern] result = prog.match[string]4956 hoàn toàn ngược lại với
prog = re.compile[pattern] result = prog.match[string]4941, vì vậy các ký tự từ trong các 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ờ
prog = re.compile[pattern] result = prog.match[string]894. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ
prog = re.compile[pattern] result = prog.match[string]895 được sử dụng
prog = re.compile[pattern] result = prog.match[string]4968Đố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
prog = re.compile[pattern] result = prog.match[string]4969 và nhiều ký tự chữ số khác. Nếu cờ
prog = re.compile[pattern] result = prog.match[string]894 chỉ được sử dụng thì
prog = re.compile[pattern] result = prog.match[string]4969 đượ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;
prog = re.compile[pattern] result = prog.match[string]4973
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
prog = re.compile[pattern] result = prog.match[string]4968. Nếu cờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, nó sẽ tương đương với
prog = re.compile[pattern] result = prog.match[string]4976
prog = re.compile[pattern] result = prog.match[string]4977Đối với các mẫu Unicode [str]
So khớp các ký tự khoảng trắng Unicode [bao gồm
prog = re.compile[pattern] result = prog.match[string]4978 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ờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, chỉ có
prog = re.compile[pattern] result = prog.match[string]4978 đượ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;
prog = re.compile[pattern] result = prog.match[string]893
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
prog = re.compile[pattern] result = prog.match[string]4977. Nếu cờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, nó sẽ tương đương với
prog = re.compile[pattern] result = prog.match[string]4985
prog = re.compile[pattern] result = prog.match[string]892Đối với các mẫu Unicode [str]
Khớp các ký tự từ Unicode; . Nếu cờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, chỉ có
prog = re.compile[pattern] result = prog.match[string]4990 đượ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ờ
prog = re.compile[pattern] result = prog.match[string]895 được sử dụng, khớp các ký tự được coi là chữ và số ở ngôn ngữ hiện tại và dấu gạch dưới
prog = re.compile[pattern] result = prog.match[string]4944
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
prog = re.compile[pattern] result = prog.match[string]892. Nếu cờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, nó sẽ tương đương với
prog = re.compile[pattern] result = prog.match[string]4996. Nếu cờ
prog = re.compile[pattern] result = prog.match[string]895 đượ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
prog = re.compile[pattern] result = prog.match[string]4998
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
prog = re.compile[pattern] result = prog.match[string]50
[Lưu ý rằng
prog = re.compile[pattern] result = prog.match[string]4941 đượ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
prog = re.compile[pattern] result = prog.match[string]5100,
prog = re.compile[pattern] result = prog.match[string]5101 và
prog = re.compile[pattern] result = prog.match[string]5102 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
prog = re.compile[pattern] result = prog.match[string]5100 và
prog = re.compile[pattern] result = prog.match[string]5101 đã được thêm vào.
Đã thay đổi trong phiên bản 3. 6. Unknown escapes consisting of
prog = re.compile[pattern] result = prog.match[string]4 and an ASCII letter now are errors.
Đã thay đổi trong phiên bản 3. 8. Trình tự thoát
prog = re.compile[pattern] result = prog.match[string]5106 đã đượ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.
prog = re.compile[pattern] result = prog.match[string]5107].
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à phiên bản của
prog = re.compile[pattern] result = prog.match[string]5108, là lớp con của
prog = re.compile[pattern] result = prog.match[string]5109. lớp lại. RegexFlag ¶
Một lớp
prog = re.compile[pattern] result = prog.match[string]5109 chứa các tùy chọn biểu thức chính quy được liệt kê bên dưới
Mới trong phiên bản 3. 11. - được thêm vào
prog = re.compile[pattern] result = prog.match[string]5111lại. A ¶ lại. ASCII ¶
Làm cho
prog = re.compile[pattern] result = prog.match[string]892,
prog = re.compile[pattern] result = prog.match[string]4944,
prog = re.compile[pattern] result = prog.match[string]4941,
prog = re.compile[pattern] result = prog.match[string]4956,
prog = re.compile[pattern] result = prog.match[string]4968,
prog = re.compile[pattern] result = prog.match[string]4973,
prog = re.compile[pattern] result = prog.match[string]4977 và
prog = re.compile[pattern] result = prog.match[string]893 thực hiện 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
prog = re.compile[pattern] result = prog.match[string]5120
Lưu ý rằng để tương thích ngược, cờ
prog = re.compile[pattern] result = prog.match[string]5046 vẫn tồn tại [cũng như từ đồng nghĩa của nó là
prog = re.compile[pattern] result = prog.match[string]5122 và đối tác được nhúng của nó là
prog = re.compile[pattern] result = prog.match[string]5123], nhưng chú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 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ôi ¶ lạ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
prog = re.compile[pattern] result = prog.match[string]5125 với
prog = re.compile[pattern] result = prog.match[string]5126] cũng hoạt động trừ khi cờ
prog = re.compile[pattern] result = prog.match[string]5127 đượ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ờ
prog = re.compile[pattern] result = prog.match[string]5128 cũng được sử dụng. Tương ứng với cờ nội tuyến
prog = re.compile[pattern] result = prog.match[string]5129
Lưu ý rằng khi các mẫu Unicode
prog = re.compile[pattern] result = prog.match[string]877 hoặc
prog = re.compile[pattern] result = prog.match[string]5124 được sử dụng kết hợp với cờ
prog = re.compile[pattern] result = prog.match[string]5132, 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ờ
prog = re.compile[pattern] result = prog.match[string]894 được sử dụng, chỉ các chữ cái từ 'a' đến 'z' và 'A' đến 'Z' được khớplại. L ¶ lại. ĐỊA ĐIỂM ¶
Làm cho đối sánh
prog = re.compile[pattern] result = prog.match[string]892,
prog = re.compile[pattern] result = prog.match[string]4944,
prog = re.compile[pattern] result = prog.match[string]4941,
prog = re.compile[pattern] result = prog.match[string]4956 và không phân biệt chữ hoa chữ thường phụ 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
prog = re.compile[pattern] result = prog.match[string]5138
Đã thay đổi trong phiên bản 3. 6. ______35128 chỉ có thể được sử dụng với các mẫu byte và không tương thích với
prog = re.compile[pattern] result = prog.match[string]5127.
Đã 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ờ
prog = re.compile[pattern] result = prog.match[string]5128 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. ĐA DÒNG ¶
When specified, the pattern character
prog = re.compile[pattern] result = prog.match[string]896 matches at the beginning of the string and at the beginning of each line [immediately following each newline]; and the pattern character
prog = re.compile[pattern] result = prog.match[string]4932 matches at the end of the string and at the end of each line [immediately preceding each newline]. Theo mặc định,
prog = re.compile[pattern] result = prog.match[string]896 chỉ khớp ở đầu chuỗi và
prog = re.compile[pattern] result = prog.match[string]4932 chỉ ở 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
prog = re.compile[pattern] result = prog.match[string]5146lại. NOFLAG ¶
Cho biết không có cờ nào được áp dụng, giá trị là
prog = re.compile[pattern] result = prog.match[string]5147. 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
prog = re.compile[pattern] result = prog.match[string]49
Mới trong phiên bản 3. 11
lại. S ¶ lại. DOTALL ¶Làm cho ký tự đặc biệt
prog = re.compile[pattern] result = prog.match[string]5148 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
prog = re.compile[pattern] result = prog.match[string]5150lại. 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 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 đứ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ư
prog = re.compile[pattern] result = prog.match[string]801,
prog = re.compile[pattern] result = prog.match[string]5152 hoặc
prog = re.compile[pattern] result = prog.match[string]5153. Ví dụ:
prog = re.compile[pattern] result = prog.match[string]5154 và
prog = re.compile[pattern] result = prog.match[string]5155 không được phép. Khi một dòng chứa
prog = re.compile[pattern] result = prog.match[string]5156 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ư
prog = re.compile[pattern] result = prog.match[string]5156 đế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
prog = re.compile[pattern] result = prog.match[string]51
Tương ứng với cờ nội tuyến
prog = re.compile[pattern] result = prog.match[string]5158
Chức năng¶
lại. biên dịch[mẫu , cờ=0]¶Compile a regular expression pattern into a regular expression object , which can be used for matching using its
prog = re.compile[pattern] result = prog.match[string]4918,
prog = re.compile[pattern] result = prog.match[string]4917 and other methods, described below.
Hành vi của biểu thức có thể được sửa đổi bằng cách chỉ định giá trị cờ. Values can be any of the following variables, combined using bitwise OR [the
prog = re.compile[pattern] result = prog.match[string]5012 operator]
The sequence
prog = re.compile[pattern] result = prog.match[string]
tương đương với
________số 8
nhưng sử dụng
prog = re.compile[pattern] result = prog.match[string]5048 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 tới
prog = re.compile[pattern] result = prog.match[string]5048 và các hàm 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 lo lắng về việc biên dịch các biểu thức chính quylại. tìm kiếm[mẫu , chuỗi, flags=0]¶
Scan through string looking for the first location where the regular expression pattern produces a match, and return a corresponding match object . Return
prog = re.compile[pattern] result = prog.match[string]5164 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. 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 đối tượng khớp tương ứng. Return
prog = re.compile[pattern] result = prog.match[string]5164 if the string does not match the pattern; note that this is different from a zero-length match.
Lưu ý rằng ngay cả trong chế độ
prog = re.compile[pattern] result = prog.match[string]85,
prog = re.compile[pattern] result = prog.match[string]5167 sẽ chỉ khớp ở đầu chuỗi chứ không phải ở đầu mỗi dòng
If you want to locate a match anywhere in string, use
prog = re.compile[pattern] result = prog.match[string]4917 instead [see also search[] vs. khớp[] ]. 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 đối tượng khớp tương ứng. Trả lại
prog = re.compile[pattern] result = prog.match[string]5164 nếu chuỗi không khớp với mẫu; .
New in version 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. If capturing parentheses are used in pattern, then the text of all groups in the pattern are also returned as part of the resulting list. If maxsplit is nonzero, at most maxsplit splits occur, and the remainder of the string is returned as the final element of the list
prog = re.compile[pattern] result = prog.match[string]8
If there are capturing groups in the separator and it matches at the start of the string, the result will start with an empty string. The same holds for the end of the string
prog = re.compile[pattern] result = prog.match[string]8
That way, separator components are always found at the same relative indices within the result list
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 đó
prog = re.compile[pattern] result = prog.match[string]8
Đã thay đổi trong phiên bản 3. 1. Added the optional flags argument.
Đã thay đổi trong phiên bản 3. 7. Added support of splitting on a pattern that could match an empty string.
lại. findall[pattern , string , flags=0] ¶Return all non-overlapping matches of pattern in string, as a list of strings or tuples. 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. If there is exactly one group, return a list of strings matching that group. 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ả
prog = re.compile[pattern] result = prog.match[string]80
Đã thay đổi trong phiên bản 3. 7. Non-empty matches can now start just after a previous empty match.
lại. finditer[pattern , string , flags=0] ¶Trả về một trình lặp mang lại các đối tượng khớp trên tất cả các đối tượng không . 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. Non-empty matches can now start just after a previous empty match.
lại. sub[pattern , repl , string , count=0 , flags=0] ¶Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 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à,
prog = re.compile[pattern] result = prog.match[string]5170 được chuyển đổi thành một ký tự xuống dòng,
prog = re.compile[pattern] result = prog.match[string]5171 đượ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. Other unknown escapes such as
prog = re.compile[pattern] result = prog.match[string]5172 are left alone. Backreferences, such as
prog = re.compile[pattern] result = prog.match[string]5173, are replaced with the substring matched by group 6 in the pattern. Ví dụ
prog = re.compile[pattern] result = prog.match[string]81
Nếu repl là một hàm, thì 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ố match object và trả về chuỗi thay thế. Ví dụ.
prog = re.compile[pattern] result = prog.match[string]82
The pattern may be a string or a pattern object .
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ế. Empty matches for the pattern are replaced only when not adjacent to a previous empty match, so
prog = re.compile[pattern] result = prog.match[string]5174 returns
prog = re.compile[pattern] result = prog.match[string]5175
In string-type repl arguments, in addition to the character escapes and backreferences described above,
prog = re.compile[pattern] result = prog.match[string]5176 will use the substring matched by the group named
prog = re.compile[pattern] result = prog.match[string]5177, as defined by the
prog = re.compile[pattern] result = prog.match[string]5032 syntax.
prog = re.compile[pattern] result = prog.match[string]5179 sử dụng số nhóm tương ứng; .
prog = re.compile[pattern] result = prog.match[string]5183 would be interpreted as a reference to group 20, not a reference to group 2 followed by the literal character
result = re.match[pattern, string]8. Tham chiếu ngược
prog = re.compile[pattern] result = prog.match[string]5185 thay thế trong toàn bộ chuỗi con khớp với RE
Đã thay đổi trong phiên bản 3. 1. Added the optional flags argument.
Đã thay đổi trong phiên bản 3. 5. Unmatched groups are replaced with an empty string.
Đã 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 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. Group id containing anything except ASCII digits. Group names containing non-ASCII characters in bytes replacement strings.
lại. subn[pattern , repl , string , count=0 , flags=0] ¶Thực hiện thao tác tương tự như
prog = re.compile[pattern] result = prog.match[string]5188, nhưng trả về một bộ dữ liệu
prog = re.compile[pattern] result = prog.match[string]5189
Đã thay đổi trong phiên bản 3. 1. Added the optional flags argument.
Đã thay đổi trong phiên bản 3. 5. Unmatched groups are replaced with an empty string.
lại. thoát[mẫu] ¶Thoát các ký tự đặc biệt trong mẫu. This is useful if you want to match an arbitrary literal string that may have regular expression metacharacters in it. For example
prog = re.compile[pattern] result = prog.match[string]83
Hàm này không được sử dụng cho chuỗi thay thế trong
prog = re.compile[pattern] result = prog.match[string]5188 và
prog = re.compile[pattern] result = prog.match[string]5191, chỉ nên thoát dấu gạch chéo ngược. Ví dụ
prog = re.compile[pattern] result = prog.match[string]84
Đã thay đổi trong phiên bản 3. 3. The
prog = re.compile[pattern] result = prog.match[string]5192 character is no longer escaped.
Đã thay đổi trong phiên bản 3. 7. Only characters that can have special meaning in a regular expression are escaped. Do đó,
prog = re.compile[pattern] result = prog.match[string]5193,
prog = re.compile[pattern] result = prog.match[string]5194,
prog = re.compile[pattern] result = prog.match[string]5195,
prog = re.compile[pattern] result = prog.match[string]5196,
prog = re.compile[pattern] result = prog.match[string]5197,
prog = re.compile[pattern] result = prog.match[string]5198,
prog = re.compile[pattern] result = prog.match[string]5199,
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 và
prog = re.compile[pattern] result = prog.match[string]05 không còn thoát. lại. purge[] ¶
Xóa bộ đệm biểu thức chính quy
Exceptions¶
exception re. lỗi[thông báo , mẫu=None, pos=None]¶Ngoại lệ xuất hiện khi một chuỗi được chuyển đến một trong các hàm ở đây không phải là một biểu thức chính quy hợp lệ [ví dụ: nó có thể chứa các dấu ngoặc đơn chưa khớp] hoặc khi một số lỗi khác xảy ra trong quá trình biên dịch hoặc so khớp. Không bao giờ là lỗi nếu một chuỗi không khớp với một mẫu. The error instance has the following additional attributes
msg ¶The unformatted error message
pattern ¶Mẫu biểu thức chính quy
tư thế ¶The index in pattern where compilation failed [may be
prog = re.compile[pattern] result = prog.match[string]5164]lineno ¶
The line corresponding to pos [may be
prog = re.compile[pattern] result = prog.match[string]5164]colno ¶
Cột tương ứng với pos [có thể là
prog = re.compile[pattern] result = prog.match[string]5164]
Đã thay đổi trong phiên bản 3. 5. Added additional attributes.
Regular Expression Objects¶
Các đối tượng biểu thức chính quy được biên dịch hỗ trợ các phương thức và thuộc tính sau
Pattern. tìm kiếm[chuỗi[ , pos[, endpos]]]¶Quét qua chuỗi để 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ề một đối tượng khớp tương ứng. Return
prog = re.compile[pattern] result = prog.match[string]5164 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
prog = re.compile[pattern] result = prog.match[string]5147. This is not completely equivalent to slicing the string; the
prog = re.compile[pattern] result = prog.match[string]896 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
Tham số tùy chọn endpos giới hạn khoảng cách chuỗi sẽ được tìm kiếm; . 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
prog = re.compile[pattern] result = prog.match[string]85Pattern. khớp[chuỗi[ , pos[, endpos]]]¶
Nếu không hoặc nhiều ký tự ở đầu chuỗi khớp với biểu thức chính quy này, hãy trả về một đối tượng khớp tương ứng. Trả lại
prog = re.compile[pattern] result = prog.match[string]5164 nếu chuỗi không khớp với mẫu; .
Các tham số pos và endpos tùy chọn có cùng ý nghĩa như đối với phương thức
prog = re.compile[pattern] result = prog.match[string]4917
prog = re.compile[pattern] result = prog.match[string]86
If you want to locate a match anywhere in string, use
prog = re.compile[pattern] result = prog.match[string]4917 instead [see also search[] vs. khớp[] ]. 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 đối tượng khớp tương ứng. Trả lại
prog = re.compile[pattern] result = prog.match[string]5164 nếu chuỗi không khớp với mẫu; .
Các tham số pos và endpos tùy chọn có cùng ý nghĩa như đối với phương thức
prog = re.compile[pattern] result = prog.match[string]4917
prog = re.compile[pattern] result = prog.match[string]87
New in version 3. 4
Pattern. tách[chuỗi , maxsplit=0]¶Identical to the
prog = re.compile[pattern] result = prog.match[string]20 function, using the compiled patternMẫu. tìm tất cả[chuỗi[ , pos[, endpos]]]¶
Similar to the
prog = re.compile[pattern] result = prog.match[string]21 function, using the compiled pattern, but also accepts optional pos and endpos parameters that limit the search region like for
prog = re.compile[pattern] result = prog.match[string]4917Mẫu. công cụ tìm[chuỗi[ , pos[, endpos]]]¶
Tương tự như hàm
prog = re.compile[pattern] result = prog.match[string]23, 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
prog = re.compile[pattern] result = prog.match[string]4917Pattern. sub[repl , chuỗi, count=0]¶
Giống với hàm
prog = re.compile[pattern] result = prog.match[string]5188, sử dụng mẫu đã biên dịchMẫu. subn[repl , string , count=0] ¶
Giống với hàm
prog = re.compile[pattern] result = prog.match[string]5191, sử dụng mẫu đã biên dịchMẫu. flags ¶
Các cờ phù hợp với regex. This is a combination of the flags given to
prog = re.compile[pattern] result = prog.match[string]27, any
prog = re.compile[pattern] result = prog.match[string]5028 inline flags in the pattern, and implicit flags such as
prog = re.compile[pattern] result = prog.match[string]29 if the pattern is a Unicode stringPattern. groups ¶
The number of capturing groups in the pattern
Pattern. groupindex ¶A dictionary mapping any symbolic group names defined by
prog = re.compile[pattern] result = prog.match[string]30 to group numbers. The dictionary is empty if no symbolic groups were used in the patternPattern. pattern ¶
The pattern string from which the pattern object was compiled
Changed in version 3. 7. Added support of
prog = re.compile[pattern] result = prog.match[string]31 and
prog = re.compile[pattern] result = prog.match[string]32. Compiled regular expression objects are considered atomic.
Match Objects¶
Match objects always have a boolean value of
prog = re.compile[pattern] result = prog.match[string]33. Since
prog = re.compile[pattern] result = prog.match[string]4918 and
prog = re.compile[pattern] result = prog.match[string]4917 return
prog = re.compile[pattern] result = prog.match[string]5164 when there is no match, you can test whether there was a match with a simple
prog = re.compile[pattern] result = prog.match[string]37 statement
prog = re.compile[pattern] result = prog.match[string]88
Match objects support the following methods and attributes
Match. expand[template] ¶Return the string obtained by doing backslash substitution on the template string template, as done by the
prog = re.compile[pattern] result = prog.match[string]5188 method. Escapes such as
prog = re.compile[pattern] result = prog.match[string]5170 are converted to the appropriate characters, and numeric backreferences [
prog = re.compile[pattern] result = prog.match[string]5090,
prog = re.compile[pattern] result = prog.match[string]5181] and named backreferences [
prog = re.compile[pattern] result = prog.match[string]5095,
prog = re.compile[pattern] result = prog.match[string]5176] are replaced by the contents of the corresponding group
Đã thay đổi trong phiên bản 3. 5. Unmatched groups are replaced with an empty string.
Match. group[[group1 , . ]] ¶Returns one or more subgroups of the match. If there is a single argument, the result is a single string; if there are multiple arguments, the result is a tuple with one item per argument. Without arguments, group1 defaults to zero [the whole match is returned]. If a groupN argument is zero, the corresponding return value is the entire matching string; if it is in the inclusive range [1. 99], it is the string matching the corresponding parenthesized group. If a group number is negative or larger than the number of groups defined in the pattern, an
prog = re.compile[pattern] result = prog.match[string]44 exception is raised. If a group is contained in a part of the pattern that did not match, the corresponding result is
prog = re.compile[pattern] result = prog.match[string]5164. If a group is contained in a part of the pattern that matched multiple times, the last match is returned
prog = re.compile[pattern] result = prog.match[string]89
If the regular expression uses the
prog = re.compile[pattern] result = prog.match[string]5032 syntax, the groupN arguments may also be strings identifying groups by their group name. If a string argument is not used as a group name in the pattern, an
prog = re.compile[pattern] result = prog.match[string]44 exception is raised
A moderately complicated example
prog = re.compile[pattern] result = prog.match[string]500
Named groups can also be referred to by their index
prog = re.compile[pattern] result = prog.match[string]501
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
prog = re.compile[pattern] result = prog.match[string]502Trù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
prog = re.compile[pattern] result = prog.match[string]503
Các nhóm được đặt tên cũng được hỗ trợ
prog = re.compile[pattern] result = prog.match[string]504
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ụ
prog = re.compile[pattern] result = prog.match[string]505
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à
prog = re.compile[pattern] result = prog.match[string]5164 trừ khi đối số mặc định được đưa ra
prog = re.compile[pattern] result = prog.match[string]506Trù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ụ
prog = re.compile[pattern] result = prog.match[string]507Trù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 được khớp bởi nhóm g [tương đương với
prog = re.compile[pattern] result = prog.match[string]48] là
prog = re.compile[pattern] result = prog.match[string]508
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ệ
prog = re.compile[pattern] result = prog.match[string]44
Một ví dụ sẽ xóa remove_this khỏi địa chỉ email
prog = re.compile[pattern] result = prog.match[string]509Trù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 đấuTrùng khớp. tư thế ¶
Giá trị của pos được truyền cho phương thức
prog = re.compile[pattern] result = prog.match[string]4917 hoặc
prog = re.compile[pattern] result = prog.match[string]4918 của đối tượng biểu thức chính quy . Đâ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. Trùng khớp. endpos ¶
Giá trị của endpos đã được truyền cho phương thức
prog = re.compile[pattern] result = prog.match[string]4917 hoặc
prog = re.compile[pattern] result = prog.match[string]4918 của đối tượng biểu thức chính quy . Đâ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 chụp được khớp cuối cùng hoặc
prog = re.compile[pattern] result = prog.match[string]5164 nếu không có nhóm nào được khớp. 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ỗiTrùng khớp. nhóm cuối cùng ¶
Tên của nhóm chụp được khớp cuối cùng hoặc
prog = re.compile[pattern] result = prog.match[string]5164 nếu nhóm không có tên hoặc nếu không có nhóm nào khớp cảTrùng khớp. lại ¶
Đối tượng biểu thức chính quy có phương thức
prog = re.compile[pattern] result = prog.match[string]4918 hoặc
prog = re.compile[pattern] result = prog.match[string]4917 tạo ra thể hiện so khớp này. Trùng khớp. chuỗi ¶
Chuỗi được chuyển đến
prog = re.compile[pattern] result = prog.match[string]4918 hoặc
prog = re.compile[pattern] result = prog.match[string]4917
Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ của
prog = re.compile[pattern] result = prog.match[string]31 và
prog = re.compile[pattern] result = prog.match[string]32. Các đối tượng phù hợp được coi là nguyên tử.
Các ví dụ về 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
prog = re.compile[pattern] result = prog.match[string]490
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
prog = re.compile[pattern] result = prog.match[string]491
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
prog = re.compile[pattern] result = prog.match[string]492
Để tìm ra cặp thẻ bao gồm những gì, người ta có thể sử dụng phương thức
prog = re.compile[pattern] result = prog.match[string]85 của đối tượng khớp theo cách sau
prog = re.compile[pattern] result = prog.match[string]493
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 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
Mã thông báo
prog = re.compile[pattern] result = prog.match[string]86
Biểu hiện thông thường
prog = re.compile[pattern] result = prog.match[string]90
prog = re.compile[pattern] result = prog.match[string]82
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ư
prog = re.compile[pattern] result = prog.match[string]494
bạn sẽ sử dụng định dạng
prog = re.compile[pattern] result = prog.match[string]86 như
prog = re.compile[pattern] result = prog.match[string]495
Biểu thức chính quy tương đương sẽ là
prog = re.compile[pattern] result = prog.match[string]496
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
prog = re.compile[pattern] result = prog.match[string]
5167 chỉ kiểm tra sự trùng khớp ở đầu chuỗiresult = re.match[pattern, string]
14 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]result = re.match[pattern, string]
15 kiểm tra xem toàn bộ chuỗi có khớp không
Ví dụ
prog = re.compile[pattern] result = prog.match[string]497
Biểu thức chính quy bắt đầu bằng
prog = re.compile[pattern] result = prog.match[string]896 có thể được sử dụng với
prog = re.compile[pattern] result = prog.match[string]4917 để hạn chế khớp ở đầu chuỗi
prog = re.compile[pattern] result = prog.match[string]498
Tuy nhiên, lưu ý rằng trong chế độ
prog = re.compile[pattern] result = prog.match[string]85,
prog = re.compile[pattern] result = prog.match[string]4918 chỉ khớp ở đầu chuỗi, trong khi sử dụng
prog = re.compile[pattern] result = prog.match[string]4917 với biểu thức chính quy bắt đầu bằng
prog = re.compile[pattern] result = prog.match[string]896 sẽ khớp ở đầu mỗi dòng
prog = re.compile[pattern] result = prog.match[string]499
Tạo danh bạ¶
prog = re.compile[pattern] result = prog.match[string]20 tách 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 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
prog = re.compile[pattern] result = prog.match[string]510
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
prog = re.compile[pattern] result = prog.match[string]511
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 của
prog = re.compile[pattern] result = prog.match[string]20 vì địa chỉ có dấu cách, mẫu phân tách của chúng tôi, trong đó
prog = re.compile[pattern] result = prog.match[string]512
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
prog = re.compile[pattern] result = prog.match[string]513
Nhập văn bản¶
prog = re.compile[pattern] result = prog.match[string]5188 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
prog = re.compile[pattern] result = prog.match[string]5188 với chức năng “munge” 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
prog = re.compile[pattern] result = prog.match[string]514
Tìm tất cả trạng từ¶
prog = re.compile[pattern] result = prog.match[string]21 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ư
prog = re.compile[pattern] result = prog.match[string]4917. 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
prog = re.compile[pattern] result = prog.match[string]21 theo cách sau
prog = re.compile[pattern] result = prog.match[string]515
Tìm tất 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 đối sánh của một mẫu hơn là văn bản đối sánh, thì
prog = re.compile[pattern] result = prog.match[string]23 sẽ hữu ích vì nó cung cấp đối tượng đối sánh thay vì các chuỗi. Tiếp tục với ví dụ trước, nếu một 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
prog = re.compile[pattern] result = prog.match[string]23 theo cách sau.
prog = re.compile[pattern] result = prog.match[string]516
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
prog = re.compile[pattern] result = prog.match[string]517
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
prog = re.compile[pattern] result = prog.match[string]518
Viết Tokenizer¶
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
prog = re.compile[pattern] result = prog.match[string]519
Trình mã thông báo tạo đầu ra sau
prog = re.compile[pattern] result = prog.match[string]0Frie09
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