Hướng dẫn how do you match a backslash in regex python? - làm cách nào để khớp dấu gạch chéo ngược trong regex python?

Các ký tự phù hợp

Hầu hết các chữ cái và ký tự sẽ đơn giản phù hợp với chính họ. Ví dụ: biểu thức thông thường

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

Có những trường hợp ngoại lệ cho quy tắc này; Một số nhân vật là những người metacharacters đặc biệt, và don lồng phù hợp với chính họ. Thay vào đó, họ báo hiệu rằng một số điều ngoài tầm 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 metacharacters khác nhau và những gì họ làm.

Ở đây, một danh sách đầy đủ các metacharacters; Ý nghĩa của chúng sẽ được thảo luận trong phần còn lại của howto này.

. ^ $ * + ? { } [ ] \ | ( )

Các metacharacters đầu tiên mà chúng tôi sẽ xem xét là

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

Metacharacters (trừ

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

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 cho tập hợp. Điều này được biểu thị bằng cách bao gồm một

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

Có lẽ metacharacter quan trọng nhất là dấu gạch chéo ngược,

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

. ^ $ * + ? { } [ ] \ | ( )

. ^ $ * + ? { } [ ] \ | ( )

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

. ^ $ * + ? { } [ ] \ | ( )

Hãy để lấy một ví dụ:

. ^ $ * + ? { } [ ] \ | ( )

. ^ $ * + ? { } [ ] \ | ( )

. ^ $ * + ? { } [ ] \ | ( )

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

. ^ $ * + ? { } [ ] \ | ( )

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Danh sách sau đây các chuỗi đặc biệt là hoàn thành. Để biết danh sách đầy đủ các chuỗi và các định nghĩa lớp mở rộng cho các mẫu chuỗi Unicode, hãy xem phần cuối cùng của cú pháp biểu thức chính quy trong tham chiếu thư viện tiêu chuẩn. Nói chung, các phiên bản Unicode phù hợp với bất kỳ ký tự nào mà trong danh mục thích hợp trong cơ sở dữ liệu Unicode.Regular Expression Syntax in the Standard Library reference. In general, the Unicode versions match any character that’s in the appropriate category in the Unicode database.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Phù hợp với bất kỳ chữ số thập phân; Điều này tương đương với lớp

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Khớp với bất kỳ ký tự không chữ số nào; Điều này tương đương với lớp

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Phù hợp với bất kỳ ký tự khoảng trắng nào; Điều này tương đương với lớp

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Phù hợp với bất kỳ ký tự không phải là màu sắc nào; Điều này tương đương với lớp

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

. ^ $ * + ? { } [ ] \ | ( )

Phù hợp với bất kỳ ký tự chữ và số nào; Điều này tương đương với lớp

. ^ $ * + ? { } [ ] \ | ( )

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Phù hợp với bất kỳ ký tự không phải là đồngumeric; Điều này tương đương với lớp

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Các chuỗi này có thể được bao gồm bên trong một lớp ký tự. Ví dụ:

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Metacharacter cuối cùng trong phần này là

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Lặp lại mọi thứ

Có thể khớp với các bộ ký tự khác nhau là điều đầu tiên các biểu thức chính quy có thể làm điều đó là có thể với các phương thức có sẵn trên các chuỗi. Tuy nhiên, nếu đó là khả năng bổ sung duy nhất của Regexes, thì họ sẽ không phải là một 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.

Metacharacter đầu tiên để lặp lại những thứ mà chúng tôi sẽ xem xét là

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Ví dụ:

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

Sự lặp lại như

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Một ví dụ từng bước sẽ làm cho điều này rõ ràng hơn. Hãy cùng xem xét biểu thức

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Sao lưu lại, để

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Hãy thử lại

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Sự kết thúc của RE đã đạt được và nó đã khớp với

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Một metacharacter lặp lại khác là

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Có hai toán tử hoặc định lượng lặp lại. Ký tự dấu câu hỏi,

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

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

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Sử dụng các biểu thức thông thường

Bây giờ chúng tôi đã xem xét một số biểu thức thông thường đơn giản, làm thế nào để chúng ta thực sự sử dụng chúng trong Python? Mô -đun

String 1: 'a\\t'
String 2: 'a\t'

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Biên soạn các biểu thức chính quy

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

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 như tìm kiếm các kết quả phù hợp mẫu hoặc thực hiện thay thế chuỗi.

Đặt res vào các 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ự dấu gạch chéo ngược (

. ^ $ * + ? { } [ ] \ | ( )

Hãy nói rằng bạn muốn viết một RE phù hợp với chuỗi

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Nói tóm lại, để phù hợp với một dấu gạch chéo ngược theo nghĩa đen, người ta phải viết

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

. ^ $ * + ? { } [ ] \ | ( )

. ^ $ * + ? { } [ ] \ | ( )

Giải pháp là sử dụng ký hiệu chuỗi thô Python sườn cho các biểu thức thông thường; Backslashes không được xử lý theo bất kỳ cách đặc biệt nào trong một chuỗi theo nghĩa đen được đặt trước với

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

. ^ $ * + ? { } [ ] \ | ( )

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Ngoài ra, các chuỗi thoát đặc biệt có giá trị trong các biểu thức chính quy, nhưng không hợp lệ như các chữ Python, bây giờ dẫn đến

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Thực hiện các trận đấu

Khi bạn có một đối tượng đại diện cho một biểu thức thông thường được biên dịch, bạn sẽ làm gì với nó? Đối tượng mẫu có một số phương thức và thuộc tính. Chỉ những người quan trọng nhất sẽ được đề cập ở đây; Tham khảo các tài liệu

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

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

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Howto này sử dụng trình thông dịch Python tiêu chuẩn cho các ví dụ của nó. Đầu tiên, chạy trình thông dịch Python, nhập mô -đun

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Bây giờ, bạn có thể thử khớp các chuỗi khác nhau với RE

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Bây giờ, hãy để thử nó trên một chuỗi mà nó sẽ phù hợp, chẳng hạn như

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

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 trường hợp đối tượng khớp cũng có một số phương thức và thuộc tính; Những cái quan trọng nhất là:match object for information about the matching string. Match object instances also have several methods and attributes; the most important ones are:

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Thử các phương pháp này sẽ sớm làm rõ ý nghĩa của chúng:

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

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 nó có phải là

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Hai phương thức mẫu trả về tất cả các trận đấu cho một mẫu.

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Tiền tố

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Các chức năng cấp độ mô-đun

Bạn không phải tạo ra một đối tượng mẫu và gọi các phương thức của nó; Mô-đun

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Dưới mui xe, các chức năng này chỉ cần 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 đó. Họ cũng lưu trữ đối tượng được 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 won won cần phải phân tích lại mẫu.

Bạn nên sử dụng các chức năng cấp mô-đun này, hoặc bạn nên tự mình lấy mẫu và gọi các phương thức của nó? Nếu bạn đang truy cập vào một regex trong một vòng lặp, việc biên dịch trước, nó sẽ lưu một vài cuộc gọi chức năng. Bên ngoài các vòng lặp, có rất nhiều sự khác biệt nhờ bộ đệm nội bộ.

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 thức biểu thức thường xuyên hoạt động. Cờ có sẵn trong mô-đun

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Ở đây, một bảng của các cờ có sẵn, tiếp theo là một lời giải thích chi tiết hơn về từng người.

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

. ^ $ * + ? { } [ ] \ | ( )

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Thực hiện kết hợp không nhạy cảm trường hợp; lớp ký tự và chuỗi theo nghĩa đen sẽ phù hợp với các chữ cái bằng cách bỏ qua trường hợp. Ví dụ,

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Tạo

. ^ $ * + ? { } [ ] \ | ( )

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Các địa phươ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 ngôn ngữ. Ví dụ: nếu bạn xử lý văn bản Pháp được mã hóa, bạn sẽ muốn có thể viết

>>> match = re.search('a\\t','a\\t')        //Match is None

. ^ $ * + ? { } [ ] \ | ( )

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

. ^ $ * + ? { } [ ] \ | ( )

>>> match = re.search('a\\t','a\\t')        //Match is None

.More Metacharacters.)

Thông thường

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Làm cho nhân vật đặc biệt

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

Tạo

. ^ $ * + ? { } [ ] \ | ( )

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Cờ này cho phép bạn viết các biểu thức thông thường dễ đọc hơn bằng cách cấp cho bạn sự linh hoạt hơn trong cách bạn có thể định dạng chúng. Khi lá cờ này đã được chỉ định, khoảng trắng trong chuỗi RE bị bỏ qua, ngoại trừ khi khoảng trắng nằm trong một lớp ký tự hoặc đi trước bởi một dấu gạch chéo ngược không được điều chỉnh; Điều này cho phép bạn tổ chức và thụt vào RE rõ ràng hơn. Cờ này cũng cho phép bạn đặt bình luận trong một RE sẽ bị động cơ bỏ qua; Nhận xét được đánh dấu bằng một

String 1: 'a\t'
String 2: 'a\t' 

Ví dụ, ở đây, một RE sử dụng

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

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

>>> match = re.search('a\\t','a\\t')        //Match is None

Trong ví dụ trên, sự kết nối tự động của các chuỗi chuỗi 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

>>> match = re.search('a\\t','a\\t')        //Match is None

Thêm Metacharacters¶

Có một số metacharacters mà chúng tôi đã bảo vệ. Hầu hết trong số họ sẽ được đề cập trong phần này.

Một số metacharacters còn lại sẽ được thảo luận là các xác nhận không có chiều rộng. Họ không làm cho động cơ tiến qua chuỗi; Thay vào đó, họ không tiêu thụ nhân vật nào cả, và chỉ đơn giản là thành công hay thất bại. Ví dụ,

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\t'
String 2: 'a\t' 

Sự xen kẽ, hoặc nhà điều hành của người khác. Nếu A và B là các biểu thức thông thường,

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Để phù hợp với nghĩa đen

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Phù hợp ở đầu dòng. Trừ khi cờ

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Ví dụ: nếu bạn muốn khớp từ

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Để phù hợp với nghĩa đen

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Các khớp ở cuối dòng, được định nghĩa là đầu cuối của chuỗi hoặc bất kỳ vị trí nào theo sau là ký tự dòng mới.

>>> match = re.search('a\\t','a\\t')        //Match is None

Để phù hợp với nghĩa đen

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

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

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\t'
String 2: 'a\t' 

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

>>> match = re.search('a\\t','a\\t')        //Match is None

Ranh giới từ. Đây là một khẳng định không có chiều rộng không chỉ khớp với đầu hoặc cuối của một từ. Một từ được định nghĩa là một chuỗi các ký tự chữ và số, do đó, phần cuối của một từ được biểu thị bằng khoảng trắng hoặc một ký tự không phải là vô sinh.

Ví dụ sau đây chỉ khớp với

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Có hai sự tinh tế bạn nên nhớ khi sử dụng chuỗi đặ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 chữ Python và trình tự biểu thức chính quy. Trong các chuỗi chữ Python,

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

Thứ hai, bên trong một lớp ký tự, trong đó không có cách sử dụng cho khẳng định này,

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Một khẳng định không có chiều rộng khác, điều này trái ngược với

>>> match = re.search('a\\t','a\\t')        //Match is None

Nhóm

Thường thì bạn cần có thêm 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 để mổ xẻ các chuỗi bằng cách viết một RE được chia thành một số nhóm nhỏ 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

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Điều này có thể được xử lý bằng cách viết một biểu thức thông thường phù hợp với toàn bộ dòng tiêu đề và có một nhóm phù hợp với tên tiêu đề và một nhóm khác phù hợp với giá trị tiêu đề.

Các nhóm được đánh dấu bằng

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

Các nhóm được chỉ định với

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

Các nhóm nhỏ được đánh số từ trái sang phải, từ 1 trở lên. Các nhóm có thể được lồng nhau; Để xác định số, chỉ cần đếm các ký tự dấu ngoặc đơn, đi từ trái sang phải.

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\t'
String 2: 'a\t' 

Phương pháp

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Backrefer trong một mẫu cho phép bạn chỉ định rằng nội dung của một 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ụ,

String 1: 'a\t'
String 2: 'a\t' 

Ví dụ: RE sau đây phát hiện các từ nhân đôi trong một chuỗi.

String 1: 'a\t'
String 2: 'a\t' 

Các bản sao lưu như thế này, aren thường hữu ích khi chỉ tìm kiếm qua một chuỗi - có một vài đị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.

Các nhóm không bắt giữ và được đặt tên

Xây dựng RES có thể sử dụng nhiều nhóm, cả hai để nắm bắt các nền tảng quan tâm, và để nhóm và cấu trúc chính lại. Trong Res phức tạp, việc theo dõi các số nhóm trở nên khó khăn. Có hai tính năng giúp với 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 thông thường, vì vậy chúng tôi sẽ xem xét điều đó trước.

Perl 5 nổi tiếng với các 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 metacharacters phát âm đơn mới hoặc các chuỗi đặc biệt mới bắt đầu bằng

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

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

String 1: 'a\t'
String 2: 'a\t' 

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Python hỗ trợ một số tiện ích mở rộng Perl Perl và thêm cú pháp mở rộng vào cú pháp mở rộng Perl. Nếu nhân vật đầu tiên sau dấu hỏi là một

String 1: 'a\t'
String 2: 'a\t' 

Bây giờ chúng tôi đã xem xét cú pháp mở rộng chung, chúng tôi có thể quay lại các tính năng đơn giản hóa việc làm việc với các nhóm trong Res 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 thông thường, nhưng aren quan tâm đến việc truy xuất nội dung của nhóm. Bạn có thể làm rõ thực tế này bằng cách sử dụng một nhóm không bắt giữ:

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Ngoại trừ thực tế là bạn có thể lấy lại nội dung của những gì nhóm phù hợ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ữ; Bạn có thể đặt bất cứ thứ gì bên trong nó, lặp lại nó với một metacharacter lặp lại như

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\t'
String 2: 'a\t' 

Một tính năng quan trọng hơn được đặt tên là các nhóm: thay vì đề cập đến chúng theo số, các nhóm có thể được tham chiếu bằng một tên.

Cú pháp cho một nhóm được đặt tên là một trong những tiện ích mở rộng cụ thể của Python:

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Ngoài ra, bạn có thể truy xuất các nhóm được đặt tên là từ điển với

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Các nhóm được đặt tên là tiện dụng vì họ cho phép bạn sử dụng tên dễ nhớ, thay vì phải nhớ số. Ở đây, một ví dụ RE từ mô -đun

String 1: 'a\t'
String 2: 'a\t' 

String 1: 'a\t'
String 2: 'a\t' 

Nó rõ ràng dễ dàng hơn nhiều để lấy

String 1: 'a\t'
String 2: 'a\t' 

Cú pháp cho các bản sao lưu trong một biểu thức như

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

String 1: 'a\t'
String 2: 'a\t' 

Asserments LookAhead

Một khẳng định không có chiều rộng khác là khẳng định lookahead. Các khẳng định lookahead có sẵn ở cả hình thức tích cực và tiêu cực, và trông như thế này:

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Khẳng định nhìn tích cực. Điều này thành công nếu biểu thức có chứa chính quy, được biểu thị ở đây bằng

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Khẳng định cái nhìn tiêu cực. Đây là điều ngược lại với khẳng định tích cực; Nó thành công nếu biểu thức chứa không phù hợp ở vị trí hiện tại trong chuỗi.

Để làm cho bê tông này, hãy để Lôi nhìn vào một trường hợp mà một cái nhìn 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à chia nó thành một tên cơ sở và một phần mở rộng, được phân tách bằng

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Mô hình phù hợp với điều này khá đơn giản:

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Lưu ý rằng

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Bây giờ, hãy xem xét làm phức tạp vấn đề một chút; Điều gì sẽ xảy ra nếu bạn muốn khớp tên tệp trong đó tiện ích mở rộng không phải là

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Biểu thức trở nên lộn xộn hơn khi bạn cố gắng vá 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: ký tự đầu tiên của phần mở rộng isn

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search(r'a\\t','a\\t')           // match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Trong lần thử thứ ba, các chữ cái thứ hai và thứ ba đều được thực hiện 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ư

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Các mẫu mà trở nên thực sự phức tạp bây giờ, khiến nó khó đọc và hiểu. Tồi tệ hơn, nếu vấn đề thay đổi và bạn muốn loại trừ cả

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Một cái nhìn tiêu cực cắt giảm tất cả sự nhầm lẫn này:

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Không bao gồm một phần mở rộng tên tệp khác bây giờ là dễ dàng; Đơn giản chỉ cần thêm nó như một sự thay thế bên trong khẳng định. Mẫu sau đây loại trừ tên tệp kết thúc trong

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Chuỗi phân tách

Phương pháp

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Chia chuỗi phân chia theo các kết quả 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ả lại như một phần của danh sách kết quả. Nếu MAXSplit là khác nhau, tại hầu hết các phân tách MaxSplit được thực hiện.

Bạn có thể giới hạn số lượng phân tách được thực hiện, bằng cách chuyển một giá trị cho MaxSplit. Khi MAXSplit là không khác biệt, tại hầu hết các phân tách MaxSplit sẽ được thực hiện và phần còn lại của chuỗi được trả về làm yếu 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 các ký tự không phải là vô hiệu.

String 1: 'a\t'
String 2: 'a\t' 

Đôi khi, bạn không chỉ quan tâm đến văn bản giữa các phân định là gì, mà còn cần biết dấu phân cách là gì. Nếu thu được dấu ngoặc đơn được sử dụng trong RE, thì các 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:

String 1: 'a\t'
String 2: 'a\t' 

Hàm cấp độ mô-đun

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Tìm kiếm và thay thế Or

Một nhiệm vụ phổ biến khác là tìm tất cả các trận đấu cho một mẫu và thay thế chúng bằng một chuỗi khác. Phương thức

>>> match = re.search('a\\t','a\\t')        //Match is None

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 bên trái của RE trong chuỗi bằng cách thay thế thay thế. Nếu mẫu được tìm thấy, chuỗi được trả về không thay đổi.

Số lượng đối số tùy chọn là số lượng tối đa của các lần xuất hiện mẫu được thay thế; Đếm phải là một số nguyên không âm. Giá trị mặc định của 0 có nghĩa là thay thế tất cả các lần xuất hiện.

Ở đây, một ví dụ đơn giản về việc sử dụng phương pháp

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Phương thức

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Các trận đấu trống chỉ được thay thế khi họ không liền kề với trận đấu trống trước đó.

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Nếu thay thế là một chuỗi, bất kỳ dấu gạch chéo ngược nào đều thoát trong đó được xử lý. Đó là,

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Ví dụ này khớp với từ

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Ngoài ra, còn có một cú pháp để đề cập đến các nhóm được đặt tên theo định nghĩa của cú pháp

String 1: 'a\t'
String 2: 'a\t' 

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Thay thế cũng có thể là một chức năng, giúp bạn kiểm soát nhiều hơn. Nếu thay thế là một hàm, hàm được gọi cho mọi lần xuất hiện không chồng chéo của mẫu. Trên mỗi cuộc gọi, hàm được chuyển một đối số đối tượng khớp cho trận đấu 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ề nó.match object argument for the match and can use this information to compute the desired replacement string and return it.

Trong ví dụ sau, hàm thay thế chuyển số thập phân thành thập lục phân:

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Khi sử dụng hàm

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

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

Đôi khi sử dụng mô -đun

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\t','a\\t')        //Match is None

Một ví dụ có thể là thay thế một chuỗi cố định bằng một chuỗi khác; Ví dụ: bạn có thể thay thế

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Một nhiệm vụ phổ biến khác là xóa mọi lần xuất hiện của một ký tự từ một chuỗi hoặc thay thế nó bằng một ký tự đơn khác. Bạn có thể làm điều này với một cái gì đó như

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Nói tóm lại, trước khi chuyển sang mô -đun

String 1: 'a\\t'
String 2: 'a\t'

khớp () so với tìm kiếm () ¶

Hàm

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Mặt khác,

>>> match = re.search('a\\t','a\\t')        //Match is None

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

Đôi khi, bạn sẽ bị cám dỗ để tiếp tục sử dụng

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

Thêm

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

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

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

>>> match = re.search('a\\\\t','a\\t')          // Match contains 'a\t'

RE khớp với

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

Trong trường hợp này, giải pháp là sử dụng các bộ định lượng không màu xanh lá cây

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

. Xử lý tất cả các trường hợp có thể, các mẫu sẽ rất phức tạp. Sử dụng mô -đun phân tích cú pháp HTML hoặc XML cho các tác vụ đó.)

Sử dụng Re.verbose¶

Đến bây giờ, bạn có thể nhận thấy rằng các biểu thức thông thường là một ký hiệu rất nhỏ gọn, nhưng chúng không thể đọc được khủng khiếp. Res của sự phức tạp vừa phải có thể trở thành các bộ sưu tập dài các dấu gạch chéo ngược, dấu ngoặc đơn và metacharacters, khiến chúng khó đọc và hiểu.

Đối với độ phân giải như vậy, việc chỉ định cờ

>>> match = re.search('a\\t','a\\t')        //Match is None

Cờ

>>> match = re.search('a\\t','a\\t')        //Match is None

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

>>> s = '\\t'
>>> print ("[" + s  + "]")
>>> [\t]                // '\t' after preprocessing

String 1: 'a\\t'
String 2: 'a\t'

String 1: 'a\\t'
String 2: 'a\t'

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

String 1: 'a\\t'
String 2: 'a\t'