programming python

Được xây dựng lại bằng Python?

Trong hướng dẫn này, bạn sẽ khám phá các biểu thức chính quy, còn được gọi là biểu thức chính quy, trong Python. Biểu thức chính quy là một chuỗi ký tự đặc biệt xác định mẫu cho chức năng khớp chuỗi phức tạp

Trước đó trong loạt bài này, trong phần hướng dẫn Dữ liệu chuỗi và ký tự trong Python, bạn đã học cách định nghĩa và thao tác với các đối tượng chuỗi. Từ đó, bạn đã biết một số cách để xác định xem hai chuỗi có khớp với nhau hay không

Bạn có thể kiểm tra xem hai chuỗi có bằng nhau hay không bằng toán tử

Bạn có thể kiểm tra xem một chuỗi có phải là chuỗi con của chuỗi khác hay không bằng toán tử hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

30 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Khớp chuỗi như thế này là một nhiệm vụ phổ biến trong lập trình và bạn có thể làm được nhiều việc với các toán tử chuỗi và các phương thức tích hợp. Tuy nhiên, đôi khi, bạn có thể cần các khả năng khớp mẫu phức tạp hơn

Trong hướng dẫn này, bạn sẽ học

Cách truy cập mô-đun
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
32, thực hiện đối sánh biểu thức chính quy trong Python

Cách sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 để khớp một mẫu với một chuỗi

Cách tạo mẫu khớp phức tạp với siêu ký tự regex

Buộc chặt dây an toàn của bạn. Cú pháp Regex mất một chút thời gian để làm quen. Nhưng một khi bạn cảm thấy thoải mái với nó, bạn sẽ thấy các biểu thức chính quy gần như không thể thiếu trong lập trình Python của mình

Tải xuống miễn phí. Nhận một chương mẫu từ Thủ thuật Python. Cuốn sách chỉ cho bạn các phương pháp hay nhất về Python với các ví dụ đơn giản mà bạn có thể áp dụng ngay lập tức để viết mã Pythonic + đẹp hơn

Regex trong Python và Công dụng của chúng

Hãy tưởng tượng bạn có một đối tượng chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34. Bây giờ, giả sử bạn cần viết mã Python để tìm xem liệu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34 có chứa chuỗi con

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36 hay không. Có ít nhất một vài cách để làm điều này. Bạn có thể sử dụng toán tử

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>>

>>> s = 'foo123bar'
>>> '123' in s
True

Nếu bạn không chỉ muốn biết liệu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36 có tồn tại trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34 hay không mà còn biết nó tồn tại ở đâu, thì bạn có thể sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

30 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

31. Mỗi trong số này trả về vị trí ký tự trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34 nơi chứa chuỗi con

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong các ví dụ này, việc đối sánh được thực hiện bằng cách so sánh đơn giản từng ký tự. Điều đó sẽ hoàn thành công việc trong nhiều trường hợp. Nhưng đôi khi, vấn đề phức tạp hơn thế

Ví dụ: thay vì tìm kiếm một chuỗi con cố định như

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36, giả sử bạn muốn xác định xem một chuỗi có chứa ba ký tự chữ số thập phân liên tiếp bất kỳ hay không, như trong các chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

44,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

45,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

46 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

So sánh nhân vật nghiêm ngặt sẽ không cắt nó ở đây. Đây là nơi mà các biểu thức chính quy trong Python đến để giải cứu

Loại bỏ các quảng cáo

Lịch sử [rất ngắn gọn] của biểu thức chính quy

Năm 1951, nhà toán học Stephen Cole Kleene đã mô tả khái niệm ngôn ngữ chính quy, một ngôn ngữ có thể nhận ra bởi một máy tự động hữu hạn và có thể diễn đạt chính thức bằng cách sử dụng các biểu thức chính quy. Vào giữa những năm 1960, nhà tiên phong về khoa học máy tính Ken Thompson, một trong những nhà thiết kế ban đầu của Unix, đã triển khai khớp mẫu trong trình soạn thảo văn bản QED bằng cách sử dụng ký hiệu của Kleene.

Kể từ đó, biểu thức chính quy đã xuất hiện trong nhiều ngôn ngữ lập trình, trình soạn thảo và các công cụ khác như một phương tiện để xác định xem một chuỗi có khớp với một mẫu đã chỉ định hay không. Python, Java và Perl đều hỗ trợ chức năng regex, cũng như hầu hết các công cụ Unix và nhiều trình soạn thảo văn bản

Mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chức năng Regex trong Python nằm trong một mô-đun có tên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32. Mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 chứa nhiều hàm và phương thức hữu ích, hầu hết các hàm này bạn sẽ tìm hiểu trong phần hướng dẫn tiếp theo của loạt bài này

Hiện tại, bạn sẽ tập trung chủ yếu vào một chức năng,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Quét một chuỗi để tìm đối sánh regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

52 quét ________ 054 đang tìm kiếm vị trí đầu tiên mà mẫu ________ 055 khớp. Nếu tìm thấy kết quả khớp, thì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 trả về một đối tượng khớp. Nếu không, nó sẽ trả về

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 lấy đối số thứ ba tùy chọn

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

59 mà bạn sẽ tìm hiểu ở phần cuối của hướng dẫn này

Cách nhập

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

61 nằm trong mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 nên bạn cần nhập nó trước khi có thể sử dụng nó. Một cách để làm điều này là nhập toàn bộ mô-đun và sau đó sử dụng tên mô-đun làm tiền tố khi gọi hàm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ngoài ra, bạn có thể nhập chức năng từ mô-đun theo tên và sau đó tham chiếu đến nó mà không cần tiền tố tên mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bạn sẽ luôn cần nhập

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 bằng cách này hay cách khác trước khi có thể sử dụng nó

Các ví dụ trong phần còn lại của hướng dẫn này sẽ sử dụng cách tiếp cận đầu tiên được hiển thị—nhập mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 và sau đó tham chiếu đến hàm với tiền tố tên mô-đun.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33. Để cho ngắn gọn, câu lệnh

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

66 thường sẽ được bỏ qua, nhưng hãy nhớ rằng nó luôn cần thiết

Để biết thêm thông tin về cách nhập từ các mô-đun và gói, hãy xem Mô-đun và gói Python—Giới thiệu

Ví dụ khớp mẫu đầu tiên

Bây giờ bạn đã biết cách truy cập vào

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33, bạn có thể dùng thử

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây, mẫu tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

69 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

54 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34. Đối tượng khớp trả về xuất hiện trên dòng 7. Các đối tượng khớp chứa nhiều thông tin hữu ích mà bạn sẽ sớm khám phá

Hiện tại, điểm quan trọng là trên thực tế,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 đã trả về một đối tượng khớp chứ không phải

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

57. Điều đó cho bạn biết rằng nó đã tìm thấy một trận đấu. Nói cách khác, mẫu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 được chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

69 có mặt trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Một đối tượng khớp là , vì vậy bạn có thể sử dụng nó trong ngữ cảnh Boolean giống như một câu lệnh có điều kiện

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trình thông dịch hiển thị đối tượng khớp là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

77. Điều này chứa một số thông tin hữu ích

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

78 cho biết phần của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

54 mà trận đấu được tìm thấy. Điều này có nghĩa là điều tương tự như nó sẽ xảy ra trong

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ này, trận đấu bắt đầu ở vị trí ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

80 và kéo dài đến nhưng không bao gồm vị trí

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

82 cho biết ký tự nào từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

54 khớp

Đây là một khởi đầu tốt. Nhưng trong trường hợp này, mẫu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 chỉ là chuỗi đơn giản

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36. So khớp mẫu ở đây vẫn chỉ là so sánh từng ký tự, khá giống với các ví dụ về toán tử

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

29 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

30 đã trình bày trước đó. Đối tượng phù hợp cho bạn biết một cách hữu ích rằng các ký tự phù hợp là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36, nhưng đó không phải là điều tiết lộ nhiều vì đó chính xác là những ký tự bạn đã tìm kiếm

Bạn chỉ đang nóng lên

Loại bỏ các quảng cáo

Các ký tự Regex trong Python

Sức mạnh thực sự của khớp regex trong Python xuất hiện khi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 chứa các ký tự đặc biệt được gọi là siêu ký tự. Chúng có một ý nghĩa duy nhất đối với công cụ khớp regex và nâng cao đáng kể khả năng tìm kiếm

Xét lại bài toán làm thế nào để xác định xem một xâu có chứa ba ký tự chữ số thập phân liên tiếp bất kỳ hay không

Trong biểu thức chính quy, một tập hợp các ký tự được chỉ định trong ngoặc vuông [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

90] tạo thành một lớp ký tự. Trình tự siêu ký tự này khớp với bất kỳ ký tự đơn nào trong lớp, như minh họa trong ví dụ sau

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

91 khớp với bất kỳ ký tự chữ số thập phân nào—bất kỳ ký tự nào trong khoảng từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

92 đến

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

93, bao gồm. Biểu thức đầy đủ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

94 khớp với bất kỳ chuỗi ba ký tự chữ số thập phân nào. Trong trường hợp này, ________ 034 khớp vì nó chứa ba ký tự chữ số thập phân liên tiếp, ________ 036

Các chuỗi này cũng phù hợp

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Mặt khác, một chuỗi không chứa ba chữ số liên tiếp sẽ không khớp

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Với biểu thức chính quy trong Python, bạn có thể xác định các mẫu trong chuỗi mà bạn không thể tìm thấy bằng toán tử

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

29 hoặc bằng các phương thức chuỗi

Hãy xem một siêu ký tự regex khác. Siêu ký tự dấu chấm [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98] khớp với bất kỳ ký tự nào ngoại trừ ký tự xuống dòng, do đó, ký tự này hoạt động giống như một ký tự đại diện

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ đầu tiên, regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

99 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

36 vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

501 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

502 khớp theo nghĩa đen và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

504. Ở đây, về cơ bản, bạn đang hỏi, "Có phải

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34 chứa một

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

501, sau đó là bất kỳ ký tự nào [ngoại trừ một dòng mới], sau đó là một

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

502?"

Những ví dụ này cung cấp một minh họa nhanh về sức mạnh của siêu ký tự regex. Lớp ký tự và dấu chấm chỉ là hai trong số các siêu ký tự được mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 hỗ trợ. Chúng còn nhiều nữa. Tiếp theo, bạn sẽ khám phá chúng đầy đủ

Siêu ký tự được Mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 hỗ trợ

Bảng dưới đây tóm tắt ngắn gọn tất cả các siêu ký tự được mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 hỗ trợ. Một số nhân vật phục vụ nhiều hơn một mục đích

Ý nghĩa của [các] ký tự_______098Khớp với bất kỳ ký tự đơn nào ngoại trừ dòng mới

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514∙ Neo một khớp ở đầu chuỗi
∙ Bổ sung cho một lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515Neo một khớp ở cuối chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516Không khớp hoặc nhiều hơn
∙ Specifies the non-greedy versions of

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517, and

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518
∙ Introduces a lookahead or lookbehind assertion
∙ Creates a named group

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

522Matches an explicitly specified number of repetitions

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

523∙ Escapes a metacharacter of its special meaning
∙ Introduces a special character class
∙ Introduces a grouping backreference

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

90Specifies a character class

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

525Designates alternation

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

526Creates a group

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

527

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

528

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

529

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

530Designate a specialized group

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

531Creates a named group

Điều này có vẻ giống như một lượng thông tin quá lớn, nhưng Các phần sau đây sẽ xem xét chi tiết từng thông tin này

Trình phân tích cú pháp regex coi bất kỳ ký tự nào không được liệt kê ở trên là một ký tự bình thường chỉ khớp với chính nó. Ví dụ, trong hình trên, bạn đã thấy điều này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, về mặt kỹ thuật,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

69 là một biểu thức chính quy, nhưng nó không phải là biểu thức chính quy thú vị vì nó không chứa bất kỳ ký tự đại diện nào. Nó chỉ khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Mọi thứ trở nên thú vị hơn nhiều khi bạn kết hợp các siêu ký tự. Các phần sau đây giải thích chi tiết cách bạn có thể sử dụng từng siêu ký tự hoặc trình tự siêu ký tự để nâng cao chức năng khớp mẫu

Loại bỏ các quảng cáo

Siêu ký tự phù hợp với một ký tự duy nhất

Các chuỗi siêu ký tự trong phần này cố khớp một ký tự đơn từ chuỗi tìm kiếm. Khi trình phân tích cú pháp regex gặp một trong các chuỗi siêu ký tự này, một kết quả khớp sẽ xảy ra nếu ký tự ở vị trí phân tích cú pháp hiện tại khớp với mô tả mà chuỗi mô tả

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chỉ định một bộ ký tự cụ thể để khớp

Các ký tự nằm trong dấu ngoặc vuông [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

90] đại diện cho một lớp ký tự—một tập hợp các ký tự được liệt kê để so khớp từ. Chuỗi siêu ký tự của lớp ký tự sẽ khớp với bất kỳ ký tự đơn nào có trong lớp

Bạn có thể liệt kê các ký tự riêng lẻ như thế này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

536 khớp với bất kỳ ký tự đơn lẻ nào của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

538,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

539 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

540. Trong ví dụ, regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

541 khớp với cả

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543 [và cũng sẽ khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

544 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545]

Một lớp ký tự cũng có thể chứa một dải ký tự được phân tách bằng dấu gạch nối [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

546], trong trường hợp đó, nó khớp với bất kỳ ký tự đơn nào trong dải đó. Ví dụ:

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

547 khớp với bất kỳ ký tự chữ cái viết thường nào giữa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

540, bao gồm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

551 khớp với một chuỗi gồm hai chữ số. Phần đầu tiên của chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

44 phù hợp là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

553

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

554 khớp với bất kỳ ký tự chữ số thập lục phân nào

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

554 khớp với ký tự chữ số thập lục phân đầu tiên trong chuỗi tìm kiếm,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537

Ghi chú. Trong các ví dụ trên, giá trị trả về luôn là giá trị khớp ngoài cùng bên trái có thể.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 quét chuỗi tìm kiếm từ trái sang phải và ngay khi nó tìm thấy kết quả khớp cho

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55, nó sẽ dừng quét và trả về kết quả khớp

Bạn có thể bổ sung cho một lớp ký tự bằng cách chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 là ký tự đầu tiên, trong trường hợp đó, nó khớp với bất kỳ ký tự nào không có trong bộ. Trong ví dụ sau,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây, đối tượng khớp chỉ ra rằng ký tự đầu tiên trong chuỗi không phải là chữ số là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

561

Nếu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 xuất hiện trong một lớp ký tự nhưng không phải là ký tự đầu tiên, thì ký tự đó không có ý nghĩa đặc biệt và khớp với ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

563 theo nghĩa đen

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Như bạn đã thấy, bạn có thể chỉ định một dãy ký tự trong một lớp ký tự bằng cách tách các ký tự bằng dấu gạch nối. Điều gì sẽ xảy ra nếu bạn muốn lớp ký tự bao gồm một ký tự gạch nối theo nghĩa đen?

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Nếu bạn muốn bao gồm một chữ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

565 trong một lớp ký tự, thì bạn có thể đặt nó làm ký tự đầu tiên hoặc thoát nó bằng dấu gạch chéo ngược

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Các siêu ký tự regex khác mất đi ý nghĩa đặc biệt của chúng bên trong một lớp ký tự

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Như bạn đã thấy trong bảng trên,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 có ý nghĩa đặc biệt trong biểu thức chính quy trong Python. Chúng chỉ định sự lặp lại mà bạn sẽ sớm tìm hiểu thêm. Nhưng trong ví dụ này, chúng ở trong một lớp ký tự, vì vậy chúng khớp với nhau theo nghĩa đen

chấm [______098]

Chỉ định một ký tự đại diện

Siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 khớp với bất kỳ ký tự đơn nào ngoại trừ một dòng mới

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Là một biểu thức chính quy, về cơ bản,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

570 có nghĩa là các ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571, sau đó là bất kỳ ký tự nào ngoại trừ dòng mới, sau đó là các ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542. Chuỗi đầu tiên hiển thị ở trên,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

573, khớp với hóa đơn vì ký tự phụ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

575

Chuỗi thứ hai và thứ ba không khớp. Trong trường hợp cuối cùng, mặc dù có một ký tự giữa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542, nhưng đó là một dòng mới và theo mặc định, siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 không khớp với một dòng mới. Tuy nhiên, có một cách để buộc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 khớp với một dòng mới mà bạn sẽ tìm hiểu ở phần cuối của hướng dẫn này

______3580
______3581

Khớp dựa trên việc một ký tự có phải là ký tự từ hay không

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580 khớp với bất kỳ ký tự chữ và số nào. Các ký tự của từ là chữ hoa và chữ thường, chữ số và ký tự gạch dưới [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

583], do đó, về cơ bản,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580 là viết tắt của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

585

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, ký tự từ đầu tiên trong chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

586 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

581 thì ngược lại. Nó khớp với bất kỳ ký tự không phải từ nào và tương đương với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

589

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây, ký tự không phải từ đầu tiên trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

590 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

591

______3592
______3593

Khớp dựa trên việc một ký tự có phải là chữ số thập phân hay không

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592 khớp với bất kỳ ký tự chữ số thập phân nào.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

593 thì ngược lại. Nó khớp với bất kỳ ký tự nào không phải là chữ số thập phân

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592 về cơ bản tương đương với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

91 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

560

______3600
______3601

Khớp dựa trên việc một ký tự có đại diện cho khoảng trắng hay không

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Lưu ý rằng, không giống như ký tự đại diện dấu chấm,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600 không khớp với ký tự xuống dòng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601 ngược lại với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600. Nó khớp với bất kỳ ký tự nào không phải là khoảng trắng

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Một lần nữa,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601 coi một dòng mới là khoảng trắng. Trong ví dụ trên, ký tự không phải khoảng trắng đầu tiên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

561

Chuỗi lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

581,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

593,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601 cũng có thể xuất hiện bên trong lớp ký tự ngoặc vuông

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

615 khớp với bất kỳ ký tự chữ số, từ hoặc khoảng trắng nào. Và vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580 bao gồm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592, nên cùng một lớp ký tự cũng có thể được biểu thị ngắn hơn một chút là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

618

Loại bỏ các quảng cáo

Thoát khỏi siêu ký tự

Đôi khi, bạn sẽ muốn đưa một siêu ký tự vào biểu thức chính quy của mình, ngoại trừ việc bạn không muốn nó mang ý nghĩa đặc biệt của nó. Thay vào đó, bạn sẽ muốn nó thể hiện chính nó dưới dạng ký tự chữ

dấu gạch chéo ngược [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

523]

Loại bỏ ý nghĩa đặc biệt của một siêu ký tự

Như bạn vừa thấy, ký tự gạch chéo ngược có thể giới thiệu các lớp ký tự đặc biệt như từ, chữ số và khoảng trắng. Ngoài ra còn có các chuỗi siêu ký tự đặc biệt được gọi là ký tự neo bắt đầu bằng dấu gạch chéo ngược mà bạn sẽ tìm hiểu bên dưới

Khi nó không phục vụ một trong hai mục đích này, dấu gạch chéo ngược sẽ thoát khỏi các siêu ký tự. Một siêu ký tự đứng trước dấu gạch chéo ngược sẽ mất ý nghĩa đặc biệt của nó và thay vào đó khớp với ký tự chữ. Xem xét các ví dụ sau

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 trên dòng 1, dấu chấm [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98] hoạt động như một ký tự đại diện siêu ký tự, khớp với ký tự đầu tiên trong chuỗi [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

561]. Ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 trên dòng 4 được thoát bằng dấu gạch chéo ngược, vì vậy đây không phải là ký tự đại diện. Nó được hiểu theo nghĩa đen và khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

625 tại chỉ mục

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

80 của chuỗi tìm kiếm

Sử dụng dấu gạch chéo ngược để thoát có thể trở nên lộn xộn. Giả sử bạn có một chuỗi chứa một dấu gạch chéo ngược

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bây giờ, giả sử bạn muốn tạo một

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 khớp với dấu gạch chéo ngược giữa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542. Bản thân dấu gạch chéo ngược là một ký tự đặc biệt trong biểu thức chính quy, vì vậy để chỉ định dấu gạch chéo ngược theo nghĩa đen, bạn cần thoát dấu gạch chéo ngược đó bằng một dấu gạch chéo ngược khác. Nếu đó là trường hợp đó, thì những điều sau đây sẽ hoạt động

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Không hẳn. Đây là những gì bạn nhận được nếu bạn thử nó

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ối. Chuyện gì đã xảy ra thế?

Vấn đề ở đây là việc thoát dấu gạch chéo ngược xảy ra hai lần, lần đầu tiên bởi trình thông dịch Python trên chuỗi ký tự và sau đó một lần nữa bởi trình phân tích cú pháp biểu thức chính quy trên biểu thức chính quy mà nó nhận được

Đây là chuỗi sự kiện

Trình thông dịch Python là trình thông dịch đầu tiên xử lý chuỗi ký tự
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
630. Nó diễn giải rằng dưới dạng dấu gạch chéo ngược đã thoát và chỉ chuyển một dấu gạch chéo ngược duy nhất tới
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
33
Trình phân tích cú pháp biểu thức chính quy chỉ nhận được một dấu gạch chéo ngược duy nhất, đây không phải là biểu thức chính quy có ý nghĩa, do đó xảy ra lỗi lộn xộn

Có hai cách xung quanh điều này. Đầu tiên, bạn có thể thoát cả hai dấu gạch chéo ngược trong chuỗi ký tự gốc

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Làm như vậy gây ra những điều sau đây xảy ra

Trình thông dịch xem
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
632 như một cặp dấu gạch chéo ngược đã thoát. Nó giảm mỗi cặp thành một dấu gạch chéo ngược và chuyển
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
630 tới trình phân tích cú pháp regex
Sau đó, trình phân tích cú pháp regex xem
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
634 là một dấu gạch chéo ngược đã thoát. Là một
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
55, khớp với một ký tự gạch chéo ngược. Bạn có thể thấy từ đối tượng khớp rằng nó khớp với dấu gạch chéo ngược ở chỉ mục
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
80 trong
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
34 như dự định. Nó cồng kềnh, nhưng nó hoạt động

Cách thứ hai, và có lẽ sạch hơn, để xử lý việc này là chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 bằng cách sử dụng chuỗi thô

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điều này ngăn chặn việc thoát ở cấp độ thông dịch viên. Chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

630 được chuyển không thay đổi tới trình phân tích cú pháp regex, trình phân tích cú pháp này lại thấy một dấu gạch chéo ngược đã thoát như mong muốn

Bạn nên sử dụng một chuỗi thô để chỉ định biểu thức chính quy trong Python bất cứ khi nào nó chứa dấu gạch chéo ngược

Loại bỏ các quảng cáo

mỏ neo

Các neo là các đối sánh có độ rộng bằng không. Chúng không khớp với bất kỳ ký tự thực tế nào trong chuỗi tìm kiếm và chúng không sử dụng bất kỳ chuỗi tìm kiếm nào trong quá trình phân tích cú pháp. Thay vào đó, một neo chỉ ra một vị trí cụ thể trong chuỗi tìm kiếm nơi phải xảy ra kết quả khớp

______3514
______3641

Neo một trận đấu vào đầu của
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
54

Khi trình phân tích cú pháp regex gặp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641, vị trí hiện tại của trình phân tích cú pháp phải ở đầu chuỗi tìm kiếm để nó tìm thấy kết quả khớp

Nói cách khác, regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

645 quy định rằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 phải có mặt không chỉ ở bất kỳ vị trí cũ nào trong chuỗi tìm kiếm mà còn ở đầu

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 hoạt động tương tự

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 hoạt động hơi khác nhau trong chế độ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650. Bạn sẽ tìm hiểu thêm về chế độ ________ 3650 bên dưới trong phần về

______3515
______3653

Neo một trận đấu đến cuối
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
54

Khi trình phân tích cú pháp regex gặp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653, vị trí hiện tại của trình phân tích cú pháp phải ở cuối chuỗi tìm kiếm để tìm kết quả khớp. Bất cứ điều gì đứng trước

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653 phải tạo thành phần cuối của chuỗi tìm kiếm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp đặc biệt,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 [nhưng không phải

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653] cũng khớp ngay trước một dòng mới ở cuối chuỗi tìm kiếm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ này, về mặt kỹ thuật,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 không nằm ở cuối chuỗi tìm kiếm vì nó được theo sau bởi một ký tự xuống dòng bổ sung. Nhưng trình phân tích cú pháp regex vẫn cho phép nó trượt và gọi nó là khớp. Ngoại lệ này không áp dụng cho

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653 hoạt động hơi khác nhau trong chế độ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650. Xem phần bên dưới để biết thêm thông tin về chế độ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667

Neo kết quả khớp với ranh giới từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667 khẳng định rằng vị trí hiện tại của trình phân tích cú pháp regex phải ở đầu hoặc cuối của một từ. Một từ bao gồm một dãy ký tự chữ và số hoặc dấu gạch dưới [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

585], giống như đối với lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong các ví dụ trên, một sự trùng khớp xảy ra ở dòng 1 và 3 vì có một ranh giới từ ở đầu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542. Đây không phải là trường hợp ở dòng 6, vì vậy trận đấu không thành công ở đó

Tương tự, có các kết quả trùng khớp ở dòng 9 và 11 vì ranh giới từ tồn tại ở cuối

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571, nhưng không phải ở dòng 14

Sử dụng dấu neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667 ở cả hai đầu của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 sẽ khiến nó khớp với nhau khi nó xuất hiện trong chuỗi tìm kiếm dưới dạng toàn bộ từ

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Đây là một trường hợp khác trong đó trả tiền để chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 làm chuỗi thô, như các ví dụ trên đã thực hiện

Bởi vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

676 là một chuỗi thoát cho cả ký tự chuỗi và biểu thức chính quy trong Python, nên mỗi lần sử dụng ở trên sẽ cần phải được thoát gấp đôi dưới dạng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

677 nếu bạn không sử dụng chuỗi thô. Đó sẽ không phải là ngày tận thế, nhưng các chuỗi thô sẽ gọn gàng hơn

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

678

Neo một kết quả phù hợp với một vị trí không phải là ranh giới từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

678 làm ngược lại với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667. Nó khẳng định rằng vị trí hiện tại của trình phân tích cú pháp regex không được ở đầu hoặc cuối của một từ

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, một kết quả trùng khớp xảy ra ở dòng 7 vì không có ranh giới từ nào tồn tại ở đầu hoặc cuối của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 trong chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

682

Loại bỏ các quảng cáo

định lượng

Một siêu ký tự định lượng ngay sau một phần của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 và cho biết phần đó phải xuất hiện bao nhiêu lần để khớp thành công

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516

Khớp với 0 hoặc nhiều lần lặp lại của biểu thức chính quy trước đó

Ví dụ:

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

685 khớp với 0 hoặc nhiều ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537. Điều đó có nghĩa là nó sẽ khớp với một chuỗi rỗng,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

688,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

689, v.v.

Hãy xem xét những ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trên dòng 1, không có ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690 nào giữa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542. Trên dòng 3 có một và trên dòng 5 có hai. Trình tự siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

693 phù hợp trong cả ba trường hợp

Đôi khi, bạn có thể gặp biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

694 trong chương trình Python. Điều này khớp với 0 hoặc nhiều lần xuất hiện của bất kỳ ký tự nào. Nói cách khác, về cơ bản, nó khớp với bất kỳ chuỗi ký tự nào cho đến ngắt dòng. [Hãy nhớ rằng siêu ký tự đại diện

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

98 không khớp với một dòng mới. ]

Trong ví dụ này,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

694 khớp với mọi thứ trong khoảng từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 đến

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bạn có nhận thấy thông tin

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

699 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

200 có trong đối tượng khớp không?

Cho đến bây giờ, biểu thức chính quy trong các ví dụ mà bạn đã xem đã chỉ định các đối sánh có độ dài có thể dự đoán được. Sau khi bạn bắt đầu sử dụng các bộ định lượng như

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516, số lượng ký tự khớp có thể thay đổi khá nhiều và thông tin trong đối tượng khớp trở nên hữu ích hơn

Bạn sẽ tìm hiểu thêm về cách truy cập thông tin được lưu trữ trong đối tượng khớp trong phần hướng dẫn tiếp theo của loạt bài này

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517

Khớp với một hoặc nhiều lần lặp lại của biểu thức chính quy trước đó

Điều này tương tự với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516, nhưng biểu thức chính quy được định lượng phải xảy ra ít nhất một lần

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Hãy nhớ ở trên rằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

204 khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205 vì ký tự phụ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 cho phép không có sự xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690. Mặt khác, siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 yêu cầu ít nhất một lần xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690. Điều đó có nghĩa là không có kết quả phù hợp ở dòng 1 trong trường hợp này

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518

Khớp với 0 hoặc một lần lặp lại của biểu thức chính quy trước đó

Một lần nữa, điều này tương tự với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517, nhưng trong trường hợp này chỉ có sự trùng khớp nếu biểu thức chính quy trước đó xảy ra một lần hoặc hoàn toàn không xảy ra

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ này, có các trận đấu trên dòng 1 và 3. Nhưng ở dòng 5, nơi có hai ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690, kết quả khớp không thành công

Dưới đây là một số ví dụ khác cho thấy việc sử dụng cả ba siêu ký tự định lượng

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Lần này, biểu thức chính quy được định lượng là lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

214 thay vì ký tự đơn giản

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690

______4216
______4217
______4218

Các phiên bản không tham lam [hoặc lười biếng] của các bộ định lượng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518

Khi được sử dụng một mình, các siêu ký tự định lượng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518 đều tham lam, nghĩa là chúng tạo ra kết quả khớp dài nhất có thể. Hãy xem xét ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

225 có nghĩa là

Một ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

226

Khi đó bất kỳ dãy ký tự nào

Sau đó, một ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227

Nhưng ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227 nào?

Cái ngay sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Cái ngay sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

Cái ngay sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543

Vì siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 là tham lam nên nó chỉ ra kết quả khớp dài nhất có thể, bao gồm mọi thứ cho đến và bao gồm cả ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227 theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543. Bạn có thể thấy từ đối tượng khớp rằng đây là kết quả khớp được tạo ra

Thay vào đó, nếu bạn muốn kết quả phù hợp ngắn nhất có thể, thì hãy sử dụng chuỗi siêu ký tự không tham lam

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

216

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, trận đấu kết thúc với ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227 theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Ghi chú. Bạn có thể hoàn thành điều tương tự với regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

238, có nghĩa là

Một ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

226

Sau đó, bất kỳ chuỗi ký tự nào khác ngoài

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227

Sau đó, một ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227

Đây là tùy chọn duy nhất khả dụng với một số trình phân tích cú pháp cũ không hỗ trợ bộ định lượng chậm. Rất may, đó không phải là trường hợp của trình phân tích cú pháp regex trong mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 của Python

Cũng có các phiên bản lười biếng của bộ định lượng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Hai ví dụ đầu tiên ở dòng 1 và 3 tương tự như ví dụ hiển thị ở trên, chỉ sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

217 thay vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

216

Các ví dụ cuối cùng trên dòng 6 và 8 hơi khác một chút. Nói chung, siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518 khớp với 0 hoặc một lần xuất hiện của biểu thức chính quy trước đó. Phiên bản tham lam,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

518, khớp với một lần xuất hiện, do đó,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

251 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 theo sau bởi một

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 duy nhất. Phiên bản không tham lam,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

218, khớp với 0 lần xuất hiện, vì vậy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

255 chỉ khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

257

Khớp chính xác các lần lặp lại
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
258 của biểu thức chính quy trước đó

Điều này tương tự với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

516 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517, nhưng nó chỉ định chính xác số lần regex trước đó phải xuất hiện để khớp thành công

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

261 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

575, theo sau chính xác là ba trường hợp của ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690, tiếp theo là một

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

575 khác. Khớp không thành công khi có ít hơn hoặc nhiều hơn ba dấu gạch ngang giữa các ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

575

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

266

Khớp với bất kỳ số lần lặp lại nào của biểu thức chính quy trước đó từ
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
258 đến
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
268, bao gồm

Trong ví dụ sau,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 được định lượng là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

270. Khớp thành công khi có hai, ba hoặc bốn dấu gạch ngang giữa các ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

575 nhưng nếu không thì không thành công

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bỏ qua

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258 ngụ ý giới hạn dưới của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

273 và bỏ qua

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 ngụ ý giới hạn trên không giới hạn

Biểu thức chính quy KhớpGiống với_______4275Bất kỳ số lần lặp lại nào của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 nhỏ hơn hoặc bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

278

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

279Bất kỳ số lần lặp lại nào của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 lớn hơn hoặc bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

282

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

283bất kỳ số lần lặp lại nào của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

285

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

286

Nếu bạn bỏ qua tất cả

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 và dấu phẩy, thì dấu ngoặc nhọn không còn hoạt động như siêu ký tự.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

522 chỉ khớp với chuỗi ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

290

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trên thực tế, để có bất kỳ ý nghĩa đặc biệt nào, một dãy có dấu ngoặc nhọn phải phù hợp với một trong các mẫu sau trong đó

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 là các số nguyên không âm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

266

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

294

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

295

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

296

Mặt khác, nó phù hợp theo nghĩa đen

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở phần sau của hướng dẫn này, khi bạn tìm hiểu về cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

297, bạn sẽ thấy cách bạn có thể xác nhận điều này

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

298

Phiên bản không tham lam [lười biếng] của
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
266

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

266 sẽ khớp với nhiều ký tự nhất có thể và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

298 sẽ khớp với càng ít ký tự càng tốt

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, _______ 5202 tạo ra kết quả khớp dài nhất có thể, vì vậy nó khớp với năm ký tự ________ 3537.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

204 tạo ra kết quả khớp ngắn nhất, vì vậy nó khớp với ba

Loại bỏ các quảng cáo

Nhóm cấu trúc và tham chiếu ngược

Cấu trúc nhóm chia nhỏ biểu thức chính quy trong Python thành các biểu thức con hoặc nhóm. Điều này phục vụ hai mục đích

nhóm. Một nhóm đại diện cho một thực thể cú pháp duy nhất. Các siêu ký tự bổ sung áp dụng cho toàn bộ nhóm dưới dạng một đơn vị
Chụp. Một số cấu trúc nhóm cũng nắm bắt phần của chuỗi tìm kiếm khớp với biểu thức con trong nhóm. Bạn có thể truy xuất các trận đấu đã chụp sau này thông qua một số cơ chế khác nhau

Dưới đây là cách thức hoạt động của nhóm và chụp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205

Định nghĩa một biểu thức con hoặc nhóm

Đây là cấu trúc nhóm cơ bản nhất. Biểu thức chính quy trong ngoặc đơn chỉ khớp với nội dung của dấu ngoặc đơn

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Là một biểu thức chính quy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

206 khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542, giống như biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

208 sẽ không có dấu ngoặc đơn

Đối xử với một nhóm như một đơn vị

Một siêu ký tự định lượng theo sau một nhóm hoạt động trên toàn bộ biểu thức con được chỉ định trong nhóm dưới dạng một đơn vị

Chẳng hạn, ví dụ sau khớp với một hoặc nhiều lần xuất hiện của chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Đây là bảng phân tích về sự khác biệt giữa hai biểu thức chính có và không có dấu ngoặc đơn nhóm

RegexInterpretationMatchesVí dụ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

210Siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 chỉ áp dụng cho ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

538.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

213 theo sau là một hoặc nhiều lần xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

538

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

216
____5217

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

218Siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

517 áp dụng cho toàn bộ chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542. Một hoặc nhiều lần xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

223

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

224

Bây giờ hãy xem một ví dụ phức tạp hơn. Regex

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

225 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

226 đến

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

227 lần xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543, tùy ý theo sau bởi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

230

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ví dụ sau đây cho thấy bạn có thể lồng các dấu ngoặc đơn vào nhóm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

231 khá phức tạp, vì vậy hãy chia nó thành các phần nhỏ hơn

RegexMatches

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

232

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 tùy ý theo sau bởi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

235Một hoặc nhiều lần xuất hiện ở trên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

236Ba ký tự chữ số thập phân

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

237Không hoặc một lần xuất hiện ở trên

Chuỗi tất cả lại với nhau và bạn nhận được. ít nhất một lần xuất hiện của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 tùy chọn theo sau bởi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542, tất cả tùy chọn theo sau bởi ba ký tự chữ số thập phân

Như bạn có thể thấy, bạn có thể xây dựng các biểu thức chính quy rất phức tạp trong Python bằng cách sử dụng nhóm các dấu ngoặc đơn

Chụp nhóm

Nhóm không phải là mục đích hữu ích duy nhất mà các cấu trúc nhóm phục vụ. Hầu hết [nhưng không hoàn toàn] cấu trúc nhóm cũng nắm bắt một phần của chuỗi tìm kiếm phù hợp với nhóm. Bạn có thể truy xuất phần đã chụp hoặc tham khảo phần đó sau theo nhiều cách khác nhau

Bạn có nhớ đối tượng khớp mà

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 trả về không? .

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

241 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

242

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

243

Trả về một bộ chứa tất cả các nhóm đã bắt được từ một đối sánh biểu thức chính quy

Hãy xem xét ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Mỗi trong số ba biểu thức

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

244 khớp với một chuỗi các ký tự từ. Regex đầy đủ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

245 ngắt chuỗi tìm kiếm thành ba mã thông báo được phân tách bằng dấu phẩy

Vì các biểu thức

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

244 sử dụng dấu ngoặc đơn nhóm nên các mã thông báo phù hợp tương ứng được ghi lại. Để truy cập các trận đấu đã bắt, bạn có thể sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

241, trả về một chứa tất cả các trận đấu đã bắt theo thứ tự

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Lưu ý rằng bộ dữ liệu chứa mã thông báo nhưng không chứa dấu phẩy xuất hiện trong chuỗi tìm kiếm. Đó là bởi vì các ký tự từ tạo nên mã thông báo nằm trong dấu ngoặc đơn nhóm nhưng dấu phẩy thì không. Dấu phẩy mà bạn thấy giữa các mã thông báo được trả về là dấu phân cách tiêu chuẩn được sử dụng để phân tách các giá trị trong một bộ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

248

Trả về một chuỗi chứa kết quả phù hợp đã bắt được
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
249____5250

Với một đối số,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

242 trả về một kết quả khớp đã bắt. Lưu ý rằng các đối số là dựa trên một, không dựa trên số không. Vì vậy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 đề cập đến trận đấu được bắt đầu tiên,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

253 đến trận đấu thứ hai, v.v.

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Vì việc đánh số các trận đấu được bắt là dựa trên một và không có bất kỳ nhóm nào được đánh số 0, nên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

254 có một ý nghĩa đặc biệt

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

254 trả về toàn bộ trận đấu và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

256 cũng làm như vậy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

257

Trả về một bộ chứa các kết quả khớp được chỉ định

Với nhiều đối số,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

242 trả về một bộ chứa các kết quả khớp được chỉ định theo thứ tự nhất định

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Đây chỉ là tốc ký thuận tiện. Thay vào đó, bạn có thể tự tạo bộ dữ liệu phù hợp

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Hai câu lệnh được hiển thị là tương đương về mặt chức năng

phản hồi

Bạn có thể khớp một nhóm đã bắt trước đó sau trong cùng một biểu thức chính quy bằng cách sử dụng một chuỗi siêu ký tự đặc biệt được gọi là tham chiếu ngược

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

259

Khớp với nội dung của một nhóm đã chụp trước đó

Trong một biểu thức chính quy trong Python, chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

259, trong đó

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

249 là một số nguyên từ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262 đến

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

263, khớp với nội dung của nhóm được chụp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

249

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

250

Đây là biểu thức chính quy khớp với một từ, theo sau là dấu phẩy, theo sau lại là cùng một từ

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ đầu tiên, ở dòng 3,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

244 khớp với phiên bản đầu tiên của chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 và lưu nó dưới dạng nhóm được bắt đầu tiên. Dấu phẩy phù hợp với nghĩa đen. Sau đó,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 là một phản hồi đối với nhóm được bắt đầu tiên và khớp lại với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571. Ví dụ thứ hai, ở dòng 9, giống hệt ngoại trừ việc thay vào đó,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

244 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

230

Ví dụ cuối cùng, ở dòng 15, không khớp vì phần đứng trước dấu phẩy không giống với phần đứng sau dấu phẩy, vì vậy tham chiếu ngược

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 không khớp

Ghi chú. Bất cứ khi nào bạn sử dụng biểu thức chính quy trong Python với tham chiếu ngược được đánh số, bạn nên chỉ định nó dưới dạng chuỗi thô. Nếu không, trình thông dịch có thể nhầm lẫn phản hồi ngược với giá trị bát phân

Hãy xem xét ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Regex ________ 5273 khớp với một chữ cái viết thường, theo sau là ________ 5274, theo sau là cùng một chữ cái viết thường. Chuỗi trong trường hợp này là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

275, chuỗi này phải khớp với. Nhưng trận đấu không thành công vì Python diễn giải sai tham chiếu ngược

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268 là ký tự có giá trị bát phân là một

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bạn sẽ đạt được kết quả khớp chính xác nếu bạn chỉ định biểu thức chính quy dưới dạng chuỗi thô

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Hãy nhớ cân nhắc sử dụng chuỗi thô bất cứ khi nào biểu thức chính quy của bạn bao gồm chuỗi siêu ký tự chứa dấu gạch chéo ngược

Các phản hồi được đánh số dựa trên một giống như các đối số của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

242. Chỉ có chín mươi chín nhóm được chụp đầu tiên có thể truy cập được bằng phản hồi. Trình thông dịch sẽ coi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

278 là ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

279, có giá trị bát phân là 100

Các cấu trúc nhóm khác

Trình tự siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205 được hiển thị ở trên là cách đơn giản nhất để thực hiện nhóm trong biểu thức chính quy trong Python. Phần tiếp theo giới thiệu cho bạn một số cấu trúc nhóm nâng cao cho phép bạn điều chỉnh thời gian và cách thức nhóm xảy ra

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

281

Tạo một nhóm đã được đặt tên

Trình tự siêu ký tự này tương tự như nhóm các dấu ngoặc đơn ở chỗ nó tạo ra một nhóm phù hợp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 có thể truy cập được thông qua đối tượng khớp hoặc tham chiếu ngược tiếp theo. Sự khác biệt trong trường hợp này là bạn tham chiếu nhóm phù hợp bằng ký hiệu đã cho

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

283 thay vì theo số của nó

Trước đó, bạn đã thấy ví dụ này với ba nhóm bị bắt được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

226 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điều sau đây thực sự làm điều tương tự ngoại trừ các nhóm có tên tượng trưng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

287,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

288 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

289

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bạn có thể tham khảo các nhóm bị bắt này bằng tên tượng trưng của chúng

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bạn vẫn có thể truy cập các nhóm có tên tượng trưng theo số nếu muốn

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Bất kỳ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

283 nào được chỉ định với cấu trúc này phải tuân thủ các quy tắc cho a và mỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

283 chỉ có thể xuất hiện một lần cho mỗi biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

292

Khớp với nội dung của một nhóm được đặt tên đã chụp trước đó

Chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

292 là một tham chiếu ngược, tương tự như

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

259, ngoại trừ việc nó đề cập đến một nhóm được đặt tên thay vì một nhóm được đánh số

Đây lại là ví dụ ở trên, sử dụng tham chiếu ngược được đánh số để khớp với một từ, theo sau là dấu phẩy, sau đó lại là cùng một từ

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Thay vào đó, đoạn mã sau thực hiện điều tương tự bằng cách sử dụng một nhóm được đặt tên và một tham chiếu ngược

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

295 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 và lưu nó thành một nhóm bị bắt có tên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

297. Một lần nữa, dấu phẩy phù hợp theo nghĩa đen. Sau đó,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

298 là một phản hồi đối với lần chụp được đặt tên và khớp lại với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Ghi chú. Dấu ngoặc nhọn [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601] được yêu cầu khoảng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

602 khi tạo một nhóm được đặt tên nhưng không phải khi đề cập đến nó sau này, bằng cách phản hồi hoặc bằng cách

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

242

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

604

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

605

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

606 tạo nhóm bị bắt. Nhưng phản hồi tương ứng là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

607____5608

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

609 không có dấu ngoặc nhọn

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

610

Tạo một nhóm không chụp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

610 giống như

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205 ở chỗ nó khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 đã chỉ định. Nhưng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

610 không ghi lại kết quả phù hợp để truy xuất sau này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ này, từ ở giữa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

615 nằm trong dấu ngoặc đơn không bắt giữ, do đó, nó bị thiếu trong bộ các nhóm đã bắt giữ. Nó không thể truy xuất được từ đối tượng khớp, cũng như không thể tham chiếu được bằng phản hồi

Tại sao bạn muốn xác định một nhóm nhưng không nắm bắt nó?

Hãy nhớ rằng trình phân tích cú pháp regex sẽ coi các dấu ngoặc đơn nhóm bên trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 là một đơn vị. Bạn có thể gặp trường hợp cần tính năng nhóm này, nhưng bạn không cần phải làm gì với giá trị sau này, vì vậy bạn không thực sự cần nắm bắt nó. Nếu bạn sử dụng nhóm không bắt giữ, thì bộ các nhóm đã bắt giữ sẽ không bị lộn xộn với các giá trị mà bạn không thực sự cần giữ lại

Ngoài ra, phải mất một thời gian và bộ nhớ để chụp một nhóm. Nếu mã thực hiện so khớp thực thi nhiều lần và bạn không nắm bắt các nhóm mà bạn sẽ không sử dụng sau này, thì bạn có thể thấy một chút lợi thế về hiệu suất

______5617
______5618

Chỉ định đối sánh có điều kiện

Một đối sánh có điều kiện đối sánh với một trong hai biểu thức chính quy được chỉ định tùy thuộc vào việc nhóm đã cho có tồn tại hay không

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

617 đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

620 nếu tồn tại một nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

249. Mặt khác, nó khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

622

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

618 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

620 nếu tồn tại một nhóm có tên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

283. Mặt khác, nó khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

622

Các đối sánh có điều kiện được minh họa rõ hơn bằng một ví dụ. Hãy xem xét regex này

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Dưới đây là các phần của biểu thức chính quy này được chia nhỏ với một số lời giải thích

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

627 chỉ ra rằng chuỗi tìm kiếm tùy ý bắt đầu bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628. Nếu đúng như vậy, thì các dấu ngoặc nhóm xung quanh

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

629 sẽ tạo ra một nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262. Nếu không, sẽ không có nhóm như vậy tồn tại

Phần tiếp theo,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

631, thực sự khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Cuối cùng,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

633 khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 nếu nhóm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262 tồn tại và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543 nếu không

Các khối mã sau minh họa việc sử dụng biểu thức chính quy trên trong một số đoạn mã Python khác nhau

ví dụ 1

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

637 bắt đầu bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628, vì vậy trình phân tích cú pháp tạo một nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262. Trận đấu có điều kiện sau đó là trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542, trận đấu này trận đấu

ví dụ 2

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 bắt đầu bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628, vì vậy trình phân tích cú pháp tạo một nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262. Trận đấu có điều kiện sau đó là trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542, không trận đấu

ví dụ 3

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205 không bắt đầu bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628, vì vậy không có nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262. Trận đấu có điều kiện sau đó là trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543, không trận đấu

Ví dụ 4

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

649 không bắt đầu bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628, vì vậy không có nhóm được đánh số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262. Trận đấu có điều kiện sau đó là trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543, trận đấu này trận đấu

Đây là một đối sánh có điều kiện khác bằng cách sử dụng nhóm được đặt tên thay vì nhóm được đánh số

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Regex này khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571, trước một ký tự không phải từ và theo sau là cùng một ký tự không phải từ hoặc chính chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Một lần nữa, hãy chia nó thành nhiều mảnh

RegexMatches

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514Phần đầu của chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

656Một ký tự không phải là từ, được ghi lại trong một nhóm có tên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

658Không hoặc một lần xuất hiện ở trên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

631Chuỗi ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

661Nội dung của nhóm có tên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657 nếu nó tồn tại hoặc chuỗi trống nếu nó không

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515Phần cuối của chuỗi

Nếu một ký tự không phải từ đứng trước

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571, thì trình phân tích cú pháp sẽ tạo một nhóm có tên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657 chứa ký tự đó. Kết quả khớp có điều kiện sau đó sẽ khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

620, là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667, lại cùng một ký tự. Điều đó có nghĩa là cùng một nhân vật cũng phải tuân theo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 để toàn bộ trận đấu thành công

Nếu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 không đứng trước một ký tự không phải từ, thì trình phân tích cú pháp sẽ không tạo nhóm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

622 là chuỗi rỗng, có nghĩa là không được có bất kỳ thứ gì theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 để toàn bộ trận đấu thành công. Vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 neo toàn bộ biểu thức chính quy, nên chuỗi phải chính xác bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571

Dưới đây là một số ví dụ về các tìm kiếm sử dụng biểu thức chính quy này trong mã Python

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trên dòng 1, chính nó là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571. Ở dòng 3 và 5, cùng một ký tự không phải từ đứng trước và theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571. Như đã quảng cáo, những trận đấu này thành công

Trong các trường hợp còn lại, các trận đấu không thành công

Biểu thức chính quy có điều kiện trong Python khá bí truyền và khó thực hiện. Nếu bạn từng tìm thấy lý do để sử dụng một lệnh, thì có lẽ bạn có thể hoàn thành cùng một mục tiêu với nhiều lệnh gọi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 riêng biệt và mã của bạn sẽ dễ đọc và hiểu hơn

Loại bỏ các quảng cáo

Xác nhận Lookahead và Lookbehind

Xác nhận nhìn trước và nhìn sau xác định thành công hay thất bại của đối sánh biểu thức chính quy trong Python dựa trên những gì ở ngay phía sau [bên trái] hoặc phía trước [bên phải] vị trí hiện tại của trình phân tích cú pháp trong chuỗi tìm kiếm

Giống như các anchor, các xác nhận lookahead và lookbehind là các xác nhận có độ rộng bằng 0, vì vậy chúng không sử dụng bất kỳ chuỗi tìm kiếm nào. Ngoài ra, mặc dù chúng chứa dấu ngoặc đơn và thực hiện nhóm, nhưng chúng không nắm bắt được những gì chúng khớp

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

679

Tạo ra một khẳng định nhìn về phía trước tích cực

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

679 khẳng định rằng những gì theo sau vị trí hiện tại của trình phân tích cú pháp regex phải khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

681

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

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

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

682 chỉ định rằng những gì theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 phải là một ký tự chữ cái viết thường. Trong trường hợp này, đó là ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252, vì vậy một kết quả khớp được tìm thấy

Mặt khác, trong ví dụ tiếp theo, lookahead không thành công. Ký tự tiếp theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

501, vì vậy không có kết quả khớp

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điểm độc đáo của giao diện tìm kiếm là phần của chuỗi tìm kiếm khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

681 không được sử dụng và nó không phải là một phần của đối tượng khớp được trả về

Hãy xem lại ví dụ đầu tiên

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trình phân tích cú pháp regex chỉ xem trước

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 nhưng chưa chuyển qua nó. Bạn có thể biết rằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 không được coi là một phần của đối sánh vì đối tượng khớp hiển thị

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

691

So sánh điều đó với một ví dụ tương tự sử dụng dấu ngoặc đơn nhóm mà không cần xem trước

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Lần này, regex tiêu thụ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 và nó trở thành một phần của trận đấu cuối cùng

Đây là một ví dụ khác minh họa cách nhìn về phía trước khác với biểu thức chính quy thông thường trong Python

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong lần tìm kiếm đầu tiên, trên dòng 1, trình phân tích cú pháp tiến hành như sau

Phần đầu tiên của biểu thức chính quy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

631, khớp và sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 từ chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205

Phần tiếp theo,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

682, là một giao diện phù hợp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252, nhưng trình phân tích cú pháp không vượt qua

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252

Cuối cùng,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

699 khớp với ký tự đơn tiếp theo có sẵn, đó là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252 và nắm bắt ký tự đó trong một nhóm có tên là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657

Cuộc gọi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

802 xác nhận rằng nhóm có tên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657 chứa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252

So sánh điều đó với tìm kiếm trên dòng 5, không chứa tìm kiếm phía trước

Như trong ví dụ đầu tiên, phần đầu tiên của biểu thức chính quy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

631, khớp và sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 từ chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

205

Phần tiếp theo,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

808, so khớp và sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252, và trình phân tích cú pháp sẽ vượt qua

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252

Cuối cùng,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

699 khớp với ký tự đơn tiếp theo có sẵn, hiện là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

802 xác nhận rằng, trong trường hợp này, nhóm có tên

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

657 chứa

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

816

Tạo một xác nhận nhìn trước tiêu cực

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

816 khẳng định rằng những gì theo sau vị trí hiện tại của trình phân tích cú pháp regex không được khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

681

Dưới đây là các ví dụ về cái nhìn tích cực mà bạn đã thấy trước đó, cùng với các ví dụ về cái nhìn tiêu cực của chúng

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Các xác nhận nhìn trước phủ định trên các dòng 3 và 8 quy định rằng những gì theo sau

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 không được là một ký tự chữ cái viết thường. Điều này không thành công ở dòng 3 nhưng thành công ở dòng 8. Điều này trái ngược với những gì đã xảy ra với các xác nhận nhìn trước tích cực tương ứng

Giống như với một cái nhìn tích cực, những gì phù hợp với một cái nhìn tiêu cực không phải là một phần của đối tượng so khớp được trả về và không được sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

820

Tạo ra một khẳng định về cái nhìn tích cực

________ 6820 khẳng định rằng những gì đứng trước vị trí hiện tại của trình phân tích cú pháp regex phải khớp với ________ 6822

Trong ví dụ sau, xác nhận lookbehind xác định rằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 phải đứng trước

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Đây là trường hợp ở đây, vì vậy trận đấu thành công. Như với các xác nhận nhìn trước, một phần của chuỗi tìm kiếm phù hợp với giao diện không trở thành một phần của kết quả khớp cuối cùng

Ví dụ tiếp theo không khớp vì giao diện yêu cầu

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

230 trước

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Có một hạn chế đối với các xác nhận nhìn sau không áp dụng cho các xác nhận nhìn trước.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

822 trong xác nhận nhìn lại phải chỉ định kết quả khớp có độ dài cố định

Ví dụ: điều sau đây không được phép vì độ dài của chuỗi khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

828 là không xác định

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Tuy nhiên, điều này không sao

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Mọi thứ khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

829 sẽ có độ dài cố định là ba, vì vậy,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

829 hợp lệ trong một xác nhận nhìn lại

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

831

Tạo một xác nhận lookbehind tiêu cực

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

831 khẳng định rằng những gì đứng trước vị trí hiện tại của trình phân tích cú pháp regex không được khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

822

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Như với khẳng định về cái nhìn tích cực,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

822 phải chỉ định một đối sánh có độ dài cố định

Loại bỏ các quảng cáo

Các siêu ký tự khác

Có một vài trình tự metacharacter để trang trải. Đây là những siêu ký tự đi lạc rõ ràng không thuộc bất kỳ danh mục nào đã được thảo luận

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

835

Chỉ định một nhận xét

Trình phân tích cú pháp regex bỏ qua mọi thứ có trong chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

835

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điều này cho phép bạn chỉ định tài liệu bên trong biểu thức chính quy trong Python, điều này có thể đặc biệt hữu ích nếu biểu thức chính quy đặc biệt dài

Thanh dọc, hoặc ống [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

525]

Chỉ định một tập hợp các lựa chọn thay thế để khớp

Một biểu thức có dạng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

838

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

262

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

840

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

226

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

842

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

268

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601 khớp với nhiều nhất một trong các biểu thức

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

838

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

846

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601 đã chỉ định

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Ở đây,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

848 sẽ khớp với bất kỳ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543 nào. Bạn có thể tách bất kỳ số lượng biểu thức chính nào bằng cách sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

525

Luân phiên không tham lam. Trình phân tích cú pháp regex xem xét các biểu thức được phân tách bằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

525 theo thứ tự từ trái sang phải và trả về kết quả khớp đầu tiên mà nó tìm thấy. Các biểu thức còn lại không được kiểm tra, ngay cả khi một trong số chúng sẽ tạo ra kết quả khớp dài hơn

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, mẫu được chỉ định trên dòng 6,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

854, sẽ khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

856. Kết quả trùng khớp được trả về là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 vì nó xuất hiện đầu tiên khi quét từ trái sang phải, mặc dù

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

856 sẽ là kết quả khớp dài hơn

Bạn có thể kết hợp xen kẽ, nhóm và bất kỳ siêu ký tự nào khác để đạt được bất kỳ mức độ phức tạp nào bạn cần. Trong ví dụ sau,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

859 có nghĩa là một chuỗi gồm một hoặc nhiều chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ tiếp theo,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

863 có nghĩa là một chuỗi gồm một hoặc nhiều ký tự chữ số thập phân hoặc một chuỗi gồm một hoặc nhiều ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

864

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Với tất cả các siêu ký tự mà mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 hỗ trợ, bầu trời thực tế là có giới hạn

Thế thôi mọi người

Điều đó hoàn thành chuyến tham quan của chúng tôi về các siêu ký tự biểu thức chính quy được hỗ trợ bởi mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 của Python. [Trên thực tế, nó không hoàn toàn như vậy—có một số yếu tố khác mà bạn sẽ tìm hiểu bên dưới trong phần thảo luận về cờ. ]

Có rất nhiều thứ để hiểu, nhưng một khi bạn đã quen với cú pháp regex trong Python, độ phức tạp của khớp mẫu mà bạn có thể thực hiện là gần như vô hạn. Những công cụ này rất hữu ích khi bạn đang viết mã để xử lý dữ liệu văn bản

Nếu bạn chưa quen với biểu thức chính quy và muốn thực hành nhiều hơn khi làm việc với chúng hoặc nếu bạn đang phát triển một ứng dụng sử dụng biểu thức chính quy và bạn muốn thử nghiệm nó một cách tương tác, thì hãy xem trang web 101 Biểu thức chính quy. Nó thực sự mát mẻ

Loại bỏ các quảng cáo

Khớp biểu thức chính quy đã sửa đổi với cờ

Hầu hết các chức năng trong mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 có một đối số tùy chọn

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

59. Điều này bao gồm chức năng mà bạn hiện rất quen thuộc,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

870

Quét một chuỗi để tìm đối sánh regex, áp dụng công cụ sửa đổi được chỉ định
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
59

Các cờ sửa đổi hành vi phân tích cú pháp regex, cho phép bạn tinh chỉnh hơn nữa việc khớp mẫu của mình

Các cờ biểu thức chính quy được hỗ trợ

Bảng dưới đây tóm tắt ngắn gọn các cờ có sẵn. Tất cả các cờ ngoại trừ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

872 đều có tên ngắn, gồm một chữ cái và cũng có tên dài hơn, đầy đủ từ

Tên ngắnTên dàiHiệu ứng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

873

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

874Làm khớp các ký tự chữ cái không phân biệt chữ hoa chữ thường

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

875

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

876Làm cho các neo bắt đầu chuỗi và cuối chuỗi khớp với các dòng mới được nhúng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

877

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

878Làm cho siêu ký tự dấu chấm khớp với một dòng mới

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

879

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

880Cho phép bao gồm khoảng trắng và nhận xét trong một biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

282Car dùng phân tích cú pháp reg để gỡ lỗi ___67

Các phần sau mô tả chi tiết hơn cách các cờ này ảnh hưởng đến hành vi so khớp

______6873
______6874

Làm cho trường hợp phù hợp không nhạy cảm

Khi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 có hiệu lực, khớp ký tự không phân biệt chữ hoa chữ thường

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong tìm kiếm ở dòng 1, ________ 6828 chỉ khớp với ba ký tự đầu tiên của ________ 6893. Tương tự, ở dòng 3,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

894 chỉ khớp với ba ký tự cuối cùng. Nhưng trong các tìm kiếm tiếp theo, trình phân tích cú pháp bỏ qua trường hợp, vì vậy cả

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

828 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

894 đều khớp với toàn bộ chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 cũng ảnh hưởng đến kết hợp chữ cái liên quan đến các lớp ký tự

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Khi trường hợp quan trọng, phần dài nhất của ________ 6898 mà ________ 6899 khớp chỉ là phần đầu tiên của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537. Chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

873 làm cho trường hợp tìm kiếm không nhạy cảm, do đó,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

899 khớp với toàn bộ chuỗi

______6875
______6876

Làm cho các neo bắt đầu chuỗi và kết thúc chuỗi khớp với các dòng mới được nhúng

Theo mặc định, các ký tự neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 [bắt đầu chuỗi] và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 [cuối chuỗi] chỉ khớp ở đầu và cuối chuỗi tìm kiếm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong trường hợp này, mặc dù chuỗi tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

507 có chứa các ký tự dòng mới được nhúng, nhưng chỉ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571 khớp khi được neo ở đầu chuỗi và chỉ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543 khớp khi được neo ở cuối

Tuy nhiên, nếu một chuỗi có các dòng mới được nhúng, bạn có thể coi chuỗi đó bao gồm nhiều dòng bên trong. Trong trường hợp đó, nếu cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 được đặt, thì ký tự meta ký tự neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 cũng khớp với các dòng bên trong

```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
514 khớp ở đầu chuỗi hoặc ở đầu bất kỳ dòng nào trong chuỗi [nghĩa là ngay sau một dòng mới]
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
515 khớp ở cuối chuỗi hoặc ở cuối bất kỳ dòng nào trong chuỗi [ngay trước một dòng mới]

Sau đây là các tìm kiếm tương tự như được hiển thị ở trên

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

507, cả ba

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

571,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

543 đều xuất hiện ở đầu hoặc cuối chuỗi hoặc ở đầu hoặc cuối một dòng trong chuỗi. Với cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 được đặt, cả ba khớp với nhau khi được neo với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515

Ghi chú. Cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 chỉ sửa đổi các neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 theo cách này. Nó không có bất kỳ ảnh hưởng nào đối với các neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trên dòng 3 và 5, các dấu neo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

514 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

515 cho biết rằng phải tìm thấy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 ở đầu và cuối dòng. Chỉ định cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 làm cho các trận đấu này thành công

Các ví dụ ở dòng 8 và 10 sử dụng cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

653 thay thế. Bạn có thể thấy rằng những trận đấu này không thành công ngay cả khi cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 có hiệu lực

______6877
______6878

Làm cho siêu ký tự dấu chấm [
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
98] khớp với một dòng mới

Hãy nhớ rằng theo mặc định, ký tự dấu chấm khớp với bất kỳ ký tự nào ngoại trừ ký tự xuống dòng. Cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 dỡ bỏ hạn chế này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong ví dụ này, trên dòng 1, ký tự dấu chấm không khớp với dòng mới trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

538. Trên dòng 3 và 5,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 đang có hiệu lực, vì vậy dấu chấm khớp với dòng mới. Lưu ý rằng tên viết tắt của cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

877, không phải

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

542 như bạn có thể mong đợi

______6879
______6880

Cho phép bao gồm khoảng trắng và nhận xét trong biểu thức chính quy

Cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545 chỉ định một vài hành vi đặc biệt

Trình phân tích cú pháp regex bỏ qua tất cả khoảng trắng trừ khi nó nằm trong một lớp ký tự hoặc được thoát bằng dấu gạch chéo ngược
Nếu biểu thức chính quy chứa một ký tự
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
528 không có trong một lớp ký tự hoặc được thoát bằng dấu gạch chéo ngược, thì trình phân tích cú pháp sẽ bỏ qua nó và tất cả các ký tự ở bên phải của nó

Việc sử dụng này là gì?

Đây là một ví dụ cho thấy cách bạn có thể sử dụng cái này. Giả sử bạn muốn phân tích số điện thoại có định dạng sau

Mã vùng ba chữ số tùy chọn, trong ngoặc đơn
khoảng trắng tùy chọn
Tiền tố ba chữ số

Dấu tách [hoặc là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

690 hoặc là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

625]

Số dòng có bốn chữ số

Regex sau thực hiện thủ thuật

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Nhưng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

549 rất bắt mắt phải không?

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Các lệnh gọi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 giống như các cuộc gọi được hiển thị ở trên, vì vậy bạn có thể thấy rằng biểu thức chính quy này hoạt động giống như biểu thức chính quy trước đó. Nhưng nó ít khó hiểu hơn ngay từ cái nhìn đầu tiên

Lưu ý rằng trích dẫn ba lần làm cho việc bao gồm các dòng mới được nhúng đặc biệt thuận tiện, đủ điều kiện là khoảng trắng bị bỏ qua trong chế độ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545

Khi sử dụng cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545, hãy chú ý đến khoảng trắng mà bạn cho là quan trọng. Hãy xem xét những ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Sau tất cả những gì bạn đã thấy cho đến thời điểm này, bạn có thể thắc mắc tại sao trên dòng 4, biểu thức chính quy

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

554 không khớp với chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

555. Không phải vì cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545 khiến trình phân tích cú pháp bỏ qua ký tự khoảng trắng

Để khớp như mong đợi, hãy thoát khỏi ký tự khoảng trắng bằng dấu gạch chéo ngược hoặc đưa ký tự này vào một lớp ký tự, như được hiển thị trên dòng 7 và 9

Như với cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537, lưu ý rằng cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545 có tên ngắn không trực quan.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

879, không phải

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

560

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

872

Hiển thị thông tin gỡ lỗi

Cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

297 khiến trình phân tích cú pháp regex trong Python hiển thị thông tin gỡ lỗi về quá trình phân tích cú pháp cho bảng điều khiển

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Khi trình phân tích cú pháp hiển thị

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

563 trong đầu ra gỡ lỗi, nó đang hiển thị mã ASCII của một ký tự bằng chữ trong biểu thức chính quy. Trong trường hợp này, các ký tự chữ là ________ 3561, ________ 7565, _______ 7565 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

252,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

538

Đây là một ví dụ phức tạp hơn. Đây là regex số điện thoại được hiển thị trong cuộc thảo luận về cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

545 trước đó

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điều này có vẻ như rất nhiều thông tin bí truyền mà bạn sẽ không bao giờ cần đến, nhưng nó có thể hữu ích. Xem Deep Dive bên dưới để biết ứng dụng thực tế

Lặn sâu. Gỡ lỗi phân tích cú pháp biểu thức chính quy
Như bạn đã biết ở trên, chuỗi siêu ký tự
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
266 biểu thị một số lần lặp lại cụ thể. Nó phù hợp với bất cứ nơi nào từ
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
258 đến
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
268 lặp lại của những gì trước nó
>>>
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
10
Bạn có thể xác minh điều này bằng cờ
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
297
>>>
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
11
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
575 xác nhận rằng trình phân tích cú pháp regex nhận ra chuỗi siêu ký tự
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
576 và diễn giải nó dưới dạng một bộ định lượng phạm vi
Tuy nhiên, như đã lưu ý trước đây, nếu một cặp dấu ngoặc nhọn trong biểu thức chính quy trong Python chứa bất kỳ thứ gì khác ngoài một số hoặc phạm vi số hợp lệ, thì nó sẽ mất ý nghĩa đặc biệt
Bạn cũng có thể xác minh điều này
>>>
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
12
Bạn có thể thấy rằng không có mã thông báo
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
577 nào trong đầu ra gỡ lỗi. Mã thông báo
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
578 chỉ ra rằng trình phân tích cú pháp xử lý
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
579 theo nghĩa đen và không phải là một chuỗi siêu ký tự định lượng.
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
69, ________ 7581, ________ 7582, ________ 7582 và ________ 7584 là các mã ASCII cho các ký tự trong chuỗi ký tự
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
585
Thông tin được hiển thị bởi cờ
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
297 có thể giúp bạn khắc phục sự cố bằng cách chỉ cho bạn cách trình phân tích cú pháp diễn giải biểu thức chính quy của bạn

Thật kỳ lạ, mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 không xác định phiên bản một chữ cái của cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

297. Bạn có thể xác định của riêng bạn nếu bạn muốn

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Nhưng điều này có thể gây nhầm lẫn hơn là hữu ích, vì người đọc mã của bạn có thể hiểu sai nó là viết tắt của cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537. Nếu bạn đã thực hiện bài tập này, bạn nên ghi lại kỹ lưỡng

______6883
______6884

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

885
____6886

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

887

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

888

Chỉ định mã hóa ký tự được sử dụng để phân tích cú pháp các lớp ký tự regex đặc biệt

Một số trình tự siêu ký tự regex [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

581,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

667,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

678,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

593,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

600 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

601] yêu cầu bạn chỉ định các ký tự cho các lớp nhất định như từ, chữ số hoặc khoảng trắng. Các cờ trong nhóm này xác định sơ đồ mã hóa được sử dụng để gán các ký tự cho các lớp này. Các mã hóa có thể là ASCII, Unicode hoặc theo ngôn ngữ hiện tại

Bạn đã có phần giới thiệu ngắn gọn về mã hóa ký tự và Unicode trong hướng dẫn về Dữ liệu chuỗi và ký tự trong Python, dưới phần thảo luận của. Để biết thêm thông tin chuyên sâu, hãy xem các tài nguyên này

Mã hóa Unicode & ký tự trong Python. Hướng dẫn không đau

Tại sao mã hóa ký tự lại quan trọng như vậy trong ngữ cảnh biểu thức chính quy trong Python?

Trước đó bạn đã biết rằng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592 chỉ định ký tự một chữ số. Mô tả về chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592 nói rằng nó tương đương với lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

91. Điều đó đúng với tiếng Anh và các ngôn ngữ Tây Âu, nhưng đối với hầu hết các ngôn ngữ trên thế giới, các ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

92 đến

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

93 không đại diện cho tất cả hoặc thậm chí bất kỳ chữ số nào

Ví dụ: đây là một chuỗi bao gồm ba

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Để trình phân tích cú pháp regex giải thích đúng cho tập lệnh Devanagari, chuỗi siêu ký tự chữ số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

592 cũng phải khớp với từng ký tự này

Unicode Consortium đã tạo Unicode để xử lý vấn đề này. Unicode là một tiêu chuẩn mã hóa ký tự được thiết kế để đại diện cho tất cả các hệ thống chữ viết trên thế giới. Tất cả các chuỗi trong Python 3, bao gồm cả biểu thức chính quy, là Unicode theo mặc định

Vì vậy, sau đó, quay lại các cờ được liệt kê ở trên. Các cờ này giúp xác định xem một ký tự có thuộc một lớp nhất định hay không bằng cách chỉ định xem mã hóa được sử dụng là ASCII, Unicode hay ngôn ngữ hiện tại

```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
885 và
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
886 chỉ định bảng mã Unicode. Unicode là mặc định, vì vậy những cờ này là không cần thiết. Chúng chủ yếu được hỗ trợ để tương thích ngược
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
883 và
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
884 buộc xác định dựa trên mã hóa ASCII. Nếu bạn tình cờ làm việc bằng tiếng Anh, thì điều này vẫn xảy ra, vì vậy cờ sẽ không ảnh hưởng đến việc có tìm thấy kết quả khớp hay không
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
887 và
```
>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3
```
888 đưa ra quyết định dựa trên ngôn ngữ hiện tại. Địa phương là một khái niệm lỗi thời và không được coi là đáng tin cậy. Ngoại trừ trong những trường hợp hiếm hoi, bạn có thể không cần đến nó

Sử dụng mã hóa Unicode mặc định, trình phân tích cú pháp regex sẽ có thể xử lý bất kỳ ngôn ngữ nào bạn sử dụng. Trong ví dụ sau, nó nhận dạng chính xác từng ký tự trong chuỗi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

617 dưới dạng chữ số

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Đây là một ví dụ khác minh họa cách mã hóa ký tự có thể ảnh hưởng đến đối sánh biểu thức chính quy trong Python. Hãy xem xét chuỗi này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

618 [từ tiếng Đức có nghĩa là xinh đẹp] chứa ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

619, có giá trị Unicode thập lục phân 16 bit là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

620. Ký tự này không thể biểu diễn trong ASCII 7-bit truyền thống

Nếu bạn đang làm việc bằng tiếng Đức, thì bạn nên mong đợi một cách hợp lý trình phân tích cú pháp regex coi tất cả các ký tự trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

618 là các ký tự từ. Nhưng hãy xem điều gì sẽ xảy ra nếu bạn tìm kiếm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34 cho các ký tự từ bằng cách sử dụng lớp ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

580 và buộc mã hóa ASCII

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Khi bạn hạn chế mã hóa thành ASCII, trình phân tích cú pháp regex chỉ nhận ra ba ký tự đầu tiên là ký tự từ. Trận đấu dừng lại ở

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

619

Mặt khác, nếu bạn chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

886 hoặc cho phép mã hóa mặc định thành Unicode, thì tất cả các ký tự trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

618 đủ điều kiện là ký tự từ

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

627 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

628 có sẵn trong trường hợp bạn cần chúng cho những trường hợp đặc biệt. Nhưng nói chung, chiến lược tốt nhất là sử dụng bảng mã Unicode mặc định. Điều này sẽ xử lý chính xác bất kỳ ngôn ngữ thế giới nào

Kết hợp các đối số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

59 trong một lệnh gọi hàm

Các giá trị cờ được xác định để bạn có thể kết hợp chúng bằng toán tử [

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

525]. Điều này cho phép bạn chỉ định một số cờ trong một lệnh gọi hàm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Cuộc gọi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 này sử dụng bitwise OR để chỉ định cả hai cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650 cùng một lúc

Đặt và xóa cờ trong một biểu thức chính quy

Ngoài việc có thể chuyển đối số

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

59 cho hầu hết các lệnh gọi hàm mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32, bạn cũng có thể sửa đổi các giá trị cờ trong biểu thức chính quy trong Python. Có hai trình tự siêu ký tự regex cung cấp khả năng này

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

636

Đặt [các] giá trị cờ trong khoảng thời gian của biểu thức chính quy

Trong một biểu thức chính quy, chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

636 đặt các cờ đã chỉ định cho toàn bộ biểu thức

Giá trị của

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

59 là một hoặc nhiều chữ cái từ bộ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

639,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

846,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

34,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

644 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

645. Đây là cách chúng tương ứng với các cờ mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

LetterFlags

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

639

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

883

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

884

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

846

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

873

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

874

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

887

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

888

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

258

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

875

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

876

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

877

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

878

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

644

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

885

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

886

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

645 ___689

Toàn bộ chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

636 khớp với chuỗi trống. Nó luôn khớp thành công và không sử dụng bất kỳ chuỗi tìm kiếm nào

Các ví dụ sau đây là các cách tương đương để đặt cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

650

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Lưu ý rằng chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

636 đặt [các] cờ đã cho cho toàn bộ biểu thức chính quy bất kể bạn đặt nó ở đâu trong biểu thức

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Trong các ví dụ trên, cả hai siêu ký tự dấu chấm khớp với các dòng mới vì cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

537 đang có hiệu lực. Điều này đúng ngay cả khi

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

673 xuất hiện ở giữa hoặc ở cuối biểu thức

Kể từ Python 3. 7, việc chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

636 ở bất kỳ đâu trong biểu thức chính quy khác với phần đầu không được chấp nhận

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Nó vẫn tạo ra kết quả phù hợp, nhưng bạn sẽ nhận được thông báo cảnh báo

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

675

Đặt hoặc xóa [các] giá trị cờ trong khoảng thời gian của một nhóm

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

675 định nghĩa một nhóm không bắt giữ phù hợp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55. Đối với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

55 có trong nhóm, trình phân tích cú pháp regex đặt bất kỳ cờ nào được chỉ định trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

679 và xóa mọi cờ được chỉ định trong

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

680

Các giá trị cho

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

679 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

680 phổ biến nhất là ________ 6846, ________ 4258, ________ 034 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

645

Trong ví dụ sau, cờ

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 được đặt cho nhóm được chỉ định

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Điều này tạo ra một trận đấu vì

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

688 cho rằng trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

689 không phân biệt chữ hoa chữ thường

Bây giờ đối chiếu điều đó với ví dụ này

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Như trong ví dụ trước, trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

689 sẽ thành công vì nó không phân biệt chữ hoa chữ thường. Nhưng khi ở ngoài nhóm,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 không còn hiệu lực, vì vậy trận đấu với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

692 phân biệt chữ hoa chữ thường và không thành công

Đây là một ví dụ minh họa việc tắt cờ cho một nhóm

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Một lần nữa, không có trận đấu nào. Mặc dù

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

874 cho phép khớp phân biệt chữ hoa chữ thường cho toàn bộ cuộc gọi, nhưng chuỗi siêu ký tự

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

694 sẽ tắt

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

891 trong khoảng thời gian của nhóm đó, do đó, khớp với

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

689 không thành công

Kể từ Python 3. 7, bạn có thể chỉ định

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

644,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

639 hoặc

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 là

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

679 để ghi đè mã hóa mặc định cho nhóm đã chỉ định

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

Tuy nhiên, bạn chỉ có thể đặt mã hóa theo cách này. Bạn không thể xóa nó

>>>

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

644,

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

639 và

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

641 loại trừ lẫn nhau. Chỉ một trong số họ có thể xuất hiện trên mỗi nhóm

Phần kết luận

Phần này kết thúc phần giới thiệu của bạn về đối sánh biểu thức chính quy và mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 của Python. Xin chúc mừng. Bạn đã thành thạo một lượng lớn tài liệu

Bây giờ bạn biết làm thế nào để

Sử dụng

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33 để thực hiện khớp regex trong Python

Tạo các tìm kiếm khớp mẫu phức tạp với các siêu ký tự regex
Tinh chỉnh hành vi phân tích cú pháp regex bằng cờ

Nhưng bạn vẫn chỉ thấy một chức năng trong mô-đun.

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

33. Mô-đun

>>> s = 'foo123bar'
>>> s.find['123']
3
>>> s.index['123']
3

32 có nhiều chức năng và đối tượng hữu ích hơn để thêm vào bộ công cụ khớp mẫu của bạn. Hướng dẫn tiếp theo trong loạt bài này sẽ giới thiệu cho bạn những gì khác mà mô-đun regex trong Python cung cấp

« Hàm trong Python

Biểu thức chính quy. Regex trong Python [Phần 2] »

Đánh dấu là đã hoàn thành

Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Biểu thức chính quy và xây dựng biểu thức chính quy trong Python

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về John Sturtz

John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python

» Thông tin thêm về John

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Aldren

Jim

Joanna

Gia-cốp

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Có trong thư viện chuẩn Python không?

Thư viện chuẩn của Python lại quản lý các biểu thức chính quy. Khớp tất cả các lần xuất hiện của một mẫu [không giống như tìm kiếm[] chỉ khớp với mẫu đầu tiên] và trả về chúng dưới dạng danh sách các chuỗi hoặc bộ.

Làm cách nào để cài đặt lại trong Python?

Gõ "cmd" vào thanh tìm kiếm và nhấn Enter để mở dòng lệnh. Cái này là cái gì? . Điều này cài đặt regex cho cài đặt Python mặc định của bạn. Type “ pip install regex ” [without quotes] in the command line and hit Enter again. This installs regex for your default Python installation.

In Re trong Python là gì?

Một biểu thức chính quy [hoặc RE] chỉ định một tập hợp các chuỗi phù hợp với nó ; .

Làm cách nào để thêm RegEx trong Python?

Các bước so khớp biểu thức chính quy .

Nhập mô-đun regex với nhập lại

Tạo một đối tượng Regex với re. chức năng biên dịch[]. .

Truyền chuỗi bạn muốn tìm kiếm vào phương thức search[] của đối tượng Regex. .

Gọi phương thức group[] của đối tượng Match để trả về một chuỗi văn bản khớp thực tế

Regex trong Python và Công dụng của chúng

Lịch sử [rất ngắn gọn] của biểu thức chính quy

Mô-đun >>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3 32

Cách nhập >>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3 33

Ví dụ khớp mẫu đầu tiên

Các ký tự Regex trong Python

Siêu ký tự được Mô-đun >>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3 32 hỗ trợ

Siêu ký tự phù hợp với một ký tự duy nhất

Thoát khỏi siêu ký tự

mỏ neo

định lượng

Nhóm cấu trúc và tham chiếu ngược

Đối xử với một nhóm như một đơn vị

Chụp nhóm

phản hồi

Các cấu trúc nhóm khác

Xác nhận Lookahead và Lookbehind

Các siêu ký tự khác

Khớp biểu thức chính quy đã sửa đổi với cờ

Các cờ biểu thức chính quy được hỗ trợ

Lặn sâu. Gỡ lỗi phân tích cú pháp biểu thức chính quy

Kết hợp các đối số >>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3 59 trong một lệnh gọi hàm

Đặt và xóa cờ trong một biểu thức chính quy

Phần kết luận

Có trong thư viện chuẩn Python không?

Làm cách nào để cài đặt lại trong Python?

In Re trong Python là gì?

Làm cách nào để thêm RegEx trong Python?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Mô-đun
`>>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3`
32

Cách nhập
`>>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3`
33

Siêu ký tự được Mô-đun
`>>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3`
32 hỗ trợ

Kết hợp các đối số
`>>> s = 'foo123bar' >>> s.find['123'] 3 >>> s.index['123'] 3`
59 trong một lệnh gọi hàm