programming python

Regex khớp với chuỗi python

Biểu thức chính quy trong Python không thể hiện thông qua mô-đun re, mô-đun cung cấp sự hỗ trợ đầy đủ cho các Biểu thức chính quy trong Python. Mô-đun này tạo ngoại lệ là lại. lỗi nếu xảy ra lỗi trong khi biên dịch hoặc khi sử dụng Biểu thức chính quy. Để sử dụng lại công việc đầu tiên, bạn cần phải nhập lại mô-đun vào chương trình, sử dụng với cú pháp như sau

nhập lại

Các hàm Regex trong Python

Các hàm regex sau được sử dụng trong Python

STT

Giăm bông

description

cuộc thi đấu

This function match with regex regex in string with the option flag. Nó trả về true nếu một kết quả khớp được tìm thấy trong chuỗi nếu nó không trả về false

Tìm kiếm

Hàm này trả về đối tượng khớp nếu có một kết quả khớp được tìm thấy trong chuỗi

tìm tất cả

Nó trả về một danh sách chứa tất cả các kết quả khớp của một mẫu trong chuỗi

tách ra

Trả về một danh sách trong chuỗi đó đã được phân chia theo từng kết quả khớp

phụ

Replace or an many results in string

>>>Xem thêm. Booleans trong Python - Các kiểu dữ liệu trong Python

Xây dựng Regex trong Python

Một biểu thức chính quy trong Python có thể được xây dựng bởi các Meta Characters, set orchart character

Build bằng Metacharacter

siêu ký tự

description

Ví dụ

[]

Nó đại diện cho các ký tự tập tin

"[a-z]"

Nó đại diện cho các ký tự đặc biệt

"\r"

Nó đại diện cho bất kỳ ký tự nào xuất hiện ở một số nơi cụ thể

"Ja. v. "

Nó đại diện cho mẫu có mặt ở đầu chuỗi

"^Java"

Nó đại diện cho mẫu có mặt ở cuối chuỗi

"viettuts"

Nó đại diện cho không hoặc nhiều lần xuất hiện của một mẫu trong chuỗi

"xin chào*"

Nó đại diện cho một hoặc nhiều lần xuất hiện của một mẫu trong chuỗi

"chào +"

{}

Số lần xuất hiện chỉ định của một mẫu trong chuỗi

"java{2}"

Nó biểu diễn cho cái này hoặc cái kia [điều kiện hoặc]

"trăn2. trăn3"

[]

Nhóm các thành phần

>>>Tham khảo. Key learning set Python

Regex trong Python - Build by set

Một tập hợp là một nhóm các ký tự được đưa ra bên trong một cặp dấu ngoặc kép. Nó đại diện cho nghĩa đặc biệt

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. 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

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. 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ế độ 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 một dãy ký tự có thể được chỉ định 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

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

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

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

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

42,

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

43,

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

44 hoặc

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

45;

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

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

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

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

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

49. 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

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

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

49 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

40. 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

46 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

48 đạ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

49 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, thì điều này tương đương với lớp

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

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

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

49 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 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

49 trong mẫu chuỗi bằng cách cung cấp cờ khi biên dịch biểu thức chính quy

Danh sách các trình tự đặc biệt sau đây chưa hoàn thành. Để 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 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

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

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

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

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

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

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

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

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;

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

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ụ:

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

27 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

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

28 hoặc

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

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

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

200. 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ế [] trong đó nó sẽ khớp với cả một dòng mới.

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

200 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

203.

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

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

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

205;

Ví dụ:

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

206 sẽ khớp với

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

207 [0

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

42 ký tự],

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

209 [1

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

42],

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

211 [3

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

42 ký tự], v.v.

Sự lặp lại như

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

203 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

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

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

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

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

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

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

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

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

218

Bước chân

phù hợp

Giải trình

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

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

5 trong trận đấu RE

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

221

Động cơ khớp với

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

222, đ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

224

Sao lưu, để

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

222 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

227

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

228

Sao lưu lại để

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

222 chỉ khớp với

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

230

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

224

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

217, 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

234. Đ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 nó thử không khớp cho ________ 5222 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

236, 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

203 và

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

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

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

241 sẽ khớp với

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

209 [1

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

42],

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

211 [3

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

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

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

207

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

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

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

248 khớp với

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

249 hoặc

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

250

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

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

251, 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

252 sẽ khớp với

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

253,

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

254 và

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

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

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

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

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

257, 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

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

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

203,

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

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

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

236 và

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

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

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

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

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

203,

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

236 hoặc

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

247 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

cũng chấp nhận một đối số cờ tùy chọn, được sử dụng để bật các tính năng đặc biệt và biến thể cú pháp khác nhau. 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 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 chỉ đơn giản là mô-đun mở rộng C có trong Python, giống như mô-đun hoặc

Đặ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 đó, biểu thức chính quy sử dụng ký tự dấu gạch chéo ngược [

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

48] để 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

274, 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 mọi dấu gạch chéo ngược và các ký tự meta 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

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

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

275. 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

274

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

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

275

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

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

281

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

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

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

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

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

47 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 biểu thức chính quy, nhưng không hợp lệ dưới dạng chuỗi ký tự Python, giờ đây sẽ dẫn đến a và cuối cùng sẽ trở thành , 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 không được sử dụng

Chuỗi thông thường

chuỗi thô

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

292

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

293

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

281

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

295

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

296

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

297

Các trận đấu biểu diễn

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

299

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

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

1900

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

1901

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

1902

Tìm tất cả các chuỗi con nơi RE khớp và trả về chúng dưới dạng

và trả lại

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

1905 nếu không tìm thấy kết quả phù hợp. Nếu chúng thành công, một phiên bản sẽ được trả về, chứa thông tin về trận đấu. 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. Nếu bạn có sẵn, 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

1908 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 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

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

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

236 có nghĩa là 'một hoặc nhiều lần lặp lại'. nên trả về

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

1905 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

299 để làm rõ điều này

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

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

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

1915. Trong trường hợp này, sẽ trả về a , 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 thông tin về chuỗi phù hợ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

1917

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

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

1918

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

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

1919

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

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

1920

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

trả về chuỗi con phù hợp với RE. và trả lại chỉ số bắt đầu và kết thúc của trận đấu. trả về cả chỉ mục bắt đầu và kết thúc trong một tuple. Vì phương thức chỉ kiểm tra xem RE có khớp ở đầu chuỗi hay không, nên

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

1918 sẽ luôn bằng 0. Tuy nhiên, phương pháp của các mẫu 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ữ trong một biến, sau đó kiểm tra xem nó có phải là

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

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

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

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. trả về một danh sách các chuỗi phù hợp

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

Tiền tố

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

1930, biến ký tự thành một 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 "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ờ đây dẫn đến a và cuối cùng sẽ trở thành một. Nhìn thấy

phải tạo toàn bộ danh sách trước khi có thể trả về kết quả. Phương thức này trả về một chuỗi các thể hiện dưới dạng

>>> 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ề

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

1905 hoặc một phiên bản

>>> 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 dưới hai tên, một tên dài chẳng hạn như

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

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

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

1943. [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 is chẳng hạn. ] Nhiều cờ có thể được chỉ định theo bit OR-trong 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

1949,

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

1950

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

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

49,

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

1952,

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

49 và

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

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

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

1955,

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

1956

Làm cho

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

200 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

1942,

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

1943

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

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

1960,

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

1961

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

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

1962,

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

1948

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

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

1964 và

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

1965

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

1966,

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

1967 [đố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

1968 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

1949 đượ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

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

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

1942, chúng sẽ khớp với 52 chữ cái ASCII và 4 chữ cái không phải ASCII bổ sung. 'İ' [U+0130, chữ cái in hoa Latinh I có dấu chấm ở trên], 'ı' [U+0131, chữ cái nhỏ i không có dấu chấm trong tiếng Latinh], 'ſ' [U+017F, chữ cái nhỏ Latinh dài s] và 'K' .

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

1973 sẽ khớp với

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

1974,

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

1975,

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

1976 hoặc

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

1977 [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

49,

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

25,

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

1952,

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

1982 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

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

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

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

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

1985 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

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

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

1960 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

49; . 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

1964 và

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

1965 vẫn chưa được giải thích; chúng sẽ được giới thiệu trong phần. ]

Thông thường,

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

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

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

1965 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

1964 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

1965 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

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

29 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

49,

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

25,

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

1952,

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

1982,

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

49 và

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

21 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 ;

>>> 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

Thêm sức mạnh mẫu

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

Thêm siêu ký tự

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

1952 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

4711

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

4712 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

4711 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

4714 sẽ khớp với

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

4715 hoặc

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

4716, không phải

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

4717, một

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

4718 hoặc một

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

4719, và một

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

4720

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

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

4721, hãy sử dụng

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

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

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

4723

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

1964

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

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

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

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

1962, đ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

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

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

4728

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

Để khớp với một

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

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

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

4730

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

1965

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

45, hãy sử dụng

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

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

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

4734

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

4735

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

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

1962,

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

4735 và

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

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

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

1962, chúng khác nhau.

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

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

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

1964 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

4742

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

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

1952

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

4744 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ự của Python,

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

1952 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

1952 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

285 ở 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

1952 đạ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

1982

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

1952, 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 ____14751, 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

4752,

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

4753.

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

4752 và

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

4753 có nhiều ý nghĩa giống như chúng trong các biểu thức toán học; . Ví dụ:

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

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

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

4761

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

Các nhóm được chỉ định bằng

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

4752,

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

4753 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

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

190

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

191

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

192

Phương thức này 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 con.

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

193

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

4770 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

194

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

40 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

4772 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

4772 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

4774 hoặc

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

4775

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

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

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

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

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

247 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

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

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

4780 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

4781 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

4782]

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

4783, 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

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

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

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

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

195

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

4784 đặ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 một 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

4788. 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 xử lý các nhóm bắt giữ đều chấp nhận các số nguyên tham chiếu đến nhóm theo số hoặc cá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

196

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

197

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

198

Việc truy xuất

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

4791 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

4792 đề 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

4793 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

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

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

4795

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

199

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

4796

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

4785, 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

4798

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 ____5200. 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

200 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 ____11965; . 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 trở nên 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 sau _____11965 là bắt buộc để đảm bảo rằng thứ gì đó như _____030, trong đó phần mở rộng chỉ bắt đầu bằng _____010, sẽ được 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

1939

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

1939, nhưng trả về chuỗi mới và số lần thay thế

tách chuỗi

Phương thức 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 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ó chức năng 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

470

Đô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

471

Hàm cấp mô-đun 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

472

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 nhận một giá trị thay thế, có thể là một chuỗi hoặc một hàm và chuỗi cần 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 pháp. Nó thay thế tên màu bằng từ

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

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

473

Phương thức này 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

474

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

475

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

4774 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

476

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

4788.

>>> 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

477

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 cuộc gọi, hàm được truyền một đối số cho 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ề nó

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

478

Khi sử dụng hàm 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 là một sai lầm. Nếu bạn đang so khớp một chuỗi cố định hoặc một lớp ký tự đơn và bạn không sử dụng bất kỳ tính năng nào như cờ, 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; . có vẻ như là chức năng để sử dụng cho việc này, nhưng hãy xem xét phương pháp. 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 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ể

Nói tóm lại, trước khi chuyển sang mô-đun, hãy xem xét liệu vấn đề của bạn có thể được giải quyết bằng phương thức 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 chỉ kiểm tra xem RE có khớp ở đầu chuỗi hay không trong khi sẽ quét về phía trước 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

299 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

479

Mặt khác, 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 và chỉ cần thêm

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

94 vào trước RE của mình. Chống lại sự cám dỗ này và sử dụng 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 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, vì vậy công cụ biểu thức chính quy phải truy ngược từng ký tự cho đến khi tìm thấy kết quả khớp cho

>>> m = p.match['tempo']
>>> 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

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

03 khớp đầ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ờ 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

1944 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 khó đọ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

42,

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

217 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

Phản hồi

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

Các hàm Regex trong Python

Xây dựng Regex trong Python

Regex trong Python - Build by set

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

Các trận đấu biểu diễn

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

Cờ tổng hợp

Thêm sức mạnh mẫu

Thêm siêu ký tự

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

Phản hồi

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề