programming python

Regex dòng tiếp theo sau trận đấu python

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[""]]
None

5. 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[""]]
None

5. 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[""]]
None

7 sẽ khớp chính xác với chuỗi

>>> p.match[""]
>>> print[p.match[""]]
None

7. [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[""]]
None

9 hoặc

>>> m = p.match['tempo']
>>> m

0; 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']
>>> m

1 và

>>> m = p.match['tempo']
>>> m

2. 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']
>>> m

3. Ví dụ:

>>> m = p.match['tempo']
>>> m

4 sẽ khớp với bất kỳ ký tự nào trong số các ký tự

>>> m = p.match['tempo']
>>> m

>>> m = p.match['tempo']
>>> m

6 hoặc

>>> m = p.match['tempo']
>>> m

7; . 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']
>>> m

Siêu ký tự [ngoại trừ

>>> p.match[""]
>>> print[p.match[""]]
None

60] không hoạt động bên trong các lớp. Ví dụ:

>>> p.match[""]
>>> print[p.match[""]]
None

61 sẽ khớp với bất kỳ ký tự nào trong số các ký tự

>>> p.match[""]
>>> print[p.match[""]]
None

62,

>>> p.match[""]
>>> print[p.match[""]]
None

63,

>>> p.match[""]
>>> print[p.match[""]]
None

64 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

65;

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[""]]
None

67 là ký tự đầu tiên của lớp. Ví dụ:

>>> p.match[""]
>>> print[p.match[""]]
None

68 sẽ khớp với bất kỳ ký tự nào ngoại trừ

>>> p.match[""]
>>> print[p.match[""]]
None

69. 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[""]]
None

60 sẽ khớp với một trong hai

>>> p.match[""]
>>> print[p.match[""]]
None

69 hoặc một

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

60. 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[""]]
None

66 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

Một số chuỗi đặc biệt bắt đầu bằng

>>> p.match[""]
>>> print[p.match[""]]
None

68 đạ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[""]]
None

69 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[""]]
None

60. Nếu mẫu biểu thức chính quy là một chuỗi, thì

>>> p.match[""]
>>> print[p.match[""]]
None

69 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[""]]
None

62 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[""]]
None

69 trong mẫu chuỗi bằng cách cung cấp cờ

>>> p.match[""]
>>> print[p.match[""]]
None

64 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[""]]
None

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

>>> p.match[""]
>>> print[p.match[""]]
None

Khớp với bất kỳ ký tự không phải chữ số nào;

>>> p.match[""]
>>> print[p.match[""]]
None

Khớp với bất kỳ ký tự khoảng trắng nào;

>>> p.match[""]
>>> print[p.match[""]]
None

Khớp với bất kỳ ký tự không phải khoảng trắng nào;

>>> p.match[""]
>>> print[p.match[""]]
None

Khớp với bất kỳ ký tự chữ và số nào;

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

67 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[""]]
None

68 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

Siêu ký tự cuối cùng trong phần này là

>>> m = p.match['tempo']
>>> m

600. 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']
>>> m

601] trong đó nó sẽ khớp với cả một dòng mới.

>>> m = p.match['tempo']
>>> m

600 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']
>>> m

603.

>>> m = p.match['tempo']
>>> m

603 không khớp với ký tự chữ

>>> m = p.match['tempo']
>>> m

605;

Ví dụ:

>>> m = p.match['tempo']
>>> m

606 sẽ khớp với

>>> m = p.match['tempo']
>>> m

607 [0

>>> p.match[""]
>>> print[p.match[""]]
None

62 ký tự],

>>> m = p.match['tempo']
>>> m

609 [1

>>> p.match[""]
>>> print[p.match[""]]
None

62],

>>> m = p.match['tempo']
>>> m

611 [3

>>> p.match[""]
>>> print[p.match[""]]
None

62 ký tự], v.v.

Sự lặp lại như

>>> m = p.match['tempo']
>>> m

603 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']
>>> m

614. Điều này phù hợp với chữ cái

>>> p.match[""]
>>> print[p.match[""]]
None

62, không có hoặc nhiều chữ cái từ lớp

>>> m = p.match['tempo']
>>> m

616 và cuối cùng kết thúc bằng

>>> m = p.match['tempo']
>>> m

617. Bây giờ hãy tưởng tượng khớp RE này với chuỗi

>>> m = p.match['tempo']
>>> m

618

Bươc

phù hợp

Giải trình

>>> m = p.match['tempo']
>>> m

>>> m = p.match['tempo']
>>> m

5 trong các trận đấu RE

>>> m = p.match['tempo']
>>> m

621

Động cơ khớp với

>>> m = p.match['tempo']
>>> m

622, đi xa nhất có thể, đến cuối chuỗi

Thất bại

Công cụ cố khớp với

>>> m = p.match['tempo']
>>> m

6, nhưng vị trí hiện tại ở cuối chuỗi nên không thành công

>>> m = p.match['tempo']
>>> m

624

Sao lưu để

>>> m = p.match['tempo']
>>> m

622 khớp với một ký tự ít hơn

Thất bại

Hãy thử lại

>>> m = p.match['tempo']
>>> m

6, nhưng vị trí hiện tại ở ký tự cuối cùng, đó là một

>>> m = p.match['tempo']
>>> m

627

>>> m = p.match['tempo']
>>> m

628

Sao lưu lại để

>>> m = p.match['tempo']
>>> m

622 chỉ khớp với

>>> m = p.match['tempo']
>>> m

630

>>> m = p.match['tempo']
>>> m

624

Hãy thử lại

>>> m = p.match['tempo']
>>> m

6. Lần này ký tự ở vị trí hiện tại là

>>> m = p.match['tempo']
>>> m

617, vậy là thành công

RE hiện đã kết thúc và nó đã khớp với

>>> m = p.match['tempo']
>>> m

634. Đ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']
>>> m

636, 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']
>>> m

603 và

>>> m = p.match['tempo']
>>> m

636; . Để sử dụng một ví dụ tương tự,

>>> m = p.match['tempo']
>>> m

641 sẽ khớp với

>>> m = p.match['tempo']
>>> m

609 [1

>>> p.match[""]
>>> print[p.match[""]]
None

62],

>>> m = p.match['tempo']
>>> m

611 [3

>>> p.match[""]
>>> print[p.match[""]]
None

62], nhưng sẽ không khớp với

>>> m = p.match['tempo']
>>> m

607

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']
>>> m

647, khớp một lần hoặc không lần; . Ví dụ:

>>> m = p.match['tempo']
>>> m

648 khớp với

>>> m = p.match['tempo']
>>> m

649 hoặc

>>> m = p.match['tempo']
>>> m

650

Bộ định lượng phức tạp nhất là

>>> m = p.match['tempo']
>>> m

651, 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']
>>> m

652 sẽ khớp với

>>> m = p.match['tempo']
>>> m

653,

>>> m = p.match['tempo']
>>> m

654 và

>>> m = p.match['tempo']
>>> m

655. Nó sẽ không khớp với

>>> m = p.match['tempo']
>>> m

656, không có dấu gạch chéo hoặc

>>> m = p.match['tempo']
>>> m

657, 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']
>>> m

658 tương đương với

>>> m = p.match['tempo']
>>> m

603,

>>> m = p.match['tempo']
>>> m

660 tương đương với

>>> m = p.match['tempo']
>>> m

636 và

>>> m = p.match['tempo']
>>> m

662 tương đương với

>>> m = p.match['tempo']
>>> m

647. Tốt hơn là sử dụng

>>> m = p.match['tempo']
>>> m

603,

>>> m = p.match['tempo']
>>> m

636 hoặc

>>> m = p.match['tempo']
>>> m

647 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']
>>> m

>>> m = p.match['tempo']
>>> m

668 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[""]]
None

RE được chuyển đến

>>> m = p.match['tempo']
>>> m

668 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[""]]
None

5 chỉ đơn giản là mô-đun mở rộng C có trong Python, giống như mô-đun

>>> m = p.match['tempo']
>>> m

671 hoặc

>>> m = p.match['tempo']
>>> m

672

Đặ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[""]]
None

68] để 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']
>>> m

674, 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']
>>> m

675. Chuỗi kết quả phải được chuyển đến

>>> m = p.match['tempo']
>>> m

668 phải là

>>> m = p.match['tempo']
>>> m

675. 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']
>>> m

674

Chuỗi văn bản cần khớp

>>> m = p.match['tempo']
>>> m

675

Dấu gạch chéo ngược thoát cho

>>> m = p.match['tempo']
>>> m

668

>>> m = p.match['tempo']
>>> m

681

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']
>>> m

682 dưới dạng chuỗi RE, vì biểu thức chính quy phải là

>>> p.match[""]
>>> print[p.match[""]]
None

67 và mỗi dấu gạch chéo ngược phải được biểu thị là

>>> p.match[""]
>>> print[p.match[""]]
None

67 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']
>>> m

692

>>> m = p.match['tempo']
>>> m

693

>>> m = p.match['tempo']
>>> m

681

>>> m = p.match['tempo']
>>> m

695

>>> m = p.match['tempo']
>>> m

696

>>> m = p.match['tempo']
>>> m

697

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']
>>> m

699

Xác định xem RE có khớp ở đầu chuỗi không

>>> p.match[""]
>>> print[p.match[""]]
None

2600

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[""]]
None

2601

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[""]]
None

2602

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[""]]
None

2600 trả về

>>> p.match[""]
>>> print[p.match[""]]
None

2605 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[""]]
None

5. Nếu bạn có sẵn

>>> p.match[""]
>>> print[p.match[""]]
None

2607, 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[""]]
None

2608 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[""]]
None

5 và biên dịch RE

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

2610. Một chuỗi rỗng hoàn toàn không được khớp, vì

>>> m = p.match['tempo']
>>> m

636 có nghĩa là 'một hoặc nhiều lần lặp lại'.

>>> m = p.match['tempo']
>>> m

699 sẽ trả về

>>> p.match[""]
>>> print[p.match[""]]
None

2605 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']
>>> m

699 để 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[""]]
None

2615. Trong trường hợp này,

>>> m = p.match['tempo']
>>> m

699 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[""]]
None

2617

Trả về chuỗi khớp với RE

>>> p.match[""]
>>> print[p.match[""]]
None

2618

Trả lại vị trí bắt đầu của trận đấu

>>> p.match[""]
>>> print[p.match[""]]
None

2619

Trả lại vị trí kết thúc trận đấu

>>> p.match[""]
>>> print[p.match[""]]
None

2620

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[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

2617 trả về chuỗi con khớp với RE.

>>> p.match[""]
>>> print[p.match[""]]
None

2618 và

>>> p.match[""]
>>> print[p.match[""]]
None

2619 trả về chỉ số bắt đầu và kết thúc của trận đấu.

>>> p.match[""]
>>> print[p.match[""]]
None

2620 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[""]]
None

2600 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[""]]
None

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[""]]
None

2605 không. Điều này thường trông giống như.

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

2601 trả về danh sách các chuỗi phù hợp

>>> p.match[""]
>>> print[p.match[""]]
None

Tiền tố

>>> p.match[""]
>>> print[p.match[""]]
None

2630, 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[""]]
None

2601 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[""]]
None

2602 trả về một chuỗi các phiên bản match object dưới dạng iterator .

>>> m = p.match['tempo']
>>> m

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[""]]
None

2605 hoặc match object .

>>> m = p.match['tempo']
>>> m

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[""]]
None

5 dưới hai tên, một tên dài chẳng hạn như

>>> p.match[""]
>>> print[p.match[""]]
None

2642 và một dạng ngắn, một chữ cái chẳng hạn như

>>> p.match[""]
>>> print[p.match[""]]
None

2643. [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[""]]
None

2644 là

>>> p.match[""]
>>> print[p.match[""]]
None

2645 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[""]]
None

2649,

>>> p.match[""]
>>> print[p.match[""]]
None

2650

Làm cho một số lần thoát như

>>> p.match[""]
>>> print[p.match[""]]
None

69,

>>> p.match[""]
>>> print[p.match[""]]
None

2652,

>>> p.match[""]
>>> print[p.match[""]]
None

69 và

>>> p.match[""]
>>> print[p.match[""]]
None

65 chỉ khớp với các ký tự ASCII với thuộc tính tương ứng

________ 12655, ________ 12656

Làm cho

>>> m = p.match['tempo']
>>> m

600 khớp với bất kỳ ký tự nào, bao gồm cả dòng mới

>>> p.match[""]
>>> print[p.match[""]]
None

2642,

>>> p.match[""]
>>> print[p.match[""]]
None

2643

Thực hiện so khớp không phân biệt chữ hoa chữ thường

>>> p.match[""]
>>> print[p.match[""]]
None

2660,

>>> p.match[""]
>>> print[p.match[""]]
None

2661

Thực hiện đối sánh nhận biết ngôn ngữ

>>> p.match[""]
>>> print[p.match[""]]
None

2662,

>>> p.match[""]
>>> print[p.match[""]]
None

2648

Kết hợp nhiều dòng, ảnh hưởng đến

>>> p.match[""]
>>> print[p.match[""]]
None

2664 và

>>> p.match[""]
>>> print[p.match[""]]
None

2665

>>> p.match[""]
>>> print[p.match[""]]
None

2666,

>>> p.match[""]
>>> print[p.match[""]]
None

2667 [đố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ỢP

Thực hiện khớp không phân biệt chữ hoa chữ thường; . Ví dụ:

>>> p.match[""]
>>> print[p.match[""]]
None

2668 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[""]]
None

2649 đượ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']
>>> m

9 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

2668 được sử dụng kết hợp với cờ

>>> p.match[""]
>>> print[p.match[""]]
None

2642, 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' .

>>> p.match[""]
>>> print[p.match[""]]
None

2673 sẽ khớp với

>>> p.match[""]
>>> print[p.match[""]]
None

2674,

>>> p.match[""]
>>> print[p.match[""]]
None

2675,

>>> p.match[""]
>>> print[p.match[""]]
None

2676 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

2677 [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[""]]
None

69,

>>> p.match[""]
>>> print[p.match[""]]
None

65,

>>> p.match[""]
>>> print[p.match[""]]
None

2652,

>>> p.match[""]
>>> print[p.match[""]]
None

2682 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[""]]
None

2683 để khớp các từ, nhưng

>>> p.match[""]
>>> print[p.match[""]]
None

69 chỉ khớp với lớp ký tự

>>> p.match[""]
>>> print[p.match[""]]
None

2685 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[""]]
None

2686 cũng phải được coi là một chữ cái. Đặt cờ

>>> p.match[""]
>>> print[p.match[""]]
None

2660 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[""]]
None

69; . 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 nhau

MĐA DÒNG

[

>>> p.match[""]
>>> print[p.match[""]]
None

2664 và

>>> p.match[""]
>>> print[p.match[""]]
None

2665 chưa được giải thích; chúng sẽ được giới thiệu trong phần Các ký tự khác . ]

Thông thường,

>>> p.match[""]
>>> print[p.match[""]]
None

2664 chỉ khớp ở đầu chuỗi và

>>> p.match[""]
>>> print[p.match[""]]
None

2665 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[""]]
None

2664 sẽ 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[""]]
None

2665 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[""]]
None

69 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[""]]
None

69,

>>> p.match[""]
>>> print[p.match[""]]
None

65,

>>> p.match[""]
>>> print[p.match[""]]
None

2652,

>>> p.match[""]
>>> print[p.match[""]]
None

2682,

>>> p.match[""]
>>> print[p.match[""]]
None

69 và

>>> p.match[""]
>>> print[p.match[""]]
None

61 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

XVERBOSE

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[""]]
None

2644;

>>> m = p.match['tempo']
>>> m

Nếu không có cài đặt dài dòng, RE sẽ trông như thế này

>>> m = p.match['tempo']
>>> m

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 so với phiên bản sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

2644

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[""]]
None

2652 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[""]]
None

6811

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[""]]
None

6812 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[""]]
None

6811 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[""]]
None

6814 sẽ khớp với

>>> p.match[""]
>>> print[p.match[""]]
None

6815 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

6816, không phải

>>> p.match[""]
>>> print[p.match[""]]
None

6817, một

>>> p.match[""]
>>> print[p.match[""]]
None

6818 hoặc một

>>> p.match[""]
>>> print[p.match[""]]
None

6819, và một

>>> p.match[""]
>>> print[p.match[""]]
None

6820

Để khớp với một

>>> p.match[""]
>>> print[p.match[""]]
None

6821 theo nghĩa đen, hãy sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

6822 hoặc đặt nó bên trong một lớp ký tự, như trong

>>> p.match[""]
>>> print[p.match[""]]
None

6823

>>> p.match[""]
>>> print[p.match[""]]
None

2664

Khớp ở đầu dòng. Trừ khi cờ

>>> p.match[""]
>>> print[p.match[""]]
None

2662 đã được đặt, cờ này sẽ chỉ khớp ở đầu chuỗi. Ở chế độ

>>> p.match[""]
>>> print[p.match[""]]
None

2662, đ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[""]]
None

6827 ở đầu dòng, RE sẽ sử dụng là

>>> p.match[""]
>>> print[p.match[""]]
None

6828

>>> m = p.match['tempo']
>>> m

Để khớp với một

>>> p.match[""]
>>> print[p.match[""]]
None

67 theo nghĩa đen, hãy sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

6830

>>> p.match[""]
>>> print[p.match[""]]
None

2665

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']
>>> m

Để khớp với một chữ

>>> p.match[""]
>>> print[p.match[""]]
None

65, hãy sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

6833 hoặc đặt nó bên trong một lớp ký tự, như trong

>>> p.match[""]
>>> print[p.match[""]]
None

6834

>>> p.match[""]
>>> print[p.match[""]]
None

6835

Chỉ khớp ở đầu chuỗi. Khi không ở chế độ

>>> p.match[""]
>>> print[p.match[""]]
None

2662,

>>> p.match[""]
>>> print[p.match[""]]
None

6835 và

>>> p.match[""]
>>> print[p.match[""]]
None

2664 thực sự giống nhau. Ở chế độ

>>> p.match[""]
>>> print[p.match[""]]
None

2662, chúng khác nhau.

>>> p.match[""]
>>> print[p.match[""]]
None

6835 vẫn chỉ khớp ở đầu chuỗi, nhưng

>>> p.match[""]
>>> print[p.match[""]]
None

2664 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[""]]
None

6842

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

>>> p.match[""]
>>> print[p.match[""]]
None

2652

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[""]]
None

6844 khi đó là một từ hoàn chỉnh;

>>> m = p.match['tempo']
>>> m

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[""]]
None

2652 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']
>>> m

685 ở phía trước chuỗi RE

>>> m = p.match['tempo']
>>> m

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[""]]
None

2652 đạ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[""]]
None

2682

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[""]]
None

2652, 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']
>>> m

Đ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[""]]
None

6852,

>>> p.match[""]
>>> print[p.match[""]]
None

6853.

>>> p.match[""]
>>> print[p.match[""]]
None

6852 và

>>> p.match[""]
>>> print[p.match[""]]
None

6853 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[""]]
None

6860 sẽ khớp với 0 hoặc nhiều lần lặp lại của

>>> p.match[""]
>>> print[p.match[""]]
None

6861

>>> m = p.match['tempo']
>>> m

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[""]]
None

260

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[""]]
None

261

>>> p.match[""]
>>> print[p.match[""]]
None

2617 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[""]]
None

262

Phương thức

>>> p.match[""]
>>> print[p.match[""]]
None

6869 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[""]]
None

263

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[""]]
None

6870 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[""]]
None

264

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[""]]
None

60 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[""]]
None

6872 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[""]]
None

6872 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[""]]
None

6874 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

6875

Giải pháp được các nhà phát triển Perl chọn là sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

6876 làm cú pháp mở rộng.

>>> m = p.match['tempo']
>>> m

647 ngay sau dấu ngoặc đơn là một lỗi cú pháp vì

>>> m = p.match['tempo']
>>> m

647 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']
>>> m

647 cho biết tiện ích mở rộng nào đang được sử dụng, do đó,

>>> p.match[""]
>>> print[p.match[""]]
None

6880 là một thứ [một xác nhận nhìn trước tích cực] và

>>> p.match[""]
>>> print[p.match[""]]
None

6881 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[""]]
None

6882]

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[""]]
None

6883, 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[""]]
None

6884, nơi bạn có thể thay thế

>>> p.match[""]
>>> print[p.match[""]]
None

6885 bằng bất kỳ biểu thức chính quy nào khác

>>> p.match[""]
>>> print[p.match[""]]
None

265

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[""]]
None

6884 đặ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 theo 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[""]]
None

6888. rõ ràng là tên của nhóm. Các nhóm được đặt tên hoạt động giống hệt 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[""]]
None

266

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[""]]
None

6889

>>> p.match[""]
>>> print[p.match[""]]
None

267

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[""]]
None

6890

>>> p.match[""]
>>> print[p.match[""]]
None

268

Việc truy xuất

>>> p.match[""]
>>> print[p.match[""]]
None

6891 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[""]]
None

6892 đề 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[""]]
None

6893 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[""]]
None

6894 cũng có thể được viết là

>>> p.match[""]
>>> print[p.match[""]]
None

6895

>>> p.match[""]
>>> print[p.match[""]]
None

269

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[""]]
None

6896

Khẳng định về 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[""]]
None

6885, 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[""]]
None

6898

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[""]]
None

00,

>>> p.match[""]
>>> print[p.match[""]]
None

01 là tên cơ sở và

>>> p.match[""]
>>> print[p.match[""]]
None

02 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[""]]
None

Lưu ý rằng

>>> m = p.match['tempo']
>>> m

600 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[""]]
None

06 và

>>> p.match[""]
>>> print[p.match[""]]
None

07 và

>>> p.match[""]
>>> print[p.match[""]]
None

08 và

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

11 Lần thử đầu tiên ở trên cố gắng loại trừ

>>> p.match[""]
>>> print[p.match[""]]
None

10 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']
>>> m

6. Điều này sai, vì mẫu cũng không khớp với

>>> p.match[""]
>>> print[p.match[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

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']
>>> m

6; . Điều này chấp nhận

>>> p.match[""]
>>> print[p.match[""]]
None

06 và từ chối

>>> p.match[""]
>>> print[p.match[""]]
None

07, 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[""]]
None

08. 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[""]]
None

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[""]]
None

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[""]]
None

10 và

>>> p.match[""]
>>> print[p.match[""]]
None

25 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[""]]
None

26 Cái nhìn tiêu cực có nghĩa là. nếu biểu thức

>>> p.match[""]
>>> print[p.match[""]]
None

10 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[""]]
None

2665 là bắt buộc để đảm bảo rằng những thứ như

>>> p.match[""]
>>> print[p.match[""]]
None

30, trong đó phần mở rộng chỉ bắt đầu bằng

>>> p.match[""]
>>> print[p.match[""]]
None

10, sẽ được cho phép.

>>> p.match[""]
>>> print[p.match[""]]
None

32 đả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[""]]
None

10 hoặc

>>> p.match[""]
>>> print[p.match[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

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[""]]
None

2639

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[""]]
None

Thực hiện tương tự như

>>> p.match[""]
>>> print[p.match[""]]
None

2639, 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[""]]
None

36 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[""]]
None

36 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[""]]
None

43 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[""]]
None

680

Đô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[""]]
None

681

Hàm cấp mô-đun

>>> p.match[""]
>>> print[p.match[""]]
None

43 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[""]]
None

682

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[""]]
None

2639 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[""]]
None

2639. Nó thay thế tên màu bằng từ

>>> p.match[""]
>>> print[p.match[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

683

Phương thức

>>> p.match[""]
>>> print[p.match[""]]
None

38 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[""]]
None

684

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[""]]
None

685

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[""]]
None

49 được chuyển đổi thành một ký tự xuống dòng,

>>> p.match[""]
>>> print[p.match[""]]
None

50 đượ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[""]]
None

6874 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[""]]
None

52, đượ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[""]]
None

53 theo sau là một chuỗi có trong

>>> p.match[""]
>>> print[p.match[""]]
None

54,

>>> p.match[""]
>>> print[p.match[""]]
None

55 và thay đổi

>>> p.match[""]
>>> print[p.match[""]]
None

53 thành

>>> p.match[""]
>>> print[p.match[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

686

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[""]]
None

6888.

>>> p.match[""]
>>> print[p.match[""]]
None

59 sẽ sử dụng chuỗi con phù hợp với nhóm có tên

>>> p.match[""]
>>> print[p.match[""]]
None

60 và

>>> p.match[""]
>>> print[p.match[""]]
None

61 sử dụng số nhóm tương ứng. Do đó,

>>> p.match[""]
>>> print[p.match[""]]
None

62 tương đương với

>>> p.match[""]
>>> print[p.match[""]]
None

63, nhưng không mơ hồ trong một chuỗi thay thế, chẳng hạn như

>>> p.match[""]
>>> print[p.match[""]]
None

64. [

>>> p.match[""]
>>> print[p.match[""]]
None

65 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[""]]
None

66. ] 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[""]]
None

687

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[""]]
None

688

Khi sử dụng hàm

>>> p.match[""]
>>> print[p.match[""]]
None

67 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[""]]
None

68 trả về

>>> p.match[""]
>>> print[p.match[""]]
None

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[""]]
None

5 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 lẻ và bạn không sử dụng bất kỳ tính năng

>>> p.match[""]
>>> print[p.match[""]]
None

5 nào chẳng hạn như cờ

>>> p.match[""]
>>> print[p.match[""]]
None

2642, 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[""]]
None

67 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[""]]
None

76. Lưu ý rằng

>>> p.match[""]
>>> print[p.match[""]]
None

76 cũng sẽ thay thế các từ bên trong

>>> p.match[""]
>>> print[p.match[""]]
None

73, biến

>>> p.match[""]
>>> print[p.match[""]]
None

79 thành

>>> p.match[""]
>>> print[p.match[""]]
None

80, nhưng RE

>>> p.match[""]
>>> print[p.match[""]]
None

73 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[""]]
None

82, để yêu cầu

>>> p.match[""]
>>> print[p.match[""]]
None

73 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[""]]
None

76. ]

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[""]]
None

85, nhưng

>>> p.match[""]
>>> print[p.match[""]]
None

86 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[""]]
None

5, 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']
>>> m

699 chỉ kiểm tra xem RE có khớp ở đầu chuỗi hay không trong khi

>>> p.match[""]
>>> print[p.match[""]]
None

2600 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']
>>> m

699 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[""]]
None

689

Mặt khác,

>>> p.match[""]
>>> print[p.match[""]]
None

2600 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[""]]
None

Đôi khi bạn sẽ muốn tiếp tục sử dụng

>>> p.match[""]
>>> print[p.match[""]]
None

93 và chỉ cần thêm

>>> p.match[""]
>>> print[p.match[""]]
None

94 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[""]]
None

95 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[""]]
None

Việc thêm

>>> p.match[""]
>>> print[p.match[""]]
None

94 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[""]]
None

95 để 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']
>>> m

01, 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[""]]
None

>>> p.match[""]
>>> print[p.match[""]]
None

RE khớp với

>>> m = p.match['tempo']
>>> m

03 trong

>>> m = p.match['tempo']
>>> m

04 và

>>> p.match[""]
>>> print[p.match[""]]
None

94 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']
>>> m

06 không thể khớp ở cuối chuỗi, do đó, 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']
>>> m

06. Trận đấu cuối cùng kéo dài từ

>>> m = p.match['tempo']
>>> m

03 trong

>>> m = p.match['tempo']
>>> m

04 đến

>>> m = p.match['tempo']
>>> m

10 trong

>>> m = p.match['tempo']
>>> m

11, đó 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']
>>> m

12,

>>> m = p.match['tempo']
>>> m

13,

>>> m = p.match['tempo']
>>> m

14 hoặc

>>> m = p.match['tempo']
>>> m

15, 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']
>>> m

10 được thử ngay sau khi khớp với

>>> m = p.match['tempo']
>>> m

03 đầ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']
>>> m

10 ở mỗi bước. Điều này tạo ra kết quả đúng

>>> p.match[""]
>>> print[p.match[""]]
None

[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[""]]
None

2644 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[""]]
None

2644 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']
>>> m

21 tương đương với

>>> m = p.match['tempo']
>>> m

22 ít đọc hơn, nhưng

>>> m = p.match['tempo']
>>> m

23 sẽ vẫn khớp với các ký tự

>>> p.match[""]
>>> print[p.match[""]]
None

62,

>>> m = p.match['tempo']
>>> m

617 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[""]]
None

Điều này dễ đọc hơn nhiều so với

>>> p.match[""]
>>> print[p.match[""]]
None

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']
>>> m

27 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

\r và \n trong regex là gì?

Regex nhận ra các chuỗi thoát phổ biến như \n cho dòng mới, \t cho tab, \r cho xuống dòng , \nnn cho .

\+ nghĩa là gì trong regex?

Ví dụ. Biểu thức chính quy "aa\n" cố khớp hai chữ "a" liên tiếp ở cuối dòng, bao gồm cả ký tự xuống dòng. Thí dụ. "a\+" khớp với "a+" chứ không phải chuỗi một hoặc "a"s . ^ dấu mũ là điểm neo bắt đầu chuỗi hoặc ký hiệu phủ định.

Regex nào khớp với cuối dòng?

Kết thúc Chuỗi hoặc Dòng. $ The $ anchor chỉ định rằng mẫu trước phải xuất hiện ở cuối chuỗi đầu vào hoặc trước \n ở cuối chuỗi đầu vào. Nếu bạn sử dụng $ với RegexOptions. Tùy chọn nhiều dòng, trận đấu cũng có thể xảy ra ở cuối dòng.

Ý nghĩa của \1 trong regex trong Python là gì?

\1 tương đương với re. Tìm kiếm[. ]. group[1] , biểu thức được phân cách bằng dấu ngoặc đơn đầu tiên bên trong biểu thức chính quy . Đó cũng là một sự thật thú vị, một phần lý do khiến các biểu thức chính quy chậm hơn đáng kể trong Python và các ngôn ngữ lập trình khác so với yêu cầu của lý thuyết CS.

Giới thiệu¶

Mẫu đơn giản¶

Nhân vật phù hợp¶

Những điều lặp đi lặp lại¶

Sử dụng Biểu thức Chính quy¶

Biên dịch biểu thức chính quy¶

Bệnh dịch hạch ngược¶

Thi đấu¶

Chức năng cấp mô-đun¶

Cờ tổng hợp¶

Công suất mẫu nhiều hơn¶

Nhiều ký tự hơn¶

Nhóm¶

Nhóm không bắt giữ và được đặt tên¶

Xác nhận nhìn trước¶

Sửa đổi chuỗi¶

Tách chuỗi¶

Tìm kiếm và Thay thế¶

Những vấn đề chung¶

Sử dụng các phương thức chuỗi¶

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

Tham lam so với Không tham lam¶

Sử dụng lại. RÕ RÀNG¶

Nhận xét¶

\r và \n trong regex là gì?

\+ nghĩa là gì trong regex?

Regex nào khớp với cuối dòng?

Ý nghĩa của \1 trong regex trong Python là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề