Tài liệu này là hướng dẫn giới thiệu về cách sử dụng biểu thức chính quy trong Python với mô-đun
>>> p.match[""] >>> print[p.match[""]] None5. Nó cung cấp phần giới thiệu nhẹ nhàng hơn phần tương ứng trong Thư viện tham khảo
Giới thiệu¶
Các biểu thức chính quy [được gọi là RE, hoặc biểu thức chính quy hoặc mẫu biểu thức chính quy] về cơ bản là một ngôn ngữ lập trình nhỏ, chuyên biệt cao được nhúng bên trong Python và được cung cấp thông qua mô-đun
>>> p.match[""] >>> print[p.match[""]] None5. Sử dụng ngôn ngữ nhỏ này, bạn chỉ định các quy tắc cho tập hợp các chuỗi có thể mà bạn muốn so khớp; . Sau đó, bạn có thể đặt các câu hỏi như “Chuỗi này có khớp với mẫu không?”, hoặc “Có vị trí nào phù hợp với mẫu ở bất kỳ đâu trong chuỗi này không?”. Bạn cũng có thể sử dụng RE để sửa đổi một chuỗi hoặc tách nó ra theo nhiều cách khác nhau
Các mẫu biểu thức chính quy được biên dịch thành một chuỗi mã byte, sau đó được thực thi bởi một công cụ khớp được viết bằng C. Để sử dụng nâng cao, có thể cần chú ý cẩn thận đến cách công cụ sẽ thực thi một RE nhất định và viết RE theo một cách nhất định để tạo mã byte chạy nhanh hơn. Tối ưu hóa không được đề cập trong tài liệu này vì nó yêu cầu bạn phải hiểu rõ về nội bộ của công cụ phù hợp
Ngôn ngữ biểu thức chính quy tương đối nhỏ và bị hạn chế, vì vậy không phải tất cả các tác vụ xử lý chuỗi có thể đều có thể được thực hiện bằng biểu thức chính quy. Cũng có những nhiệm vụ có thể được thực hiện với các biểu thức thông thường, nhưng các biểu thức này rất phức tạp. Trong những trường hợp này, bạn nên viết mã Python để xử lý;
Mẫu đơn giản¶
Chúng ta sẽ bắt đầu bằng cách tìm hiểu về các biểu thức chính quy đơn giản nhất có thể. Vì các biểu thức chính quy được sử dụng để hoạt động trên các chuỗi, chúng tôi sẽ bắt đầu với tác vụ phổ biến nhất. ký tự phù hợp
Để có giải thích chi tiết về khoa học máy tính làm cơ sở cho các biểu thức chính quy [máy tự động hữu hạn xác định và không xác định], bạn có thể tham khảo hầu hết mọi sách giáo khoa về viết trình biên dịch
Nhân vật phù hợp¶
Hầu hết các chữ cái và ký tự sẽ tự khớp với nhau. Ví dụ: biểu thức chính quy
>>> p.match[""] >>> print[p.match[""]] None7 sẽ khớp chính xác với chuỗi
>>> p.match[""] >>> print[p.match[""]] None7. [Bạn có thể bật chế độ không phân biệt chữ hoa chữ thường để RE này khớp với cả
>>> p.match[""] >>> print[p.match[""]] None9 hoặc
>>> m = p.match['tempo'] >>> m0; thông tin thêm về điều này sau. ]
Có những ngoại lệ đối với quy tắc này; . Thay vào đó, chúng báo hiệu rằng một số điều khác thường nên được khớp hoặc chúng ảnh hưởng đến các phần khác của RE bằng cách lặp lại chúng hoặc thay đổi ý nghĩa của chúng. Phần lớn tài liệu này được dành để thảo luận về các siêu ký tự khác nhau và chức năng của chúng.
Đây là danh sách đầy đủ các siêu ký tự;
. ^ $ * + ? { } [ ] \ | [ ]
Các siêu ký tự đầu tiên chúng ta sẽ xem xét là
>>> m = p.match['tempo'] >>> m1 và
>>> m = p.match['tempo'] >>> m2. Chúng được sử dụng để chỉ định một lớp ký tự, là một tập hợp các ký tự mà bạn muốn so khớp. Các ký tự có thể được liệt kê riêng lẻ hoặc có thể chỉ định một loạt các ký tự bằng cách đưa ra hai ký tự và phân tách chúng bằng dấu
>>> m = p.match['tempo'] >>> m3. Ví dụ:
>>> m = p.match['tempo'] >>> m4 sẽ khớp với bất kỳ ký tự nào trong số các ký tự
>>> m = p.match['tempo'] >>> m5,
>>> m = p.match['tempo'] >>> m6 hoặc
>>> m = p.match['tempo'] >>> m7; . Nếu bạn chỉ muốn khớp các chữ cái viết thường, RE của bạn sẽ là
>>> m = p.match['tempo'] >>> m9
Siêu ký tự [ngoại trừ
>>> p.match[""] >>> print[p.match[""]] None60] không hoạt động bên trong các lớp. Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None61 sẽ khớp với bất kỳ ký tự nào trong số các ký tự
>>> p.match[""] >>> print[p.match[""]] None62,
>>> p.match[""] >>> print[p.match[""]] None63,
>>> p.match[""] >>> print[p.match[""]] None64 hoặc
>>> p.match[""] >>> print[p.match[""]] None65;
Bạn có thể khớp các ký tự không được liệt kê trong lớp bằng cách bổ sung bộ. Điều này được biểu thị bằng cách bao gồm một
>>> p.match[""] >>> print[p.match[""]] None67 là ký tự đầu tiên của lớp. Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None68 sẽ khớp với bất kỳ ký tự nào ngoại trừ
>>> p.match[""] >>> print[p.match[""]] None69. Nếu dấu mũ xuất hiện ở nơi khác trong một lớp ký tự, nó không có ý nghĩa đặc biệt. Ví dụ.
>>> p.match[""] >>> print[p.match[""]] None60 sẽ khớp với một trong hai
>>> p.match[""] >>> print[p.match[""]] None69 hoặc một
>>> p.match[""] >>> print[p.match[""]] None67
Có lẽ siêu ký tự quan trọng nhất là dấu gạch chéo ngược,
>>> p.match[""] >>> print[p.match[""]] None60. Như trong chuỗi ký tự Python, dấu gạch chéo ngược có thể được theo sau bởi các ký tự khác nhau để báo hiệu các chuỗi đặc biệt khác nhau. Nó cũng được sử dụng để thoát khỏi tất cả các siêu ký tự để bạn vẫn có thể khớp chúng theo mẫu; .
>>> p.match[""] >>> print[p.match[""]] None66 hoặc
>>> p.match[""] >>> print[p.match[""]] None67
Một số chuỗi đặc biệt bắt đầu bằng
>>> p.match[""] >>> print[p.match[""]] None68 đại diện cho các bộ ký tự được xác định trước thường hữu ích, chẳng hạn như tập hợp các chữ số, tập hợp các chữ cái hoặc tập hợp bất kỳ thứ gì không phải là khoảng trắng
Hãy lấy một ví dụ.
>>> p.match[""] >>> print[p.match[""]] None69 khớp với bất kỳ ký tự chữ và số nào. Nếu mẫu biểu thức chính quy được biểu thị bằng byte, điều này tương đương với lớp
>>> p.match[""] >>> print[p.match[""]] None60. Nếu mẫu biểu thức chính quy là một chuỗi, thì
>>> p.match[""] >>> print[p.match[""]] None69 sẽ khớp với tất cả các ký tự được đánh dấu là chữ cái trong cơ sở dữ liệu Unicode do mô-đun
>>> p.match[""] >>> print[p.match[""]] None62 cung cấp. Bạn có thể sử dụng định nghĩa hạn chế hơn của
>>> p.match[""] >>> print[p.match[""]] None69 trong mẫu chuỗi bằng cách cung cấp cờ
>>> p.match[""] >>> print[p.match[""]] None64 khi biên dịch biểu thức chính quy
Danh sách trình tự đặc biệt sau đây chưa đầy đủ. Để biết danh sách đầy đủ các chuỗi và định nghĩa lớp mở rộng cho các mẫu chuỗi Unicode, hãy xem phần cuối của Cú pháp biểu thức chính quy trong tài liệu tham khảo Thư viện chuẩn. Nói chung, các phiên bản Unicode khớp với bất kỳ ký tự nào trong danh mục phù hợp trong cơ sở dữ liệu Unicode.
>>> p.match[""] >>> print[p.match[""]] None65
Khớp với bất kỳ chữ số thập phân nào;
>>> p.match[""] >>> print[p.match[""]] None67
Khớp với bất kỳ ký tự không phải chữ số nào;
>>> p.match[""] >>> print[p.match[""]] None69
Khớp với bất kỳ ký tự khoảng trắng nào;
>>> p.match[""] >>> print[p.match[""]] None61
Khớp với bất kỳ ký tự không phải khoảng trắng nào;
>>> p.match[""] >>> print[p.match[""]] None69
Khớp với bất kỳ ký tự chữ và số nào;
>>> p.match[""] >>> print[p.match[""]] None65
Khớp với bất kỳ ký tự không phải chữ và số nào;
Các chuỗi này có thể được đưa vào bên trong một lớp ký tự. Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None67 là một lớp ký tự sẽ khớp với bất kỳ ký tự khoảng trắng nào hoặc
>>> p.match[""] >>> print[p.match[""]] None68 hoặc
>>> p.match[""] >>> print[p.match[""]] None69
Siêu ký tự cuối cùng trong phần này là
>>> m = p.match['tempo'] >>> m600. Nó khớp với mọi thứ ngoại trừ một ký tự xuống dòng và có một chế độ thay thế [
>>> m = p.match['tempo'] >>> m601] trong đó nó sẽ khớp với cả một dòng mới.
>>> m = p.match['tempo'] >>> m600 thường được sử dụng khi bạn muốn khớp “bất kỳ ký tự nào”
Những điều lặp đi lặp lại¶
Khả năng khớp các bộ ký tự khác nhau là điều đầu tiên mà các biểu thức chính quy có thể thực hiện, điều chưa thể thực hiện được với các phương thức có sẵn trên chuỗi. Tuy nhiên, nếu đó là khả năng bổ sung duy nhất của biểu thức chính quy, thì chúng sẽ không có nhiều tiến bộ. Một khả năng khác là bạn có thể chỉ định rằng các phần của RE phải được lặp lại một số lần nhất định
Siêu ký tự đầu tiên để lặp lại những thứ mà chúng ta sẽ xem xét là
>>> m = p.match['tempo'] >>> m603.
>>> m = p.match['tempo'] >>> m603 không khớp với ký tự chữ
>>> m = p.match['tempo'] >>> m605;
Ví dụ:
>>> m = p.match['tempo'] >>> m606 sẽ khớp với
>>> m = p.match['tempo'] >>> m607 [0
>>> p.match[""] >>> print[p.match[""]] None62 ký tự],
>>> m = p.match['tempo'] >>> m609 [1
>>> p.match[""] >>> print[p.match[""]] None62],
>>> m = p.match['tempo'] >>> m611 [3
>>> p.match[""] >>> print[p.match[""]] None62 ký tự], v.v.
Sự lặp lại như
>>> m = p.match['tempo'] >>> m603 là tham lam; . Nếu các phần sau của mẫu không khớp, thì công cụ khớp sẽ sao lưu và thử lại với ít lần lặp lại hơn
Một ví dụ từng bước sẽ làm cho điều này rõ ràng hơn. Hãy xem xét biểu thức
>>> m = p.match['tempo'] >>> m614. Điều này phù hợp với chữ cái
>>> p.match[""] >>> print[p.match[""]] None62, không có hoặc nhiều chữ cái từ lớp
>>> m = p.match['tempo'] >>> m616 và cuối cùng kết thúc bằng
>>> m = p.match['tempo'] >>> m617. Bây giờ hãy tưởng tượng khớp RE này với chuỗi
>>> m = p.match['tempo'] >>> m618
Bươc
phù hợp
Giải trình
1
>>> m = p.match['tempo'] >>> m5
>>> m = p.match['tempo'] >>> m5 trong các trận đấu RE
2
>>> m = p.match['tempo'] >>> m621
Động cơ khớp với
>>> m = p.match['tempo'] >>> m622, đi xa nhất có thể, đến cuối chuỗi
3
Thất bại
Công cụ cố khớp với
>>> m = p.match['tempo'] >>> m6, nhưng vị trí hiện tại ở cuối chuỗi nên không thành công
4
>>> m = p.match['tempo'] >>> m624
Sao lưu để
>>> m = p.match['tempo'] >>> m622 khớp với một ký tự ít hơn
5
Thất bại
Hãy thử lại
>>> m = p.match['tempo'] >>> m6, nhưng vị trí hiện tại ở ký tự cuối cùng, đó là một
>>> m = p.match['tempo'] >>> m627
6
>>> m = p.match['tempo'] >>> m628
Sao lưu lại để
>>> m = p.match['tempo'] >>> m622 chỉ khớp với
>>> m = p.match['tempo'] >>> m630
6
>>> m = p.match['tempo'] >>> m624
Hãy thử lại
>>> m = p.match['tempo'] >>> m6. Lần này ký tự ở vị trí hiện tại là
>>> m = p.match['tempo'] >>> m617, vậy là thành công
RE hiện đã kết thúc và nó đã khớp với
>>> m = p.match['tempo'] >>> m634. Điều này cho thấy công cụ so khớp đi xa nhất có thể lúc đầu và nếu không tìm thấy kết quả phù hợp thì nó sẽ sao lưu dần dần và thử lại phần còn lại của RE nhiều lần. Nó sẽ sao lưu cho đến khi thử không khớp cho ________ 5622 và nếu sau đó không thành công, công cụ sẽ kết luận rằng chuỗi hoàn toàn không khớp với RE
Một siêu ký tự lặp lại khác là
>>> m = p.match['tempo'] >>> m636, khớp với một hoặc nhiều lần. Hãy chú ý cẩn thận đến sự khác biệt giữa
>>> m = p.match['tempo'] >>> m603 và
>>> m = p.match['tempo'] >>> m636; . Để sử dụng một ví dụ tương tự,
>>> m = p.match['tempo'] >>> m641 sẽ khớp với
>>> m = p.match['tempo'] >>> m609 [1
>>> p.match[""] >>> print[p.match[""]] None62],
>>> m = p.match['tempo'] >>> m611 [3
>>> p.match[""] >>> print[p.match[""]] None62], nhưng sẽ không khớp với
>>> m = p.match['tempo'] >>> m607
Có thêm hai toán tử hoặc bộ định lượng lặp lại. Ký tự dấu chấm hỏi,
>>> m = p.match['tempo'] >>> m647, khớp một lần hoặc không lần; . Ví dụ:
>>> m = p.match['tempo'] >>> m648 khớp với
>>> m = p.match['tempo'] >>> m649 hoặc
>>> m = p.match['tempo'] >>> m650
Bộ định lượng phức tạp nhất là
>>> m = p.match['tempo'] >>> m651, trong đó m và n là số nguyên thập phân. Định lượng này có nghĩa là phải có ít nhất m lần lặp lại và nhiều nhất n. Ví dụ:
>>> m = p.match['tempo'] >>> m652 sẽ khớp với
>>> m = p.match['tempo'] >>> m653,
>>> m = p.match['tempo'] >>> m654 và
>>> m = p.match['tempo'] >>> m655. Nó sẽ không khớp với
>>> m = p.match['tempo'] >>> m656, không có dấu gạch chéo hoặc
>>> m = p.match['tempo'] >>> m657, có bốn dấu gạch chéo
Bạn có thể bỏ qua m hoặc n; . Bỏ qua m được hiểu là giới hạn dưới của 0, trong khi bỏ qua n dẫn đến giới hạn trên là vô cùng
Độc giả của một người theo chủ nghĩa giản lược có thể nhận thấy rằng ba lượng từ khác đều có thể được biểu thị bằng cách sử dụng ký hiệu này.
>>> m = p.match['tempo'] >>> m658 tương đương với
>>> m = p.match['tempo'] >>> m603,
>>> m = p.match['tempo'] >>> m660 tương đương với
>>> m = p.match['tempo'] >>> m636 và
>>> m = p.match['tempo'] >>> m662 tương đương với
>>> m = p.match['tempo'] >>> m647. Tốt hơn là sử dụng
>>> m = p.match['tempo'] >>> m603,
>>> m = p.match['tempo'] >>> m636 hoặc
>>> m = p.match['tempo'] >>> m647 khi bạn có thể, đơn giản vì chúng ngắn hơn và dễ đọc hơn
Sử dụng Biểu thức Chính quy¶
Bây giờ chúng ta đã xem xét một số biểu thức chính quy đơn giản, làm thế nào để chúng ta thực sự sử dụng chúng trong Python?
Biên dịch biểu thức chính quy¶
Các biểu thức chính quy được biên dịch thành các đối tượng mẫu, có các phương thức cho các hoạt động khác nhau, chẳng hạn như tìm kiếm các kết quả khớp mẫu hoặc thực hiện thay thế chuỗi
>>> m = p.match['tempo'] >>> m6
>>> m = p.match['tempo'] >>> m668 cũng chấp nhận một đối số cờ tùy chọn, được sử dụng để kích hoạt nhiều tính năng đặc biệt và các biến thể cú pháp. Chúng tôi sẽ xem xét các cài đặt có sẵn sau, nhưng bây giờ, một ví dụ duy nhất sẽ làm được
>>> p.match[""] >>> print[p.match[""]] None26
RE được chuyển đến
>>> m = p.match['tempo'] >>> m668 dưới dạng một chuỗi. RE được xử lý dưới dạng chuỗi vì biểu thức chính quy không phải là một phần của ngôn ngữ Python cốt lõi và không có cú pháp đặc biệt nào được tạo để diễn đạt chúng. [Có những ứng dụng hoàn toàn không cần RE, vì vậy không cần phải làm phồng đặc tả ngôn ngữ bằng cách đưa chúng vào. ] Thay vào đó, mô-đun
>>> p.match[""] >>> print[p.match[""]] None5 chỉ đơn giản là mô-đun mở rộng C có trong Python, giống như mô-đun
>>> m = p.match['tempo'] >>> m671 hoặc
>>> m = p.match['tempo'] >>> m672
Đặt RE trong chuỗi giữ cho ngôn ngữ Python đơn giản hơn, nhưng có một nhược điểm là chủ đề của phần tiếp theo
Bệnh dịch hạch ngược¶
Như đã nêu trước đó, các biểu thức chính quy sử dụng ký tự gạch chéo ngược [
>>> p.match[""] >>> print[p.match[""]] None68] để 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 mâu thuẫn 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ự
Giả sử bạn muốn viết RE khớp với chuỗi
>>> m = p.match['tempo'] >>> m674, chuỗi này có thể tìm thấy trong tệp LaTeX. Để tìm ra những gì cần viết trong mã chương trình, hãy bắt đầu với chuỗi mong muốn được khớp. Tiếp theo, bạn phải thoát khỏi bất kỳ dấu gạch chéo ngược và ký tự meta nào khác bằng cách đặt trước chúng bằng dấu gạch chéo ngược, dẫn đến chuỗi
>>> m = p.match['tempo'] >>> m675. Chuỗi kết quả phải được chuyển đến
>>> m = p.match['tempo'] >>> m668 phải là
>>> m = p.match['tempo'] >>> m675. Tuy nhiên, để thể hiện điều này dưới dạng chuỗi ký tự Python, cả hai dấu gạch chéo ngược phải được thoát lại
Nhân vật
Sân khấu
>>> m = p.match['tempo'] >>> m674
Chuỗi văn bản cần khớp
>>> m = p.match['tempo'] >>> m675
Dấu gạch chéo ngược thoát cho
>>> m = p.match['tempo'] >>> m668
>>> m = p.match['tempo'] >>> m681
Dấu gạch chéo ngược đã thoát cho một chuỗi ký tự
Nói tóm lại, để khớp với dấu gạch chéo ngược theo nghĩa đen, người ta phải viết
>>> m = p.match['tempo'] >>> m682 dưới dạng chuỗi RE, vì biểu thức chính quy phải là
>>> p.match[""] >>> print[p.match[""]] None67 và mỗi dấu gạch chéo ngược phải được biểu thị là
>>> p.match[""] >>> print[p.match[""]] None67 bên trong một chuỗi ký tự Python thông thường. Trong các RE có dấu gạch chéo ngược lặp đi lặp lại, điều này dẫn đến nhiều dấu gạch chéo ngược lặp lại và làm cho các chuỗi kết quả trở nên khó hiểu
Giải pháp là sử dụng ký hiệu chuỗi thô của Python cho các biểu thức chính quy; . Biểu thức chính quy thường sẽ được viết bằng mã Python sử dụng ký hiệu chuỗi thô này
Ngoài ra, các chuỗi thoát đặc biệt hợp lệ trong các biểu thức chính quy, nhưng không hợp lệ dưới dạng chuỗi ký tự Python, hiện dẫn đến ____5690 và cuối cùng sẽ trở thành ____5691, có nghĩa là các chuỗi sẽ không hợp lệ nếu ký hiệu chuỗi thô hoặc thoát khỏi dấu gạch chéo ngược '
Chuỗi thông thường
chuỗi thô
>>> m = p.match['tempo'] >>> m692
>>> m = p.match['tempo'] >>> m693
>>> m = p.match['tempo'] >>> m681
>>> m = p.match['tempo'] >>> m695
>>> m = p.match['tempo'] >>> m696
>>> m = p.match['tempo'] >>> m697
Thi đấu¶
Khi bạn có một đối tượng đại diện cho một biểu thức chính quy được biên dịch, bạn sẽ làm gì với nó? . Chỉ những điều quan trọng nhất sẽ được đề cập ở đây;
Phương thức/Thuộc tính
Mục đích
>>> m = p.match['tempo'] >>> m699
Xác định xem RE có khớp ở đầu chuỗi không
>>> p.match[""] >>> print[p.match[""]] None2600
Quét qua một chuỗi, tìm kiếm bất kỳ vị trí nào mà RE này khớp
>>> p.match[""] >>> print[p.match[""]] None2601
Tìm tất cả các chuỗi con nơi RE khớp và trả về chúng dưới dạng danh sách
>>> p.match[""] >>> print[p.match[""]] None2602
Tìm tất cả các chuỗi con mà RE khớp và trả về chúng dưới dạng trình lặp .
______5699 và
>>> p.match[""] >>> print[p.match[""]] None2600 trả về
>>> p.match[""] >>> print[p.match[""]] None2605 nếu không tìm thấy kết quả khớp. Nếu chúng thành công, một phiên bản đối tượng khớp được trả về, chứa thông tin về sự trùng khớp. nơi nó bắt đầu và kết thúc, chuỗi con mà nó khớp, v.v.
Bạn có thể tìm hiểu về điều này bằng cách thử nghiệm tương tác với mô-đun
>>> p.match[""] >>> print[p.match[""]] None5. Nếu bạn có sẵn
>>> p.match[""] >>> print[p.match[""]] None2607, bạn cũng có thể muốn xem Tools/demo/redemo. py, một chương trình trình diễn đi kèm với bản phân phối Python. Nó cho phép bạn nhập RE và chuỗi, đồng thời hiển thị RE khớp hay không.
>>> p.match[""] >>> print[p.match[""]] None2608 có thể khá hữu ích khi cố gắng gỡ lỗi RE phức tạp
HOWTO này sử dụng trình thông dịch Python chuẩn cho các ví dụ của nó. Đầu tiên, hãy chạy trình thông dịch Python, nhập mô-đun
>>> p.match[""] >>> print[p.match[""]] None5 và biên dịch RE
>>> p.match[""] >>> print[p.match[""]] None68
Bây giờ, bạn có thể thử khớp các chuỗi khác nhau với RE
>>> p.match[""] >>> print[p.match[""]] None2610. Một chuỗi rỗng hoàn toàn không được khớp, vì
>>> m = p.match['tempo'] >>> m636 có nghĩa là 'một hoặc nhiều lần lặp lại'.
>>> m = p.match['tempo'] >>> m699 sẽ trả về
>>> p.match[""] >>> print[p.match[""]] None2605 trong trường hợp này, điều này sẽ khiến trình thông dịch không in ra. Bạn có thể in rõ ràng kết quả của
>>> m = p.match['tempo'] >>> m699 để làm rõ điều này
>>> p.match[""] >>> print[p.match[""]] None
Bây giờ, hãy thử với một chuỗi phù hợp, chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None2615. Trong trường hợp này,
>>> m = p.match['tempo'] >>> m699 sẽ trả về một đối tượng khớp , vì vậy bạn nên lưu kết quả vào một biến để sử dụng sau này.
>>> m = p.match['tempo'] >>> m
Bây giờ bạn có thể truy vấn đối tượng khớp để biết thông tin về chuỗi khớp. Các thể hiện đối tượng khớp cũng có một số phương thức và thuộc tính; .
Phương thức/Thuộc tính
Mục đích
>>> p.match[""] >>> print[p.match[""]] None2617
Trả về chuỗi khớp với RE
>>> p.match[""] >>> print[p.match[""]] None2618
Trả lại vị trí bắt đầu của trận đấu
>>> p.match[""] >>> print[p.match[""]] None2619
Trả lại vị trí kết thúc trận đấu
>>> p.match[""] >>> print[p.match[""]] None2620
Trả về một bộ chứa các vị trí [bắt đầu, kết thúc] của trận đấu
Thử các phương pháp này sẽ sớm làm rõ ý nghĩa của chúng
>>> p.match[""] >>> print[p.match[""]] None6
>>> p.match[""] >>> print[p.match[""]] None2617 trả về chuỗi con khớp với RE.
>>> p.match[""] >>> print[p.match[""]] None2618 và
>>> p.match[""] >>> print[p.match[""]] None2619 trả về chỉ số bắt đầu và kết thúc của trận đấu.
>>> p.match[""] >>> print[p.match[""]] None2620 trả về cả chỉ mục bắt đầu và kết thúc trong một bộ dữ liệu. Vì phương thức ________ 5699 chỉ kiểm tra xem RE có khớp ở đầu chuỗi hay không, nên ________ 12618 sẽ luôn bằng 0. Tuy nhiên, phương thức của các mẫu
>>> p.match[""] >>> print[p.match[""]] None2600 quét qua chuỗi, do đó, trận đấu có thể không bắt đầu từ 0 trong trường hợp đó
>>> p.match[""] >>> print[p.match[""]] None6
Trong các chương trình thực tế, phong cách phổ biến nhất là lưu trữ đối tượng khớp trong một biến, sau đó kiểm tra xem đó có phải là
>>> p.match[""] >>> print[p.match[""]] None2605 không. Điều này thường trông giống như.
>>> p.match[""] >>> print[p.match[""]] None6
Hai phương thức mẫu trả về tất cả các kết quả phù hợp cho một mẫu.
>>> p.match[""] >>> print[p.match[""]] None2601 trả về danh sách các chuỗi phù hợp
>>> p.match[""] >>> print[p.match[""]] None6
Tiền tố
>>> p.match[""] >>> print[p.match[""]] None2630, làm cho ký tự này trở thành ký tự chuỗi thô, là cần thiết trong ví dụ này vì các chuỗi thoát trong một ký tự chuỗi ký tự "nấu chín" bình thường không được Python nhận ra, trái ngược với các biểu thức thông thường, giờ dẫn đến một . Xem Bệnh dịch hạch ngược .
>>> p.match[""] >>> print[p.match[""]] None2601 phải tạo toàn bộ danh sách trước khi có thể trả về kết quả. Phương thức
>>> p.match[""] >>> print[p.match[""]] None2602 trả về một chuỗi các phiên bản match object dưới dạng iterator .
>>> m = p.match['tempo'] >>> m60
Chức năng cấp mô-đun¶
Bạn không cần phải tạo một đối tượng mẫu và gọi các phương thức của nó; . Các hàm này nhận các đối số giống như phương thức mẫu tương ứng với chuỗi RE được thêm làm đối số đầu tiên và vẫn trả về phiên bản
>>> p.match[""] >>> print[p.match[""]] None2605 hoặc match object .
>>> m = p.match['tempo'] >>> m61
Về cơ bản, các chức năng này chỉ đơn giản là tạo một đối tượng mẫu cho bạn và gọi phương thức thích hợp trên đó. Chúng cũng lưu trữ đối tượng đã biên dịch trong bộ đệm, vì vậy các cuộc gọi trong tương lai sử dụng cùng một RE sẽ không cần phải phân tích cú pháp mẫu nhiều lần
Bạn có nên sử dụng các hàm cấp mô-đun này hay bạn nên lấy mẫu và tự gọi các phương thức của nó? . Bên ngoài các vòng lặp, không có nhiều khác biệt nhờ bộ đệm bên trong
Cờ tổng hợp¶
Cờ biên dịch cho phép bạn sửa đổi một số khía cạnh về cách hoạt động của biểu thức chính quy. Các cờ có sẵn trong mô-đun
>>> p.match[""] >>> print[p.match[""]] None5 dưới hai tên, một tên dài chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None2642 và một dạng ngắn, một chữ cái chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None2643. [Nếu bạn đã quen thuộc với các công cụ sửa đổi mẫu của Perl, thì các dạng một chữ cái sẽ sử dụng các chữ cái giống nhau; dạng viết tắt của
>>> p.match[""] >>> print[p.match[""]] None2644 là
>>> p.match[""] >>> print[p.match[""]] None2645 chẳng hạn. ] Nhiều cờ có thể được chỉ định bằng bit OR-ing chúng;
Đây là bảng các cờ có sẵn, theo sau là giải thích chi tiết hơn về từng cờ
Lá cờ
Nghĩa
>>> p.match[""] >>> print[p.match[""]] None2649,
>>> p.match[""] >>> print[p.match[""]] None2650
Làm cho một số lần thoát như
>>> p.match[""] >>> print[p.match[""]] None69,
>>> p.match[""] >>> print[p.match[""]] None2652,
>>> p.match[""] >>> print[p.match[""]] None69 và
>>> p.match[""] >>> print[p.match[""]] None65 chỉ khớp với các ký tự ASCII với thuộc tính tương ứng
>>> p.match[""] >>> print[p.match[""]] None2655,
>>> p.match[""] >>> print[p.match[""]] None2656
Làm cho
>>> m = p.match['tempo'] >>> m600 khớp với bất kỳ ký tự nào, bao gồm cả dòng mới
>>> p.match[""] >>> print[p.match[""]] None2642,
>>> p.match[""] >>> print[p.match[""]] None2643
Thực hiện so khớp không phân biệt chữ hoa chữ thường
>>> p.match[""] >>> print[p.match[""]] None2660,
>>> p.match[""] >>> print[p.match[""]] None2661
Thực hiện đối sánh nhận biết ngôn ngữ
>>> p.match[""] >>> print[p.match[""]] None2662,
>>> p.match[""] >>> print[p.match[""]] None2648
Kết hợp nhiều dòng, ảnh hưởng đến
>>> p.match[""] >>> print[p.match[""]] None2664 và
>>> p.match[""] >>> print[p.match[""]] None2665
>>> p.match[""] >>> print[p.match[""]] None2666,
>>> p.match[""] >>> print[p.match[""]] None2667 [đối với 'mở rộng']
Kích hoạt RE dài dòng, có thể được tổ chức rõ ràng và dễ hiểu hơn
TôiBỎ QUA TRƯỜNG HỢPThực hiện khớp không phân biệt chữ hoa chữ thường; . Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None2668 cũng sẽ khớp với các chữ cái viết thường. Kết hợp Unicode đầy đủ cũng hoạt động trừ khi cờ
>>> p.match[""] >>> print[p.match[""]] None2649 được sử dụng để tắt kết quả khớp không phải ASCII. Khi các mẫu Unicode
>>> m = p.match['tempo'] >>> m9 hoặc
>>> p.match[""] >>> print[p.match[""]] None2668 được sử dụng kết hợp với cờ
>>> p.match[""] >>> print[p.match[""]] None2642, 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 in hoa Latinh 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' .
>>> p.match[""] >>> print[p.match[""]] None2673 sẽ khớp với
>>> p.match[""] >>> print[p.match[""]] None2674,
>>> p.match[""] >>> print[p.match[""]] None2675,
>>> p.match[""] >>> print[p.match[""]] None2676 hoặc
>>> p.match[""] >>> print[p.match[""]] None2677 [cái sau chỉ khớp ở chế độ Unicode]. Chữ thường này không tính đến ngôn ngữ hiện tại; LĐỊA ĐIỂM
Làm cho đối sánh
>>> p.match[""] >>> print[p.match[""]] None69,
>>> p.match[""] >>> print[p.match[""]] None65,
>>> p.match[""] >>> print[p.match[""]] None2652,
>>> p.match[""] >>> print[p.match[""]] None2682 và phân biệt chữ hoa chữ thường phụ thuộc vào ngôn ngữ hiện tại thay vì cơ sở dữ liệu Unicode
Ngôn ngữ là một tính năng của thư viện C nhằm giúp viết các chương trình có tính đến sự khác biệt về ngôn ngữ. Ví dụ: nếu bạn đang xử lý văn bản tiếng Pháp được mã hóa, bạn muốn có thể viết
>>> p.match[""] >>> print[p.match[""]] None2683 để khớp các từ, nhưng
>>> p.match[""] >>> print[p.match[""]] None69 chỉ khớp với lớp ký tự
>>> p.match[""] >>> print[p.match[""]] None2685 theo mẫu byte; . Nếu hệ thống của bạn được cấu hình đúng cách và ngôn ngữ tiếng Pháp được chọn, một số hàm C nhất định sẽ cho chương trình biết rằng byte tương ứng với
>>> p.match[""] >>> print[p.match[""]] None2686 cũng phải được coi là một chữ cái. Đặt cờ
>>> p.match[""] >>> print[p.match[""]] None2660 khi biên dịch biểu thức chính quy sẽ khiến đối tượng được biên dịch kết quả sử dụng các hàm C này cho
>>> p.match[""] >>> print[p.match[""]] None69; . Việc sử dụng cờ này không được khuyến khích trong Python 3 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 nhauMĐA DÒNG
[
>>> p.match[""] >>> print[p.match[""]] None2664 và
>>> p.match[""] >>> print[p.match[""]] None2665 vẫn chưa được giải thích; chúng sẽ được giới thiệu trong phần Các siêu ký tự khác . ]
Thông thường,
>>> p.match[""] >>> print[p.match[""]] None2664 chỉ khớp ở đầu chuỗi và
>>> p.match[""] >>> print[p.match[""]] None2665 chỉ khớp ở cuối chuỗi và ngay trước dòng mới [nếu có] ở cuối chuỗi. Khi cờ này được chỉ định,
>>> p.match[""] >>> print[p.match[""]] None2664 khớp ở đầu chuỗi và ở đầu mỗi dòng trong chuỗi, ngay sau mỗi dòng mới. Tương tự, siêu ký tự
>>> p.match[""] >>> print[p.match[""]] None2665 khớp ở cuối chuỗi và ở cuối mỗi dòng [ngay trước mỗi dòng mới]SDOTALL
Làm cho ký tự đặc biệt
>>> p.match[""] >>> print[p.match[""]] None69 khớp với bất kỳ ký tự nào, kể cả một dòng mới; AASCII
Làm cho
>>> p.match[""] >>> print[p.match[""]] None69,
>>> p.match[""] >>> print[p.match[""]] None65,
>>> p.match[""] >>> print[p.match[""]] None2652,
>>> p.match[""] >>> print[p.match[""]] None2682,
>>> p.match[""] >>> print[p.match[""]] None69 và
>>> p.match[""] >>> print[p.match[""]] None61 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 byteXVERBOSE
Cờ này cho phép bạn viết các biểu thức chính quy dễ đọc hơn bằng cách cho phép bạn linh hoạt hơn trong cách định dạng chúng. Khi cờ này đã được chỉ định, khoảng trắng trong chuỗi RE sẽ bị bỏ qua, trừ khi khoảng trắng nằm trong một lớp ký tự hoặc trước dấu gạch chéo ngược không thoát; . Cờ này cũng cho phép bạn đặt nhận xét trong RE sẽ bị công cụ bỏ qua;
Ví dụ: đây là RE sử dụng
>>> p.match[""] >>> print[p.match[""]] None2644;
>>> m = p.match['tempo'] >>> m62
Nếu không có cài đặt dài dòng, RE sẽ trông như thế này
>>> m = p.match['tempo'] >>> m63
Trong ví dụ trên, phép nối chuỗi ký tự tự động của Python đã được sử dụng để chia RE thành các phần nhỏ hơn, nhưng nó vẫn khó hiểu hơn phiên bản sử dụng
>>> p.match[""] >>> print[p.match[""]] None2644
Công suất mẫu nhiều hơn¶
Cho đến nay, chúng tôi chỉ đề cập đến một phần các tính năng của biểu thức chính quy. Trong phần này, chúng ta sẽ đề cập đến một số siêu ký tự mới và cách sử dụng các nhóm để truy xuất các phần của văn bản đã khớp
Nhiều ký tự hơn¶
Có một số siêu ký tự mà chúng tôi chưa đề cập đến. Hầu hết trong số họ sẽ được đề cập trong phần này
Một số siêu ký tự còn lại sẽ được thảo luận là các xác nhận có độ rộng bằng 0. Chúng không làm cho động cơ chạy xuyên qua sợi dây; . Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None2652 là một khẳng định rằng vị trí hiện tại nằm ở một ranh giới từ; . Điều này có nghĩa là các xác nhận có độ rộng bằng 0 không bao giờ được lặp lại, bởi vì nếu chúng khớp một lần tại một vị trí nhất định, thì rõ ràng chúng có thể được khớp vô số lần
>>> p.match[""] >>> print[p.match[""]] None6811
Luân phiên, hoặc toán tử “hoặc”. Nếu A và B là biểu thức chính quy,
>>> p.match[""] >>> print[p.match[""]] None6812 sẽ khớp với bất kỳ chuỗi nào khớp với A hoặc B.
>>> p.match[""] >>> print[p.match[""]] None6811 có mức độ ưu tiên rất thấp để làm cho nó hoạt động hợp lý khi bạn đang xen kẽ các chuỗi nhiều ký tự.
>>> p.match[""] >>> print[p.match[""]] None6814 sẽ khớp với
>>> p.match[""] >>> print[p.match[""]] None6815 hoặc
>>> p.match[""] >>> print[p.match[""]] None6816, không phải
>>> p.match[""] >>> print[p.match[""]] None6817, một
>>> p.match[""] >>> print[p.match[""]] None6818 hoặc một
>>> p.match[""] >>> print[p.match[""]] None6819, và một
>>> p.match[""] >>> print[p.match[""]] None6820
Để khớp với một chữ
>>> p.match[""] >>> print[p.match[""]] None6821, hãy sử dụng
>>> p.match[""] >>> print[p.match[""]] None6822 hoặc đặt nó bên trong một lớp ký tự, như trong
>>> p.match[""] >>> print[p.match[""]] None6823
>>> p.match[""] >>> print[p.match[""]] None2664
Khớp ở đầu dòng. Trừ khi cờ
>>> p.match[""] >>> print[p.match[""]] None2662 đã được đặt, cờ này sẽ chỉ khớp ở đầu chuỗi. Ở chế độ
>>> p.match[""] >>> print[p.match[""]] None2662, điều này cũng khớp ngay sau mỗi dòng mới trong chuỗi
Ví dụ: nếu bạn chỉ muốn khớp từ
>>> p.match[""] >>> print[p.match[""]] None6827 ở đầu dòng, RE sẽ sử dụng là
>>> p.match[""] >>> print[p.match[""]] None6828
>>> m = p.match['tempo'] >>> m64
Để khớp với một
>>> p.match[""] >>> print[p.match[""]] None67 theo nghĩa đen, hãy sử dụng
>>> p.match[""] >>> print[p.match[""]] None6830
>>> p.match[""] >>> print[p.match[""]] None2665
Khớp ở cuối dòng, được xác định là cuối chuỗi hoặc bất kỳ vị trí nào theo sau bởi ký tự xuống dòng
>>> m = p.match['tempo'] >>> m65
Để khớp với một chữ
>>> p.match[""] >>> print[p.match[""]] None65, hãy sử dụng
>>> p.match[""] >>> print[p.match[""]] None6833 hoặc đặt nó bên trong một lớp ký tự, như trong
>>> p.match[""] >>> print[p.match[""]] None6834
>>> p.match[""] >>> print[p.match[""]] None6835
Chỉ khớp ở đầu chuỗi. Khi không ở chế độ
>>> p.match[""] >>> print[p.match[""]] None2662,
>>> p.match[""] >>> print[p.match[""]] None6835 và
>>> p.match[""] >>> print[p.match[""]] None2664 thực sự giống nhau. Ở chế độ
>>> p.match[""] >>> print[p.match[""]] None2662, chúng khác nhau.
>>> p.match[""] >>> print[p.match[""]] None6835 vẫn chỉ khớp ở đầu chuỗi, nhưng
>>> p.match[""] >>> print[p.match[""]] None2664 có thể khớp ở bất kỳ vị trí nào bên trong chuỗi theo sau ký tự xuống dòng
>>> p.match[""] >>> print[p.match[""]] None6842
Chỉ khớp ở cuối chuỗi
>>> p.match[""] >>> print[p.match[""]] None2652
Ranh giới từ. Đây là xác nhận có độ rộng bằng 0 chỉ khớp ở đầu hoặc cuối từ. Một từ được định nghĩa là một chuỗi các ký tự chữ và số, do đó, phần cuối của từ được biểu thị bằng khoảng trắng hoặc ký tự không phải chữ và số
Ví dụ sau chỉ khớp với
>>> p.match[""] >>> print[p.match[""]] None6844 khi đó là một từ hoàn chỉnh;
>>> m = p.match['tempo'] >>> m66
Có hai điều tinh tế bạn nên nhớ khi sử dụng trình tự đặc biệt này. Đầu tiên, đây là sự va chạm tồi tệ nhất giữa các chuỗi ký tự chuỗi của Python và các chuỗi biểu thức chính quy. Trong chuỗi ký tự Python, ________ 12652 là ký tự xóa lùi, giá trị ASCII 8. Nếu bạn không sử dụng chuỗi thô, thì Python sẽ chuyển đổi
>>> p.match[""] >>> print[p.match[""]] None2652 thành backspace và RE của bạn sẽ không khớp như bạn mong đợi. Ví dụ sau trông giống như RE trước của chúng tôi, nhưng bỏ qua
>>> m = p.match['tempo'] >>> m685 trước chuỗi RE
>>> m = p.match['tempo'] >>> m67
Thứ hai, bên trong một lớp ký tự, nơi không sử dụng khẳng định này,
>>> p.match[""] >>> print[p.match[""]] None2652 đại diện cho ký tự xóa lùi, để tương thích với chuỗi ký tự của Python
>>> p.match[""] >>> print[p.match[""]] None2682
Một xác nhận khác có độ rộng bằng 0, điều này ngược lại với
>>> p.match[""] >>> print[p.match[""]] None2652, chỉ khớp khi vị trí hiện tại không nằm ở ranh giới từ
Nhóm¶
Thông thường, bạn cần thu thập nhiều thông tin hơn là liệu RE có khớp hay không. Các biểu thức chính quy thường được sử dụng để phân tích các chuỗi bằng cách viết RE được chia thành nhiều nhóm con phù hợp với các thành phần quan tâm khác nhau. Ví dụ: dòng tiêu đề RFC-822 được chia thành tên tiêu đề và giá trị, được phân tách bằng dấu ____16851, như thế này
>>> m = p.match['tempo'] >>> m68
Điều này có thể được xử lý bằng cách viết một biểu thức chính quy khớp với toàn bộ dòng tiêu đề và có một nhóm khớp với tên tiêu đề và một nhóm khác khớp với giá trị của tiêu đề
Các nhóm được đánh dấu bằng ký tự phụ
>>> p.match[""] >>> print[p.match[""]] None6852,
>>> p.match[""] >>> print[p.match[""]] None6853.
>>> p.match[""] >>> print[p.match[""]] None6852 và
>>> p.match[""] >>> print[p.match[""]] None6853 có nhiều ý nghĩa giống như trong các biểu thức toán học; . Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None6860 sẽ khớp với 0 hoặc nhiều lần lặp lại của
>>> p.match[""] >>> print[p.match[""]] None6861
>>> m = p.match['tempo'] >>> m69
Các nhóm được biểu thị bằng >>> p.match[""]
>>> print[p.match[""]]
None
6852, >>> p.match[""]
>>> print[p.match[""]]
None
6853 cũng nắm bắt chỉ mục bắt đầu và kết thúc của văn bản mà chúng khớp; . Các nhóm được đánh số bắt đầu bằng 0. Nhóm 0 luôn có mặt; . Sau này chúng ta sẽ xem cách thể hiện các nhóm không nắm bắt được khoảng văn bản mà chúng khớp. match object methods all have group 0 as their default argument. Later we’ll see how to express groups that don’t capture the span of text that they match.
>>> p.match[""] >>> print[p.match[""]] None260
Các nhóm con được đánh số từ trái sang phải, từ 1 trở lên. Các nhóm có thể được lồng vào nhau;
>>> p.match[""] >>> print[p.match[""]] None261
>>> p.match[""] >>> print[p.match[""]] None2617 có thể được chuyển nhiều số nhóm cùng một lúc, trong trường hợp đó, nó sẽ trả về một bộ chứa các giá trị tương ứng cho các nhóm đó
>>> p.match[""] >>> print[p.match[""]] None262
Phương thức
>>> p.match[""] >>> print[p.match[""]] None6869 trả về một bộ chứa các chuỗi cho tất cả các nhóm con, từ 1 cho đến bao nhiêu nhóm
>>> p.match[""] >>> print[p.match[""]] None263
Phản hồi ngược trong một mẫu cho phép bạn chỉ định rằng nội dung của nhóm chụp trước đó cũng phải được tìm thấy tại vị trí hiện tại trong chuỗi. Ví dụ:
>>> p.match[""] >>> print[p.match[""]] None6870 sẽ thành công nếu có thể tìm thấy nội dung chính xác của nhóm 1 tại vị trí hiện tại và không thành công nếu không. Hãy nhớ rằng các chuỗi ký tự của Python cũng sử dụng dấu gạch chéo ngược theo sau là các số để cho phép bao gồm các ký tự tùy ý trong một chuỗi, vì vậy hãy đảm bảo sử dụng chuỗi thô khi kết hợp các tham chiếu ngược trong RE
Ví dụ: RE sau phát hiện các từ được nhân đôi trong một chuỗi
>>> p.match[""] >>> print[p.match[""]] None264
Các tham chiếu ngược như thế này thường không hữu ích khi chỉ tìm kiếm qua một chuỗi — có một số định dạng văn bản lặp lại dữ liệu theo cách này — nhưng bạn sẽ sớm phát hiện ra rằng chúng rất hữu ích khi thực hiện thay thế chuỗi
Nhóm không bắt giữ và được đặt tên¶
Các RE phức tạp có thể sử dụng nhiều nhóm, vừa để nắm bắt các chuỗi con quan tâm, vừa để nhóm và cấu trúc chính RE. Trong các RE phức tạp, việc theo dõi số nhóm trở nên khó khăn. Có hai tính năng giúp giải quyết vấn đề này. Cả hai đều sử dụng một cú pháp chung cho các phần mở rộng biểu thức chính quy, vì vậy chúng tôi sẽ xem xét điều đó trước
Perl 5 nổi tiếng với những bổ sung mạnh mẽ cho các biểu thức chính quy tiêu chuẩn. Đối với các tính năng mới này, các nhà phát triển Perl không thể chọn các siêu ký tự một lần nhấn phím mới hoặc các chuỗi đặc biệt mới bắt đầu bằng
>>> p.match[""] >>> print[p.match[""]] None60 mà không làm cho các biểu thức chính quy của Perl khác biệt một cách khó hiểu so với các RE tiêu chuẩn. Ví dụ, nếu họ chọn
>>> p.match[""] >>> print[p.match[""]] None6872 làm một siêu ký tự mới, thì các biểu thức cũ sẽ cho rằng
>>> p.match[""] >>> print[p.match[""]] None6872 là một ký tự thông thường và sẽ không thoát khỏi ký tự đó bằng cách viết
>>> p.match[""] >>> print[p.match[""]] None6874 hoặc
>>> p.match[""] >>> print[p.match[""]] None6875
Giải pháp được các nhà phát triển Perl chọn là sử dụng
>>> p.match[""] >>> print[p.match[""]] None6876 làm cú pháp mở rộng.
>>> m = p.match['tempo'] >>> m647 ngay sau dấu ngoặc đơn là một lỗi cú pháp vì
>>> m = p.match['tempo'] >>> m647 sẽ không có gì để lặp lại, vì vậy điều này không gây ra bất kỳ vấn đề tương thích nào. Các ký tự ngay sau
>>> m = p.match['tempo'] >>> m647 cho biết tiện ích mở rộng nào đang được sử dụng, do đó,
>>> p.match[""] >>> print[p.match[""]] None6880 là một thứ [một xác nhận nhìn trước tích cực] và
>>> p.match[""] >>> print[p.match[""]] None6881 là một thứ khác [một nhóm không nắm bắt có chứa biểu thức con
>>> p.match[""] >>> print[p.match[""]] None6882]
Python hỗ trợ một số tiện ích mở rộng của Perl và thêm cú pháp mở rộng vào cú pháp mở rộng của Perl. Nếu ký tự đầu tiên sau dấu chấm hỏi là
>>> p.match[""] >>> print[p.match[""]] None6883, bạn biết rằng đó là một tiện ích mở rộng dành riêng cho Python
Bây giờ chúng ta đã xem xét cú pháp tiện ích mở rộng chung, chúng ta có thể quay lại các tính năng giúp đơn giản hóa việc làm việc với các nhóm trong các RE phức tạp
Đôi khi, bạn sẽ muốn sử dụng một nhóm để biểu thị một phần của biểu thức chính quy, nhưng không quan tâm đến việc truy xuất nội dung của nhóm. Bạn có thể làm cho thực tế này trở nên rõ ràng bằng cách sử dụng một nhóm không bắt giữ.
>>> p.match[""] >>> print[p.match[""]] None6884, nơi bạn có thể thay thế
>>> p.match[""] >>> print[p.match[""]] None6885 bằng bất kỳ biểu thức chính quy nào khác
>>> p.match[""] >>> print[p.match[""]] None265
Ngoại trừ thực tế là bạn không thể truy xuất nội dung của những gì nhóm đã khớp, một nhóm không bắt giữ hoạt động giống hệt như một nhóm bắt giữ; .
>>> p.match[""] >>> print[p.match[""]] None6884 đặc biệt hữu ích khi sửa đổi một mẫu hiện có, vì bạn có thể thêm các nhóm mới mà không thay đổi cách đánh số tất cả các nhóm khác. Cần lưu ý rằng không có sự khác biệt về hiệu suất trong việc tìm kiếm giữa các nhóm chụp và không chụp;
Một tính năng quan trọng hơn được đặt tên nhóm. thay vì gọi chúng bằng số, các nhóm có thể được gọi bằng tên
Cú pháp cho nhóm được đặt tên là một trong những phần mở rộng dành riêng cho Python.
>>> p.match[""] >>> print[p.match[""]] None6888. rõ ràng là tên của nhóm. Các nhóm được đặt tên hoạt động giống như các nhóm bắt giữ và ngoài ra còn liên kết tên với một nhóm. Tất cả các phương thức match object xử lý việc bắt nhóm đều chấp nhận số nguyên tham chiếu đến nhóm theo số hoặc chuỗi chứa tên của nhóm mong muốn. Các nhóm được đặt tên vẫn được cung cấp số, vì vậy bạn có thể truy xuất thông tin về một nhóm theo hai cách.
>>> p.match[""] >>> print[p.match[""]] None266
Ngoài ra, bạn có thể truy xuất các nhóm được đặt tên dưới dạng từ điển với
>>> p.match[""] >>> print[p.match[""]] None6889
>>> p.match[""] >>> print[p.match[""]] None267
Các nhóm được đặt tên rất tiện dụng vì chúng cho phép bạn sử dụng các tên dễ nhớ thay vì phải nhớ các con số. Đây là một ví dụ RE từ mô-đun
>>> p.match[""] >>> print[p.match[""]] None6890
>>> p.match[""] >>> print[p.match[""]] None268
Việc truy xuất
>>> p.match[""] >>> print[p.match[""]] None6891 rõ ràng là dễ dàng hơn nhiều, thay vì phải nhớ truy xuất nhóm 9
Cú pháp cho phản hồi trong một biểu thức chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None6892 đề cập đến số của nhóm. Đương nhiên có một biến thể sử dụng tên nhóm thay vì số. Đây là một phần mở rộng khác của Python.
>>> p.match[""] >>> print[p.match[""]] None6893 chỉ ra rằng nội dung của nhóm được gọi là tên sẽ được khớp lại tại điểm hiện tại. Biểu thức chính quy để tìm các từ được nhân đôi,
>>> p.match[""] >>> print[p.match[""]] None6894 cũng có thể được viết là
>>> p.match[""] >>> print[p.match[""]] None6895
>>> p.match[""] >>> print[p.match[""]] None269
Xác nhận nhìn trước¶
Một xác nhận độ rộng bằng 0 khác là xác nhận nhìn trước. Các xác nhận nhìn về phía trước có sẵn ở cả dạng tích cực và tiêu cực và trông như thế này
>>> p.match[""] >>> print[p.match[""]] None6896
Khẳng định cái nhìn tích cực. Điều này thành công nếu biểu thức chính quy được chứa, được đại diện ở đây bởi
>>> p.match[""] >>> print[p.match[""]] None6885, khớp thành công tại vị trí hiện tại và không thành công nếu không. Tuy nhiên, một khi biểu thức chứa trong đó đã được thử, công cụ so khớp hoàn toàn không tiến lên;
>>> p.match[""] >>> print[p.match[""]] None6898
Khẳng định nhìn trước tiêu cực. Điều này trái ngược với khẳng định tích cực;
Để làm cho điều này trở nên cụ thể, hãy xem xét một trường hợp mà một cái nhìn về phía trước là hữu ích. Hãy xem xét một mẫu đơn giản để khớp với tên tệp và tách nó thành tên cơ sở và phần mở rộng, được phân tách bằng dấu ____5600. Ví dụ: trong
>>> p.match[""] >>> print[p.match[""]] None00,
>>> p.match[""] >>> print[p.match[""]] None01 là tên cơ sở và
>>> p.match[""] >>> print[p.match[""]] None02 là phần mở rộng của tên tệp
Mẫu để phù hợp với điều này là khá đơn giản
>>> p.match[""] >>> print[p.match[""]] None03
Lưu ý rằng
>>> m = p.match['tempo'] >>> m600 cần được xử lý đặc biệt vì nó là một siêu ký tự, do đó, nó nằm trong một lớp ký tự để chỉ khớp với ký tự cụ thể đó. Ngoài ra, hãy chú ý đến dấu ____12665; . Biểu thức chính quy này khớp với
>>> p.match[""] >>> print[p.match[""]] None06 và
>>> p.match[""] >>> print[p.match[""]] None07 và
>>> p.match[""] >>> print[p.match[""]] None08 và
>>> p.match[""] >>> print[p.match[""]] None09
Bây giờ, hãy xem xét làm phức tạp vấn đề một chút;
>>> p.match[""] >>> print[p.match[""]] None11 Lần thử đầu tiên ở trên cố gắng loại trừ
>>> p.match[""] >>> print[p.match[""]] None10 bằng cách yêu cầu ký tự đầu tiên của phần mở rộng không phải là
>>> m = p.match['tempo'] >>> m6. Điều này sai, vì mẫu cũng không khớp với
>>> p.match[""] >>> print[p.match[""]] None06
>>> p.match[""] >>> print[p.match[""]] None15
Biểu thức trở nên lộn xộn hơn khi bạn cố gắng khắc phục giải pháp đầu tiên bằng cách yêu cầu một trong các trường hợp sau khớp với nhau. ký tự đầu tiên của phần mở rộng không phải là
>>> m = p.match['tempo'] >>> m6; . Điều này chấp nhận
>>> p.match[""] >>> print[p.match[""]] None06 và từ chối
>>> p.match[""] >>> print[p.match[""]] None07, nhưng nó yêu cầu phần mở rộng gồm ba chữ cái và không chấp nhận tên tệp có phần mở rộng gồm hai chữ cái, chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None08. Chúng tôi sẽ phức tạp hóa mô hình một lần nữa trong nỗ lực khắc phục nó
>>> p.match[""] >>> print[p.match[""]] None22
Trong lần thử thứ ba, tất cả các chữ cái thứ hai và thứ ba đều được tạo thành tùy chọn để cho phép các phần mở rộng phù hợp ngắn hơn ba ký tự, chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None08
Hiện tại, mô hình đang trở nên thực sự phức tạp, khiến cho việc đọc và hiểu trở nên khó khăn. Tồi tệ hơn, nếu vấn đề thay đổi và bạn muốn loại trừ cả
>>> p.match[""] >>> print[p.match[""]] None10 và
>>> p.match[""] >>> print[p.match[""]] None25 dưới dạng tiện ích mở rộng, mẫu sẽ càng phức tạp và khó hiểu hơn
Một cái nhìn tiêu cực cắt đứt tất cả sự nhầm lẫn này
>>> p.match[""] >>> print[p.match[""]] None26 Cái nhìn tiêu cực có nghĩa là. nếu biểu thức
>>> p.match[""] >>> print[p.match[""]] None10 không khớp vào thời điểm này, hãy thử phần còn lại của mẫu; . Dấu đuôi
>>> p.match[""] >>> print[p.match[""]] None2665 là bắt buộc để đảm bảo rằng những thứ như
>>> p.match[""] >>> print[p.match[""]] None30, trong đó phần mở rộng chỉ bắt đầu bằng
>>> p.match[""] >>> print[p.match[""]] None10, sẽ được cho phép.
>>> p.match[""] >>> print[p.match[""]] None32 đảm bảo rằng mẫu hoạt động khi có nhiều dấu chấm trong tên tệp
Giờ đây, việc loại trừ một phần mở rộng tên tệp khác trở nên dễ dàng; . Mẫu sau không bao gồm tên tệp kết thúc bằng
>>> p.match[""] >>> print[p.match[""]] None10 hoặc
>>> p.match[""] >>> print[p.match[""]] None25
>>> p.match[""] >>> print[p.match[""]] None35
Sửa đổi chuỗi¶
Cho đến thời điểm này, chúng tôi chỉ đơn giản thực hiện các tìm kiếm đối với một chuỗi tĩnh. Biểu thức chính quy cũng thường được sử dụng để sửa đổi chuỗi theo nhiều cách khác nhau, sử dụng các phương thức mẫu sau
Phương thức/Thuộc tính
Mục đích
>>> p.match[""] >>> print[p.match[""]] None36
Tách chuỗi thành một danh sách, tách nó ở bất cứ đâu RE khớp
>>> p.match[""] >>> print[p.match[""]] None2639
Tìm tất cả các chuỗi con nơi RE khớp và thay thế chúng bằng một chuỗi khác
>>> p.match[""] >>> print[p.match[""]] None38
Thực hiện tương tự như
>>> p.match[""] >>> print[p.match[""]] None2639, nhưng trả về chuỗi mới và số lần thay thế
Tách chuỗi¶
Phương thức
>>> p.match[""] >>> print[p.match[""]] None36 của một mẫu tách một chuỗi ra bất cứ nơi nào RE khớp, trả về một danh sách các phần. Nó tương tự như phương pháp chuỗi
>>> p.match[""] >>> print[p.match[""]] None36 nhưng cung cấp tính tổng quát hơn nhiều trong các dấu phân cách mà bạn có thể phân chia theo; . Như bạn mong đợi, cũng có một hàm
>>> p.match[""] >>> print[p.match[""]] None43 cấp mô-đun.tách[chuỗi[ , maxsplit=0]]
Tách chuỗi bằng các kết quả khớp của biểu thức chính quy. Nếu chụp dấu ngoặc đơn được sử dụng trong RE, thì nội dung của chúng cũng sẽ được trả về như một phần của danh sách kết quả. Nếu maxsplit khác không, thì tối đa các lần tách maxsplit được thực hiện
Bạn có thể giới hạn số lần phân tách được thực hiện bằng cách chuyển một giá trị cho maxsplit. Khi maxsplit khác không, tối đa các lần tách maxsplit sẽ được thực hiện và phần còn lại của chuỗi được trả về dưới dạng phần tử cuối cùng của danh sách. Trong ví dụ sau, dấu phân cách là bất kỳ chuỗi ký tự không phải chữ và số nào
>>> p.match[""] >>> print[p.match[""]] None680
Đôi khi bạn không chỉ quan tâm đến văn bản giữa các dấu phân cách là gì mà còn cần biết dấu phân cách là gì. Nếu chụp dấu ngoặc đơn được sử dụng trong RE, thì giá trị của chúng cũng được trả về như một phần của danh sách. So sánh các cuộc gọi sau
>>> p.match[""] >>> print[p.match[""]] None681
Hàm cấp mô-đun
>>> p.match[""] >>> print[p.match[""]] None43 thêm RE được sử dụng làm đối số đầu tiên, nhưng nếu không thì giống nhau
>>> p.match[""] >>> print[p.match[""]] None682
Tìm kiếm và Thay thế¶
Một nhiệm vụ phổ biến khác là tìm tất cả các kết quả khớp cho một mẫu và thay thế chúng bằng một chuỗi khác. Phương thức
>>> p.match[""] >>> print[p.match[""]] None2639 lấy một giá trị thay thế, có thể là một chuỗi hoặc một hàm và chuỗi sẽ được xử lý.sub[chuỗi thay thế , string[, count=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 chuỗi RE trong chuỗi bằng phép thay thế thay thế. Nếu không tìm thấy mẫu, chuỗi được trả về không thay đổi
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ế; . Giá trị mặc định là 0 có nghĩa là thay thế tất cả các lần xuất hiện
Đây là một ví dụ đơn giản về việc sử dụng phương thức
>>> p.match[""] >>> print[p.match[""]] None2639. Nó thay thế tên màu bằng từ
>>> p.match[""] >>> print[p.match[""]] None47
>>> p.match[""] >>> print[p.match[""]] None683
Phương thức
>>> p.match[""] >>> print[p.match[""]] None38 thực hiện công việc tương tự, nhưng trả về 2-tuple chứa giá trị chuỗi mới và số lần thay thế đã được thực hiện
>>> p.match[""] >>> print[p.match[""]] None684
Các trận đấu trống chỉ được thay thế khi chúng không liền kề với trận đấu trống trước đó
>>> p.match[""] >>> print[p.match[""]] None685
Nếu thay thế là một chuỗi, bất kỳ dấu gạch chéo ngược nào thoát khỏi nó đều được xử lý. Nghĩa là,
>>> p.match[""] >>> print[p.match[""]] None49 được chuyển đổi thành một ký tự xuống dòng,
>>> p.match[""] >>> print[p.match[""]] None50 được chuyển đổi thành ký tự xuống dòng, v.v. Các lối thoát không xác định như
>>> p.match[""] >>> print[p.match[""]] None6874 bị bỏ lại một mình. Các tham chiếu ngược, chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None52, được thay thế bằng chuỗi con khớp với nhóm tương ứng trong RE. Điều này cho phép bạn kết hợp các phần của văn bản gốc trong chuỗi thay thế kết quả
Ví dụ này khớp với từ
>>> p.match[""] >>> print[p.match[""]] None53 theo sau là một chuỗi có trong
>>> p.match[""] >>> print[p.match[""]] None54,
>>> p.match[""] >>> print[p.match[""]] None55 và thay đổi
>>> p.match[""] >>> print[p.match[""]] None53 thành
>>> p.match[""] >>> print[p.match[""]] None57
>>> p.match[""] >>> print[p.match[""]] None686
Ngoài ra còn có một cú pháp để chỉ các nhóm được đặt tên theo định nghĩa của cú pháp
>>> p.match[""] >>> print[p.match[""]] None6888.
>>> p.match[""] >>> print[p.match[""]] None59 sẽ sử dụng chuỗi con phù hợp với nhóm có tên
>>> p.match[""] >>> print[p.match[""]] None60 và
>>> p.match[""] >>> print[p.match[""]] None61 sử dụng số nhóm tương ứng. Do đó,
>>> p.match[""] >>> print[p.match[""]] None62 tương đương với
>>> p.match[""] >>> print[p.match[""]] None63, nhưng không mơ hồ trong một chuỗi thay thế, chẳng hạn như
>>> p.match[""] >>> print[p.match[""]] None64. [
>>> p.match[""] >>> print[p.match[""]] None65 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ữ
>>> p.match[""] >>> print[p.match[""]] None66. ] Các thay thế sau đều tương đương, nhưng sử dụng cả ba biến thể của chuỗi thay thế
>>> p.match[""] >>> print[p.match[""]] None687
thay thế cũng có thể là một chức năng, cho phép bạn kiểm soát nhiều hơn. Nếu sự thay thế là một hàm, thì hàm này được gọi cho mọi lần xuất hiện mẫu không chồng chéo. Trên mỗi lệnh gọi, hàm được truyền một đối số match object để khớp và có thể sử dụng thông tin này để tính toán chuỗi thay thế mong muốn và trả về chuỗi đó.
Trong ví dụ sau, hàm thay thế dịch số thập phân thành thập lục phân
>>> p.match[""] >>> print[p.match[""]] None688
Khi sử dụng hàm
>>> p.match[""] >>> print[p.match[""]] None67 cấp mô-đun, mẫu được chuyển làm đối số đầu tiên. Mẫu có thể được cung cấp dưới dạng đối tượng hoặc dưới dạng chuỗi; . g.
>>> p.match[""] >>> print[p.match[""]] None68 trả về
>>> p.match[""] >>> print[p.match[""]] None69
Những vấn đề chung¶
Biểu thức chính quy là một công cụ mạnh mẽ cho một số ứng dụng, nhưng theo một số cách, hành vi của chúng không trực quan và đôi khi chúng không hành xử theo cách mà bạn có thể mong đợi. Phần này sẽ chỉ ra một số cạm bẫy phổ biến nhất
Sử dụng các phương thức chuỗi¶
Đôi khi sử dụng mô-đun
>>> p.match[""] >>> print[p.match[""]] None5 là một sai lầm. Nếu bạn đang so khớp một chuỗi cố định hoặc một lớp ký tự đơn và bạn không sử dụng bất kỳ tính năng
>>> p.match[""] >>> print[p.match[""]] None5 nào chẳng hạn như cờ
>>> p.match[""] >>> print[p.match[""]] None2642, thì có thể không cần đến toàn bộ sức mạnh của biểu thức chính quy. Các chuỗi có một số phương thức để thực hiện các thao tác với các chuỗi cố định và chúng thường nhanh hơn nhiều, bởi vì việc triển khai là một vòng lặp C nhỏ duy nhất được tối ưu hóa cho mục đích, thay vì công cụ biểu thức chính quy lớn, tổng quát hơn
Một ví dụ có thể là thay thế một chuỗi cố định bằng một chuỗi khác; .
>>> p.match[""] >>> print[p.match[""]] None67 có vẻ như là chức năng được sử dụng cho việc này, nhưng hãy xem xét phương pháp
>>> p.match[""] >>> print[p.match[""]] None76. Lưu ý rằng
>>> p.match[""] >>> print[p.match[""]] None76 cũng sẽ thay thế các từ bên trong
>>> p.match[""] >>> print[p.match[""]] None73, biến
>>> p.match[""] >>> print[p.match[""]] None79 thành
>>> p.match[""] >>> print[p.match[""]] None80, nhưng RE
>>> p.match[""] >>> print[p.match[""]] None73 ngây thơ cũng sẽ làm điều đó. [Để tránh thực hiện thay thế trên các phần của từ, mẫu sẽ phải là
>>> p.match[""] >>> print[p.match[""]] None82, để yêu cầu
>>> p.match[""] >>> print[p.match[""]] None73 có ranh giới từ ở hai bên. Điều này vượt quá khả năng của
>>> p.match[""] >>> print[p.match[""]] None76. ]
Một tác vụ phổ biến khác là xóa mọi lần xuất hiện của một ký tự đơn lẻ khỏi chuỗi hoặc thay thế nó bằng một ký tự đơn lẻ khác. Bạn có thể làm điều này với thứ gì đó như
>>> p.match[""] >>> print[p.match[""]] None85, nhưng
>>> p.match[""] >>> print[p.match[""]] None86 có khả năng thực hiện cả hai tác vụ và sẽ nhanh hơn bất kỳ thao tác biểu thức chính quy nào có thể
Tóm lại, trước khi chuyển sang mô-đun
>>> p.match[""] >>> print[p.match[""]] None5, hãy cân nhắc xem vấn đề của bạn có thể được giải quyết bằng phương pháp chuỗi nhanh hơn và đơn giản hơn không
trận đấu [] so với tìm kiếm []¶
Hàm
>>> m = p.match['tempo'] >>> m699 chỉ kiểm tra xem RE có khớp ở đầu chuỗi hay không trong khi
>>> p.match[""] >>> print[p.match[""]] None2600 sẽ quét qua chuỗi để tìm khớp. Điều quan trọng là phải ghi nhớ sự khác biệt này. Hãy nhớ rằng,
>>> m = p.match['tempo'] >>> m699 sẽ chỉ báo cáo một trận đấu thành công sẽ bắt đầu từ 0;
>>> p.match[""] >>> print[p.match[""]] None689
Mặt khác,
>>> p.match[""] >>> print[p.match[""]] None2600 sẽ quét về phía trước qua chuỗi, báo cáo kết quả khớp đầu tiên mà nó tìm thấy
>>> p.match[""] >>> print[p.match[""]] None0
Đôi khi bạn sẽ muốn tiếp tục sử dụng
>>> p.match[""] >>> print[p.match[""]] None93 và chỉ cần thêm
>>> p.match[""] >>> print[p.match[""]] None94 vào trước RE của bạn. Chống lại sự cám dỗ này và sử dụng
>>> p.match[""] >>> print[p.match[""]] None95 thay thế. Trình biên dịch biểu thức chính quy thực hiện một số phân tích về RE để tăng tốc quá trình tìm kiếm kết quả khớp. Một phân tích như vậy chỉ ra ký tự đầu tiên của một trận đấu phải là gì; . Phân tích cho phép công cụ nhanh chóng quét qua chuỗi để tìm ký tự bắt đầu, chỉ thử khớp hoàn toàn nếu tìm thấy
>>> p.match[""] >>> print[p.match[""]] None97
Việc thêm
>>> p.match[""] >>> print[p.match[""]] None94 sẽ làm mất khả năng tối ưu hóa này, yêu cầu quét đến cuối chuỗi rồi quay lại để tìm kết quả khớp cho phần còn lại của RE. Sử dụng
>>> p.match[""] >>> print[p.match[""]] None95 để thay thế
Tham lam so với Không tham lam¶
Khi lặp lại một biểu thức chính quy, như trong
>>> m = p.match['tempo'] >>> m01, hành động kết quả là sử dụng càng nhiều mẫu càng tốt. Thực tế này thường gây khó chịu cho bạn khi bạn đang cố khớp một cặp dấu phân cách cân bằng, chẳng hạn như dấu ngoặc nhọn bao quanh thẻ HTML. Mẫu ngây thơ để khớp một thẻ HTML không hoạt động do bản chất tham lam của
>>> p.match[""] >>> print[p.match[""]] None94
>>> p.match[""] >>> print[p.match[""]] None1
RE khớp với
>>> m = p.match['tempo'] >>> m03 trong
>>> m = p.match['tempo'] >>> m04 và
>>> p.match[""] >>> print[p.match[""]] None94 tiêu thụ phần còn lại của chuỗi. Tuy nhiên, vẫn còn nhiều hơn trong RE và
>>> m = p.match['tempo'] >>> m06 không thể khớp ở cuối chuỗi, vì vậy công cụ biểu thức chính quy phải truy ngược từng ký tự cho đến khi tìm thấy kết quả khớp cho
>>> m = p.match['tempo'] >>> m06. Trận đấu cuối cùng kéo dài từ
>>> m = p.match['tempo'] >>> m03 trong
>>> m = p.match['tempo'] >>> m04 đến
>>> m = p.match['tempo'] >>> m10 trong
>>> m = p.match['tempo'] >>> m11, đó không phải là điều bạn muốn
Trong trường hợp này, giải pháp là sử dụng các bộ định lượng không tham lam
>>> m = p.match['tempo'] >>> m12,
>>> m = p.match['tempo'] >>> m13,
>>> m = p.match['tempo'] >>> m14 hoặc
>>> m = p.match['tempo'] >>> m15, phù hợp với càng ít văn bản càng tốt. Trong ví dụ trên,
>>> m = p.match['tempo'] >>> m10 được thử ngay sau khi khớp với
>>> m = p.match['tempo'] >>> m03 đầu tiên và khi nó không thành công, công cụ sẽ tiến lên một ký tự tại một thời điểm, thử lại
>>> m = p.match['tempo'] >>> m10 ở mỗi bước. Điều này tạo ra kết quả đúng
>>> p.match[""] >>> print[p.match[""]] None2
[Lưu ý rằng việc phân tích cú pháp HTML hoặc XML bằng các biểu thức chính quy rất khó khăn. Các mẫu nhanh và bẩn sẽ xử lý các trường hợp phổ biến, nhưng HTML và XML có các trường hợp đặc biệt sẽ phá vỡ biểu thức chính quy rõ ràng; . Sử dụng mô-đun trình phân tích cú pháp HTML hoặc XML cho các tác vụ đó. ]
Sử dụng lại. RÕ RÀNG¶
Đến bây giờ, có lẽ bạn đã nhận thấy rằng các biểu thức chính quy là một ký hiệu rất nhỏ gọn, nhưng chúng không dễ đọc lắm. RE có độ phức tạp vừa phải có thể trở thành tập hợp dài các dấu gạch chéo ngược, dấu ngoặc đơn và ký tự đại diện, khiến chúng khó đọc và khó hiểu
Đối với các RE như vậy, việc chỉ định cờ
>>> p.match[""] >>> print[p.match[""]] None2644 khi biên dịch biểu thức chính quy có thể hữu ích vì nó cho phép bạn định dạng biểu thức chính quy rõ ràng hơn
Cờ
>>> p.match[""] >>> print[p.match[""]] None2644 có một số hiệu ứng. Khoảng trắng trong biểu thức chính quy không nằm trong lớp ký tự sẽ bị bỏ qua. Điều này có nghĩa là một biểu thức chẳng hạn như
>>> m = p.match['tempo'] >>> m21 tương đương với
>>> m = p.match['tempo'] >>> m22 ít đọc hơn, nhưng
>>> m = p.match['tempo'] >>> m23 sẽ vẫn khớp với các ký tự
>>> p.match[""] >>> print[p.match[""]] None62,
>>> m = p.match['tempo'] >>> m617 hoặc dấu cách. Ngoài ra, bạn cũng có thể đặt nhận xét bên trong RE; . Khi được sử dụng với chuỗi trích dẫn ba lần, điều này cho phép các RE được định dạng gọn gàng hơn
>>> p.match[""] >>> print[p.match[""]] None3
Điều này dễ đọc hơn nhiều so với
>>> p.match[""] >>> print[p.match[""]] None4
Nhận xét¶
Biểu thức chính quy là một chủ đề phức tạp. Tài liệu này có giúp bạn hiểu chúng không?
Cuốn sách đầy đủ nhất về các biểu thức chính quy gần như chắc chắn là cuốn Mastering Regular Expressions của Jeffrey Friedl, được xuất bản bởi O'Reilly. Thật không may, nó hoàn toàn tập trung vào các biểu thức chính quy của Perl và Java, và hoàn toàn không chứa bất kỳ tài liệu Python nào, vì vậy nó sẽ không hữu ích như một tài liệu tham khảo để lập trình bằng Python. [Ấn bản đầu tiên đề cập đến mô-đun
>>> m = p.match['tempo'] >>> m27 hiện đã bị xóa của Python, mô-đun này sẽ không giúp bạn nhiều. ] Cân nhắc kiểm tra nó từ thư viện của bạn