Hướng dẫn re ignorecase python - lại bỏ qua python

Hướng dẫn re ignorecase python - lại bỏ qua python

Show

Đã đăng vào thg 11 27, 2017 9:57 SA 3 phút đọc 3 phút đọc

1. Regex là gì?

Regular expression (Regex) là một chuỗi miêu tả một bộ các chuỗi khác, theo những quy tắc cú pháp nhất định. Bạn cũng có thể gọi Regex là một ngôn ngữ. Và hầu như ngôn ngữ lập trình nào cũng hỗ trợ Regular expression.

2. Regex trong Python.

Regular Expression trong Python được thể hiện qua module re, re Module cung cấp sự hỗ trợ đầy đủ các Regular Expression trong Python. Module này tạo Exception là re.error nếu xảy ra một lỗi trong khi biên dịch hoặc khi sử dụng một Regular Expression. Để sử dụng re việc đầu tiên bạn cần phải import module re vào chương trình, sử dụng với cú pháp như sau:

import re

3. Sử dụng Regex với search(), match(), split()

3.1 re.match()

re.match(pattern, string, flags=0)

So khớp pattern với string với các flag tùy ý. Dưới đây là cú pháp cho hàm này.

Chi tiết về tham số:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.

Hàm re.match trả về một đối tượng match nếu thành công và trả về None nếu thất bại. Chúng ta sử dụng hàm group(num) hoặc groups() của đối tượng match để lấy biểu thức đã được so khớp (kết nối).

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
re.search(pattern, string, flags=0)

Phương thức này thực hiện tìm kiếm chuỗi so khớp trên string và nó sẽ trả về các giá trị được so khớp.

Trong đó:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''

3.4 re.split()

re.split(pattern, string, maxsplit=0, flags=0)

Trong đó:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

3.4 re.split()

3.3 Một số flag hay dùng trong Regular Expression

I hay IGNORECASE - Không phân biệt hoa thường khi tiến hành search hoặc match L hay LOCALE - So Khớp với local hiện tại. M hay MULTILINE - Thay đổi $ và ^ thành kết thúc của một dòng và bắt đầu của một dòng thay vì mặc định là kết thúc chuỗi và bắt đầu chuỗi. A hay ACSII - Thay đổi \w, \W, \b, \B, \d, \D, \S và \s thành so khơp full unicode. S hay DOTALL -Thay đổi pattern . thành khớp với bất kỳ ký tự nào và dòng mới. ...

4. Kết Luận

Regular Expression trong python còn rất nhiều nhưng trong bài này mình chỉ hướng dẫn các bạn sử dụng một số regex hay dùng trong python mong rằng nó giúp ích được các bạn.

xem thêm : https://viblo.asia/p/chia-se-10-regular-expression-huu-ich-ma-developer-nen-biet-Qbq5QJPLKD8 https://viblo.asia/p/cac-ki-tu-dac-biet-trong-regular-expressions-phan-2-ORNZqP6MK0n

Mã nguồn: lib/re.py Lib/re.py


Mô -đun này cung cấp các hoạt động khớp biểu thức thường xuyên tương tự như các hoạt động được tìm thấy trong Perl.

Cả hai mẫu và chuỗi sẽ được tìm kiếm có thể là chuỗi Unicode (

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
9) cũng như các chuỗi 8 bit (
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
0). Tuy nhiên, các chuỗi unicode và chuỗi 8 bit không thể được trộn lẫn: nghĩa là, bạn không thể khớp với một chuỗi unicode với mẫu byte hoặc ngược lại; Tương tự, khi yêu cầu thay thế, chuỗi thay thế phải cùng loại với cả mẫu và chuỗi tìm kiếm.

Biểu thức chính quy sử dụng ký tự dấu gạch chéo ngược (

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1) để biểu thị các hình thức đặc biệt hoặc cho phép các ký tự đặc biệt được sử dụng mà không cần gọi ý nghĩa đặc biệt của chúng. Điều này va chạm với việc sử dụng Python sườn của cùng một nhân vật cho cùng một mục đích trong các chữ viết; Ví dụ, để phù hợp với một dấu gạch chéo ngược theo nghĩa đen, người ta có thể phải viết
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
2 dưới dạng chuỗi mẫu, bởi vì biểu thức thông thường phải là
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
3 và mỗi dấu gạch chéo ngược phải được biểu thị dưới dạng
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
3 bên trong một chuỗi python thông thường theo nghĩa đen. Ngoài ra, xin lưu ý rằng bất kỳ trình tự thoát không hợp lệ nào trong việc sử dụng Python, của dấu gạch chéo ngược trong các chuỗi chữ hiện tại tạo ra
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
5 và trong tương lai, điều này sẽ trở thành
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
6. Hành vi này sẽ xảy ra ngay cả khi đó là một chuỗi thoát hợp lệ cho một biểu thức chính quy.

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

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
7. Vì vậy,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
8 là một chuỗi hai ký tự chứa
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và
re.split(pattern, string, maxsplit=0, flags=0)
0, trong khi
re.split(pattern, string, maxsplit=0, flags=0)
1 là một chuỗi một ký tự có chứa một dòng mới. Thông thường các mẫu sẽ được thể hiện trong mã Python bằng cách sử dụng ký hiệu chuỗi thô này.

Điều quan trọng cần lưu ý là hầu hết các hoạt động biểu thức chính quy đều có sẵn dưới dạng các hàm và phương thức cấp độ mô-đun trên các biểu thức được biên dịch thông thường. Các chức năng là các phím tắt mà don don yêu cầu bạn biên dịch một đối tượng Regex trước, nhưng bỏ lỡ một số tham số tinh chỉnh.compiled regular expressions. The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters.

Xem thêm

Mô-đun Regex của bên thứ ba, có API tương thích với mô-đun thư viện tiêu chuẩn

re.split(pattern, string, maxsplit=0, flags=0)
2, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode kỹ lưỡng hơn.

Biểu thức thông thường cú pháp

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ó; Các hàm trong mô -đun này cho phép bạn kiểm tra xem một chuỗi cụ thể có khớp với biểu thức chính quy nhất định không (hoặc nếu một biểu thức chính quy nhất định khớp với một chuỗi cụ thể, đi xuống cùng một điều).

Biểu thức thông thường có thể được nối để tạo thành các biểu thức thường xuyên mới; Nếu A và B đều là biểu thức chính quy, thì AB cũng là một biểu thức chính quy. Nói chung, nếu chuỗi P khớp với A và một chuỗi Q khác khớp với B, chuỗi PQ sẽ khớp với AB. Điều này giữ trừ khi A hoặc B chứa các hoạt động ưu tiên thấp; điều kiện biên giữa a và b; hoặc đã đánh số tài liệu tham khảo nhóm. Do đó, các biểu thức phức tạp có thể dễ dàng được xây dựng từ các biểu thức nguyên thủy đơn giản hơn như các biểu thức được mô tả ở đây. Để biết chi tiết về lý thuyết và thực hiện các biểu thức thường xuyên, hãy tham khảo cuốn sách Friedl [FRIE09] hoặc gần như bất kỳ cuốn sách giáo khoa nào về xây dựng trình biên dịch.[Frie09], or almost any textbook about compiler construction.

Một lời giải thích ngắn gọn về định dạng của các biểu thức thường xuyên sau. Để biết thêm thông tin và một bài thuyết trình nhẹ nhàng hơn, hãy tham khảo ý kiến ​​biểu thức thường xuyên.Regular Expression HOWTO.

Biểu thức chính quy có thể chứa cả các ký tự đặc biệt và thông thường. Hầu hết các ký tự thông thường, như

re.split(pattern, string, maxsplit=0, flags=0)
3,
re.split(pattern, string, maxsplit=0, flags=0)
4 hoặc
re.split(pattern, string, maxsplit=0, flags=0)
5, là các biểu thức chính quy đơn giản nhất; Họ chỉ đơn giản là phù hợp với chính họ. Bạn có thể kết hợp các ký tự thông thường, vì vậy
re.split(pattern, string, maxsplit=0, flags=0)
6 khớp với chuỗi
re.split(pattern, string, maxsplit=0, flags=0)
7. .

Một số ký tự, như

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0 hoặc
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
1, là đặc biệt. Các ký tự đặc biệt là đại diện cho các lớp các ký tự thông thường hoặc ảnh hưởng đến cách các biểu thức chính quy xung quanh chúng được giải thích.

Vòng loại lặp lại (

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
2,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
3,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
4,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
5, v.v.) không thể được lồng trực tiếp. Điều này tránh sự mơ hồ với hậu tố biến đổi không màu xanh lá cây
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
4 và với các công cụ sửa đổi khác trong các triển khai khác. Để áp dụng sự lặp lại thứ hai cho sự lặp lại bên trong, dấu ngoặc đơn có thể được sử dụng. Ví dụ: biểu thức
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
7 khớp với bất kỳ bội số nào của sáu ký tự
re.split(pattern, string, maxsplit=0, flags=0)
4.

Các nhân vật đặc biệt là:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
9

(Dot.) Trong chế độ mặc định, điều này phù hợp với bất kỳ ký tự nào ngoại trừ dòng mới. Nếu cờ

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
0 đã được chỉ định, điều này phù hợp với bất kỳ ký tự nào bao gồm cả dòng mới.

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
1

.

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3

Khớp với phần cuối của chuỗi hoặc ngay trước dòng mới ở cuối chuỗi và ở chế độ

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
2 cũng khớp với một dòng mới.
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
5 phù hợp với cả ‘foo, và‘ foobar, trong khi biểu thức thông thường
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
6 chỉ khớp với ‘foo. Thú vị hơn, việc tìm kiếm
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
7 trong
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
8 phù hợp với ‘FOO2, thông thường, nhưng‘ FOO1, ở chế độ
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
2; Tìm kiếm một
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
3 duy nhất trong
re.match(pattern, string, flags=0)
01 sẽ tìm thấy hai khớp (trống): một ngay trước dòng mới và một ở cuối chuỗi.

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
2

Làm cho RE kết quả khớp với 0 hoặc nhiều sự lặp lại của RE trước đó, càng nhiều lần lặp lại càng tốt.

re.match(pattern, string, flags=0)
03 sẽ phù hợp với ‘A,’ ab, hoặc ‘A, sau đó là bất kỳ số lượng‘ Biên.

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
3

Làm cho RE kết quả phù hợp với 1 hoặc nhiều sự lặp lại của Re trước.

re.match(pattern, string, flags=0)
05 sẽ phù hợp với ’A, theo sau là bất kỳ số lượng‘ Biên nào; Nó sẽ không chỉ phù hợp với ’a.

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
4

Làm cho kết quả RE khớp với 0 hoặc 1 lần lặp lại của Re trước.

re.match(pattern, string, flags=0)
07 sẽ phù hợp với ‘A, hoặc‘ AB.

re.match(pattern, string, flags=0)
08,
re.match(pattern, string, flags=0)
09,
re.match(pattern, string, flags=0)
10

Vòng loại

re.match(pattern, string, flags=0)
11,
re.match(pattern, string, flags=0)
12 và
re.match(pattern, string, flags=0)
13 đều tham lam; Họ phù hợp với văn bản càng nhiều càng tốt. Đôi khi hành vi này không phải là mong muốn; Nếu RE
re.match(pattern, string, flags=0)
14 được khớp với
re.match(pattern, string, flags=0)
15, nó sẽ khớp với toàn bộ chuỗi và không chỉ
re.match(pattern, string, flags=0)
16. Thêm
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
4 sau khi vòng loại làm cho nó thực hiện trận đấu theo kiểu không xanh hoặc tối thiểu; Càng ít ký tự càng tốt sẽ được khớp. Sử dụng RE
re.match(pattern, string, flags=0)
18 sẽ chỉ khớp với
re.match(pattern, string, flags=0)
16.

re.match(pattern, string, flags=0)
20

Chỉ định rằng chính xác các bản sao m của RE trước đó phải được khớp; Ít trận đấu hơn khiến toàn bộ RE không phù hợp. Ví dụ:

re.match(pattern, string, flags=0)
21 sẽ khớp chính xác sáu ký tự
re.split(pattern, string, maxsplit=0, flags=0)
4, nhưng không phải năm ký tự.

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
5

Làm cho RE kết quả phù hợp từ M đến N lặp lại của RE trước đó, cố gắng khớp với càng nhiều lần lặp lại càng tốt. Ví dụ:

re.match(pattern, string, flags=0)
24 sẽ khớp từ 3 đến 5
re.split(pattern, string, maxsplit=0, flags=0)
4 ký tự. Bỏ qua M chỉ định giới hạn dưới bằng 0 và bỏ qua N chỉ định giới hạn trên vô hạn. Ví dụ,
re.match(pattern, string, flags=0)
26 sẽ khớp với
re.match(pattern, string, flags=0)
27 hoặc một nghìn ký tự
re.split(pattern, string, maxsplit=0, flags=0)
4 theo sau là
re.match(pattern, string, flags=0)
29, nhưng không phải
re.match(pattern, string, flags=0)
30. Dấu phẩy có thể không bị bỏ qua hoặc công cụ sửa đổi sẽ bị nhầm lẫn với mẫu được mô tả trước đó.

re.match(pattern, string, flags=0)
31

Làm cho RE kết quả phù hợp từ M đến N lặp lại của Re trước, cố gắng khớp với càng ít sự lặp lại càng tốt. Đây là phiên bản không màu xanh của vòng loại trước. Ví dụ: trên chuỗi 6 ký tự

re.match(pattern, string, flags=0)
32,
re.match(pattern, string, flags=0)
24 sẽ khớp với 5
re.split(pattern, string, maxsplit=0, flags=0)
4 ký tự, trong khi
re.match(pattern, string, flags=0)
35 sẽ chỉ khớp với 3 ký tự.

re.match(pattern, string, flags=0)
36

Hoặc thoát khỏi các ký tự đặc biệt (cho phép bạn khớp các ký tự như

re.match(pattern, string, flags=0)
11,
re.match(pattern, string, flags=0)
13, v.v.) hoặc báo hiệu một chuỗi đặc biệt; Trình tự đặc biệt được thảo luận dưới đây.

Nếu bạn không sử dụng một chuỗi thô để diễn đạt mẫu, hãy nhớ rằng Python cũng sử dụng dấu gạch chéo ngược như một chuỗi thoát trong các chữ viết; Nếu trình tự thoát được công nhận bởi trình phân tích cú pháp Python, thì dấu gạch chéo ngược và ký tự tiếp theo được bao gồm trong chuỗi kết quả. Tuy nhiên, nếu Python sẽ nhận ra chuỗi kết quả, dấu gạch chéo ngược nên được lặp lại hai lần. Điều này rất phức tạp và khó hiểu, vì vậy, nó rất khuyến khích bạn sử dụng các chuỗi thô cho tất cả nhưng các biểu thức đơn giản nhất.

re.match(pattern, string, flags=0)
39

Được sử dụng để chỉ ra một tập hợp các ký tự. Trong một tập hợp:

  • Các ký tự có thể được liệt kê riêng lẻ, ví dụ:

    re.match(pattern, string, flags=0)
    
    40 sẽ khớp với
    re.split(pattern, string, maxsplit=0, flags=0)
    
    4,
    re.match(pattern, string, flags=0)
    
    42 hoặc
    re.match(pattern, string, flags=0)
    
    43.

  • Phạm vi ký tự có thể được chỉ định bằng cách đưa hai ký tự và tách chúng bằng

    re.match(pattern, string, flags=0)
    
    44, ví dụ
    re.match(pattern, string, flags=0)
    
    45 sẽ khớp với bất kỳ chữ cái ASCII nào,
    re.match(pattern, string, flags=0)
    
    46 sẽ khớp với tất cả các số hai chữ số từ
    re.match(pattern, string, flags=0)
    
    47 với
    re.match(pattern, string, flags=0)
    
    48 và
    re.match(pattern, string, flags=0)
    
    49 sẽ khớp với bất kỳ hình nghĩa nào. Nếu
    re.match(pattern, string, flags=0)
    
    50 được thoát ra (ví dụ:
    re.match(pattern, string, flags=0)
    
    51) hoặc nếu nó được đặt là ký tự đầu tiên hoặc cuối cùng (ví dụ:
    re.match(pattern, string, flags=0)
    
    52 hoặc
    re.match(pattern, string, flags=0)
    
    53), nó sẽ phù hợp với nghĩa đen
    re.match(pattern, string, flags=0)
    
    44.

  • Các nhân vật đặc biệt mất ý nghĩa đặc biệt của họ bên trong bộ. Ví dụ:

    re.match(pattern, string, flags=0)
    
    55 sẽ khớp với bất kỳ ký tự nghĩa đen nào
    pattern: là chuỗi regular expression.
    string: là chuỗi cần so khớp để loại bỏ pattern
    maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
    flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
    
    1,
    re.match(pattern, string, flags=0)
    
    12,
    re.match(pattern, string, flags=0)
    
    11 hoặc
    re.match(pattern, string, flags=0)
    
    59.

  • Các lớp ký tự như

    re.match(pattern, string, flags=0)
    
    60 hoặc
    re.match(pattern, string, flags=0)
    
    61 (được định nghĩa bên dưới) cũng được chấp nhận bên trong một bộ, mặc dù các ký tự mà chúng khớp phụ thuộc vào chế độ
    re.match(pattern, string, flags=0)
    
    62 hay
    re.match(pattern, string, flags=0)
    
    63 có hiệu lực hay không.

  • Các ký tự không nằm trong phạm vi có thể được khớp bằng cách bổ sung cho tập hợp. Nếu ký tự đầu tiên của bộ là

    re.match(pattern, string, flags=0)
    
    64, tất cả các ký tự không có trong tập hợp sẽ được khớp. Ví dụ:
    re.match(pattern, string, flags=0)
    
    65 sẽ khớp với bất kỳ ký tự nào ngoại trừ
    re.match(pattern, string, flags=0)
    
    66 và
    re.match(pattern, string, flags=0)
    
    67 sẽ khớp với bất kỳ ký tự nào ngoại trừ
    re.match(pattern, string, flags=0)
    
    64.
    >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
    ['0', '3', '9']
    
    1 không có ý nghĩa đặc biệt nếu nó không phải là ký tự đầu tiên trong tập hợp.

  • Để phù hợp với một

    re.match(pattern, string, flags=0)
    
    70 theo nghĩa đen bên trong một bộ, đi trước nó với một dấu gạch chéo ngược hoặc đặt nó vào đầu bộ. Ví dụ, cả
    re.match(pattern, string, flags=0)
    
    71 và
    re.match(pattern, string, flags=0)
    
    72 sẽ phù hợp với dấu ngoặc đơn.

  • Hỗ trợ các bộ lồng nhau và các hoạt động tập hợp như trong Unicode Kỹ thuật tiêu chuẩn số 18 có thể được thêm vào trong tương lai. Điều này sẽ thay đổi cú pháp, vì vậy để tạo điều kiện cho sự thay đổi này

    re.match(pattern, string, flags=0)
    
    73 sẽ được nêu ra trong các trường hợp mơ hồ trong thời điểm hiện tại. Điều đó bao gồm các bộ bắt đầu với một trình tự ký tự theo nghĩa đen
    re.match(pattern, string, flags=0)
    
    74 hoặc có chứa chữ
    re.match(pattern, string, flags=0)
    
    75,
    re.match(pattern, string, flags=0)
    
    76,
    re.match(pattern, string, flags=0)
    
    77 và
    re.match(pattern, string, flags=0)
    
    78. Để tránh một cảnh báo thoát khỏi họ bằng một dấu gạch chéo ngược.

Đã thay đổi trong phiên bản 3.7:

re.match(pattern, string, flags=0)
73 được nâng lên nếu một bộ ký tự chứa các cấu trúc sẽ thay đổi về mặt ngữ nghĩa trong tương lai.
re.match(pattern, string, flags=0)
73 is raised if a character set contains constructs that will change semantically in the future.

re.match(pattern, string, flags=0)
80

re.match(pattern, string, flags=0)
81, trong đó A và B có thể là RES tùy ý, tạo ra một biểu thức chính quy sẽ khớp với A hoặc B. Một số lượng RES tùy ý có thể được phân tách bằng
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0 theo cách này. Điều này có thể được sử dụng bên trong các nhóm (xem bên dưới) là tốt. Khi chuỗi đích được quét, độ phân tách bởi
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0 được thử từ trái sang phải. Khi một mẫu hoàn toàn phù hợp, nhánh đó được chấp nhận. Điều này có nghĩa là một khi A khớp, B sẽ không được kiểm tra thêm, ngay cả khi nó sẽ tạo ra một trận đấu tổng thể dài hơn. Nói cách khác, toán tử
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0 không bao giờ tham lam. Để phù hợp với chữ
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0, sử dụng
re.match(pattern, string, flags=0)
86 hoặc đặt nó bên trong một lớp ký tự, như trong
re.match(pattern, string, flags=0)
87.

re.match(pattern, string, flags=0)
88

Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn, và chỉ ra sự khởi đầu và kết thúc của một nhóm; Nội dung của một nhóm có thể được truy xuất sau khi một trận đấu được thực hiện và có thể được khớp sau trong chuỗi với chuỗi đặc biệt

re.match(pattern, string, flags=0)
89, được mô tả bên dưới. Để phù hợp với các chữ
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
1 hoặc
re.match(pattern, string, flags=0)
59, hãy sử dụng
re.match(pattern, string, flags=0)
92 hoặc
re.match(pattern, string, flags=0)
93 hoặc gửi chúng bên trong một lớp ký tự:
re.match(pattern, string, flags=0)
94,
re.match(pattern, string, flags=0)
95.

re.match(pattern, string, flags=0)
96

Đây là một ký hiệu mở rộng (A

re.match(pattern, string, flags=0)
13 theo
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
1 không có ý nghĩa nếu không). Nhân vật đầu tiên sau
re.match(pattern, string, flags=0)
13 xác định ý nghĩa và cú pháp tiếp theo của cấu trúc là gì. Phần mở rộng thường không tạo ra một nhóm mới;
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
00 là ngoại lệ duy nhất cho quy tắc này. Sau đây là các phần mở rộng hiện được hỗ trợ.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
01

. Các chữ cái đặt các cờ tương ứng:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
09 (khớp ASCII-chỉ),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
10 (trường hợp bỏ qua),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
11 (phụ thuộc vào ngôn ngữ),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
12 (đa dòng),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
13 (DOT khớp với tất cả Verbose), cho toàn bộ biểu thức chính quy. . Cờ nên được sử dụng đầu tiên trong chuỗi biểu thức.Module Contents.) This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
16 function. Flags should be used first in the expression string.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
17

Một phiên bản không bắt giữ của dấu ngoặc đơn thông thường. Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn, nhưng phần phụ mà nhóm không thể được truy xuất sau khi thực hiện một trận đấu hoặc được tham chiếu sau trong mẫu.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
18

. Cờ:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
09 (khớp ASCII-chỉ),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
10 (trường hợp bỏ qua),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
11 (phụ thuộc vào địa phương),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
12 (đa dòng),
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
13 (DOT khớp với tất cả một phần của biểu thức. (Các cờ được mô tả trong nội dung mô -đun.)Module Contents.)

Các chữ cái

re.split(pattern, string, maxsplit=0, flags=0)
4,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
04 và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
07 loại trừ lẫn nhau khi được sử dụng làm cờ nội tuyến, vì vậy chúng có thể được kết hợp hoặc theo dõi
re.match(pattern, string, flags=0)
44. Thay vào đó, khi một trong số chúng xuất hiện trong một nhóm nội tuyến, nó sẽ ghi đè chế độ phù hợp trong nhóm kèm theo. Trong các mẫu Unicode
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
42 chuyển sang khớp ASCII-MONY và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
43 chuyển sang khớp unicode (mặc định). Trong mẫu byte
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
44 chuyển sang địa phương tùy thuộc vào khớp và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
42 chuyển sang khớp ASCII-chỉ (mặc định). Ghi đè này chỉ có hiệu lực cho nhóm nội tuyến hẹp và chế độ khớp ban đầu được khôi phục bên ngoài nhóm.

Mới trong phiên bản 3.6.

Đã thay đổi trong phiên bản 3.7: Các chữ cái

re.split(pattern, string, maxsplit=0, flags=0)
4,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
04 và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
07 cũng có thể được sử dụng trong một nhóm.The letters
re.split(pattern, string, maxsplit=0, flags=0)
4,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
04 and
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
07 also can be used in a group.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
00

Tương tự như dấu ngoặc đơn thông thường, nhưng phần phụ được khớp với tên nhóm có thể truy cập thông qua tên nhóm tượng trưng. Tên nhóm phải là định danh Python hợp lệ và mỗi tên nhóm chỉ được xác định một lần trong một biểu thức chính quy. Một nhóm tượng trưng cũng là một nhóm được đánh số, giống như nhóm không được đặt tên.

Các nhóm được đặt tên có thể được tham chiếu trong ba bối cảnh. Nếu mẫu là

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
50 (nghĩa là khớp một chuỗi được trích dẫn với trích dẫn đơn hoặc đôi):

Bối cảnh tham khảo về nhóm Trích dẫn

Các cách để tham khảo nó

trong cùng một mẫu

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    51 (như được hiển thị)

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    52

Khi xử lý đối tượng khớp m

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    53

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    54 (v.v.)

Trong một chuỗi được chuyển đến đối số thay thế của

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
55

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    56

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    57

  • pattern : Đây là chuỗn cần so khớp.
    string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
    flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
    
    52

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
59

Một bản sao lưu cho một nhóm được đặt tên; Nó phù hợp với bất kỳ văn bản nào phù hợp với tên nhóm trước đó được đặt tên.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
60

Một lời bình luận; Nội dung của dấu ngoặc đơn giản là bỏ qua.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
61

Khớp nếu

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
62 khớp với tiếp theo, nhưng không tiêu thụ bất kỳ chuỗi nào. Đây được gọi là một khẳng định lookahead. Ví dụ:
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
63 sẽ khớp với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
64 chỉ khi nó theo sau là
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
65.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
66

Phù hợp nếu

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
62 không phù hợp với tiếp theo. Đây là một khẳng định cái nhìn tiêu cực. Ví dụ:
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
68 sẽ khớp với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
64 chỉ khi nó không theo sau là
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
65.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
71

Khớp nếu vị trí hiện tại trong chuỗi được đi trước bởi một trận đấu cho

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
62 kết thúc ở vị trí hiện tại. Điều này được gọi là một khẳng định tầm nhìn tích cực.
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
73 sẽ tìm thấy một trận đấu trong
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
74, vì Lookbehind sẽ sao lưu 3 ký tự và kiểm tra xem mẫu chứa có khớp không. Mẫu chứa chỉ phải khớp với các chuỗi có độ dài cố định, nghĩa là
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
75 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
76 được cho phép, nhưng không phải là
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
77 và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
78. Lưu ý rằng các mẫu bắt đầu với các xác nhận Lookehind tích cực sẽ không khớp khi bắt đầu chuỗi được tìm kiếm; Rất có thể bạn sẽ muốn sử dụng chức năng
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 thay vì hàm
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80:

re.match(pattern, string, flags=0)
0

Ví dụ này tìm kiếm một từ sau một dấu gạch nối:

re.match(pattern, string, flags=0)
1

Đã thay đổi trong phiên bản 3.5: Đã thêm hỗ trợ cho các tài liệu tham khảo nhóm có độ dài cố định.Added support for group references of fixed length.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
81

Khớp nếu vị trí hiện tại trong chuỗi không đi trước một trận đấu cho

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
62. Đây được gọi là một khẳng định tiêu cực. Tương tự như các khẳng định hướng tích cực, mẫu chứa chỉ phải khớp với một số chuỗi có độ dài cố định. Các mẫu bắt đầu với các xác nhận trông tiêu cực có thể khớp với đầu chuỗi được tìm kiếm.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
83

Sẽ cố gắng khớp với

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
84 nếu nhóm có ID hoặc tên đã cho tồn tại và với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
85 nếu nó không có.
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
85 là tùy chọn và có thể được bỏ qua. Ví dụ:
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
87 là một mẫu khớp email kém, sẽ phù hợp với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
88 cũng như
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
89, nhưng không phải với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
90 cũng không
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
91.

Các chuỗi đặc biệt bao gồm

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và một ký tự từ danh sách dưới đây. Nếu ký tự thông thường không phải là chữ số ASCII hoặc chữ ASCII, thì kết quả sẽ phù hợp với ký tự thứ hai. Ví dụ,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
93 khớp với ký tự
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
94.

re.match(pattern, string, flags=0)
89

Khớp với nội dung của nhóm của cùng một số. Các nhóm được đánh số bắt đầu từ 1. Ví dụ:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
96 khớp với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
97 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
98, nhưng không phải
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
99 (lưu ý không gian sau nhóm). Trình tự đặc biệt này chỉ có thể được sử dụng để phù hợp với một trong 99 nhóm đầu tiên. Nếu chữ số đầu tiên của số là 0, hoặc số dài 3 chữ số, nó sẽ không được hiểu là khớp nhóm, nhưng là ký tự có số giá trị bát phân. Bên trong
re.match(pattern, string, flags=0)
74 và
re.match(pattern, string, flags=0)
70 của một lớp ký tự, tất cả các lối thoát số được coi là ký tự.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
02

Chỉ khớp khi bắt đầu chuỗi.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03

Khớp với chuỗi trống, nhưng chỉ ở đầu hoặc cuối của một từ. Một từ được định nghĩa là một chuỗi các ký tự từ. Lưu ý rằng chính thức,

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03 được định nghĩa là ranh giới giữa ký tự
re.match(pattern, string, flags=0)
60 và
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
06 (hoặc ngược lại) hoặc giữa
re.match(pattern, string, flags=0)
60 và đầu/đầu của chuỗi. Điều này có nghĩa là
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
08 khớp với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
09,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
10,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
11,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
12 nhưng không phải
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
13 hoặc
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
14.

Theo mặc định Unicode Alphanumerics là những người được sử dụng trong các mẫu Unicode, nhưng điều này có thể được thay đổi bằng cách sử dụng cờ

re.match(pattern, string, flags=0)
62. Ranh giới từ được xác định bởi địa phương hiện tại nếu cờ
re.match(pattern, string, flags=0)
63 được sử dụng. Bên trong một phạm vi ký tự,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03 đại diện cho ký tự backspace, để tương thích với các chữ Python.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
18

Khớp với chuỗi trống, nhưng chỉ khi nó không ở đầu hoặc cuối của một từ. Điều này có nghĩa là

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
19 khớp với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
20,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
21,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
22, nhưng không phải
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
23,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
24 hoặc
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
25.
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
18 hoàn toàn trái ngược với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03, vì vậy các ký tự từ trong các mẫu Unicode là Unicode Alphanumerics hoặc Undercore, mặc dù điều này có thể được thay đổi bằng cách sử dụng cờ
re.match(pattern, string, flags=0)
62. Ranh giới từ được xác định bởi địa phương hiện tại nếu cờ
re.match(pattern, string, flags=0)
63 được sử dụng.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
30 cho các mẫu Unicode (STR):

Khớp với bất kỳ chữ số thập phân unicode nào (nghĩa là, bất kỳ ký tự nào trong danh mục ký tự Unicode [nd]). Điều này bao gồm

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
31, và nhiều ký tự chữ số khác. Nếu cờ
re.match(pattern, string, flags=0)
62 chỉ được sử dụng
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
31 được khớp.

Cho các mẫu 8 bit (byte):

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
31.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
35

Phù hợp với bất kỳ ký tự nào không phải là một chữ số thập phân. Đây là điều ngược lại với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
30. Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, điều này sẽ trở thành tương đương với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
38.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
39 cho các mẫu Unicode (STR):

Khớp với các ký tự khoảng trắng Unicode (bao gồm

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 và cũng có nhiều ký tự khác, ví dụ như các không gian không phá vỡ được ủy quyền bởi các quy tắc typography bằng nhiều ngôn ngữ). Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, chỉ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 được khớp.

Cho các mẫu 8 bit (byte):

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
31.

Phù hợp với bất kỳ ký tự nào không phải là một chữ số thập phân. Đây là điều ngược lại với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
30. Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, điều này sẽ trở thành tương đương với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
38.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
39 cho các mẫu Unicode (STR):

Khớp với các ký tự khoảng trắng Unicode (bao gồm
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 và cũng có nhiều ký tự khác, ví dụ như các không gian không phá vỡ được ủy quyền bởi các quy tắc typography bằng nhiều ngôn ngữ). Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, chỉ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 được khớp.

Phù hợp với các ký tự được coi là khoảng trắng trong bộ ký tự ASCII; Điều này tương đương với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40.

Cho các mẫu 8 bit (byte):

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

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
31.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
06

Phù hợp với bất kỳ ký tự nào không phải là một chữ số thập phân. Đây là điều ngược lại với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
30. Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, điều này sẽ trở thành tương đương với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
38.

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
58

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
39 cho các mẫu Unicode (STR):

Khớp với các ký tự khoảng trắng Unicode (bao gồm

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 và cũng có nhiều ký tự khác, ví dụ như các không gian không phá vỡ được ủy quyền bởi các quy tắc typography bằng nhiều ngôn ngữ). Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, chỉ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40 được khớp.

re.match(pattern, string, flags=0)
2

Phù hợp với các ký tự được coi là khoảng trắng trong bộ ký tự ASCII; Điều này tương đương với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
40.

re.match(pattern, string, flags=0)
61

Phù hợp với bất kỳ ký tự nào không phải là ký tự khoảng trắng. Đây là điều ngược lại với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
39. Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, điều này sẽ trở thành tương đương với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
47.

re.match(pattern, string, flags=0)
60 cho các mẫu unicode (str):The
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
60 and
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
61 escape sequences have been added.

Khớp với các ký tự từ unicode; Điều này bao gồm hầu hết các ký tự có thể là một phần của một từ trong bất kỳ ngôn ngữ nào, cũng như các số và dấu gạch dưới. Nếu cờ

re.match(pattern, string, flags=0)
62 được sử dụng, chỉ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
50 được khớp.Unknown escapes consisting of
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 and an ASCII letter now are errors.

Phù hợp với các ký tự được coi là chữ và số trong bộ ký tự ASCII; Điều này tương đương với

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
50. Nếu cờ
re.match(pattern, string, flags=0)
63 được sử dụng, khớp các ký tự được coi là chữ và số trong địa phương hiện tại và dấu gạch dưới.The
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
66 escape sequence has been added. As in string literals, it expands to the named Unicode character (e.g.
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
67).

Khớp với bất kỳ ký tự nào không phải là một ký tự từ. Đây là điều ngược lại với re.match(pattern, string, flags=0) 60. Nếu cờ re.match(pattern, string, flags=0) 62 được sử dụng, điều này sẽ trở thành tương đương với >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds") >>> m.group('first_name') 'Malcolm' >>> m.group('last_name') 'Reynolds' 56. Nếu cờ re.match(pattern, string, flags=0) 63 được sử dụng, khớp các ký tự không phải là chữ và số trong địa phương hiện tại cũng như dấu gạch dưới.

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

Cờ

Đã thay đổi trong phiên bản 3.6: Hằng số cờ hiện là các trường hợp là

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
68, là một lớp con của
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
69.Flag constants are now instances of
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
68, which is a subclass of
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
69.

________ 370 ________ 371¶ ________ 370 ________ 373¶

Tạo

re.match(pattern, string, flags=0)
60,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
06,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
18,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
30,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
35,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
39 và
re.match(pattern, string, flags=0)
61 thực hiện kết hợp ASCII-chỉ khớp thay vì khớp unicode đầy đủ. Điều này chỉ có ý nghĩa đối với các mẫu Unicode và bị bỏ qua cho các mẫu byte. Tương ứng với cờ nội tuyến
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
82.

Lưu ý rằng để tương thích ngược, cờ

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
14 vẫn tồn tại (cũng như từ đồng nghĩa của nó
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
84 và đối tác nhúng của nó ).

________ 370 ________ 387¶

Hiển thị thông tin gỡ lỗi về biểu thức biên dịch. Không có cờ nội tuyến tương ứng.

________ 370 ________ 389¶ ________ 370 ________ 391¶

Thực hiện kết hợp không nhạy cảm trường hợp; Biểu thức như

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
92 cũng sẽ phù hợp với các chữ cái viết thường. Kết hợp unicode đầy đủ (chẳng hạn như
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
93 khớp
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
94) cũng hoạt động trừ khi cờ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
95 được sử dụng để vô hiệu hóa các trận đấu không ASCII. Địa điểm hiện tại không thay đổi hiệu ứng của cờ này trừ khi cờ
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
96 cũng được sử dụng. Tương ứng với cờ nội tuyến
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
97.

Lưu ý rằng khi các mẫu Unicode

re.match(pattern, string, flags=0)
45 hoặc
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
92 được sử dụng kết hợp với cờ
re.search(pattern, string, flags=0)
00, chúng sẽ khớp với 52 chữ cái ASCII và 4 chữ cái không ASCII bổ sung: ' 'ı' (U+0131, chữ nhỏ Latin Dotless i), 'ſ' (u+017f, chữ nhỏ Latin dài s) và 'k' (u+212a, dấu hiệu Kelvin). Nếu cờ
re.match(pattern, string, flags=0)
62 được sử dụng, chỉ có các chữ cái ‘A, thành‘ Z, và ‘A, với’ Z, được khớp.

________ 370 ________ 403¶ ________ 370 ________ 405¶

Tạo

re.match(pattern, string, flags=0)
60,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
06,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
03,
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
18 và kết hợp không nhạy cảm trường hợp phụ thuộc vào địa phương hiện tại. Cờ này chỉ có thể được sử dụng với các mẫu byte. Việc sử dụng lá cờ này không được khuyến khích vì cơ chế địa phương rất không đáng tin cậy, nó chỉ xử lý một nền văn hóa của người Hồi giáo tại một thời điểm và nó chỉ hoạt động với các địa phương 8 bit. Kết hợp Unicode đã được bật theo mặc định trong Python 3 cho các mẫu Unicode (STR) và nó có thể xử lý các địa phương/ngôn ngữ khác nhau. Tương ứng với cờ nội tuyến
re.search(pattern, string, flags=0)
10.

Đã thay đổi trong phiên bản 3.6:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
96 chỉ có thể được sử dụng với các mẫu byte và không tương thích với
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
95.
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
96 can be used only with bytes patterns and is not compatible with
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
95.

Đã thay đổi trong phiên bản 3.7: Được biên dịch các đối tượng biểu thức chính quy bằng cờ

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
96 không còn phụ thuộc vào ngôn ngữ tại thời điểm biên dịch. Chỉ địa phương tại thời điểm phù hợp mới ảnh hưởng đến kết quả của việc phù hợp.Compiled regular expression objects with the
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
96 flag no longer depend on the locale at compile time. Only the locale at matching time affects the result of matching.

________ 370 ________ 415¶ ________ 370 ________ 417¶

Khi được chỉ định, ký tự mẫu

re.match(pattern, string, flags=0)
64 khớp ở đầu chuỗi và ở đầu mỗi dòng (ngay sau mỗi dòng mới); và ký tự mẫu
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
94 khớp ở cuối chuỗi và ở cuối mỗi dòng (ngay trước mỗi dòng mới). Theo mặc định,
re.match(pattern, string, flags=0)
64 chỉ khớp với đầu chuỗi và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
94 chỉ ở cuối chuỗi và ngay trước dòng mới (nếu có) ở cuối chuỗi. Tương ứng với cờ nội tuyến
re.search(pattern, string, flags=0)
22.

________ 370 ________ 424¶ ________ 370 ________ 426¶

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

re.search(pattern, string, flags=0)
27 khớp với bất kỳ nhân vật nào, bao gồm cả dòng mới; Không có cờ này,
re.search(pattern, string, flags=0)
27 sẽ khớp với bất cứ điều gì ngoại trừ một dòng mới. Tương ứng với cờ nội tuyến
re.search(pattern, string, flags=0)
29.

________ 370 ________ 431¶ ________ 370 ________ 433¶

Cờ này cho phép bạn viết các biểu thức thông thường trông đẹp hơn và dễ đọc hơn bằng cách cho phép bạn các phần logic tách biệt trực quan của mẫu và thêm nhận xét. Khoảng trắng trong mẫu bị bỏ qua, ngoại trừ khi trong một lớp ký tự hoặc khi đi trước bởi một dấu gạch chéo ngược không được phân loại hoặc trong các mã thông báo như

re.match(pattern, string, flags=0)
08,
re.search(pattern, string, flags=0)
35 hoặc
re.search(pattern, string, flags=0)
36. Ví dụ,
re.search(pattern, string, flags=0)
37 và
re.search(pattern, string, flags=0)
38 không được phép. Khi một dòng chứa một
re.search(pattern, string, flags=0)
39 không nằm trong một lớp ký tự và không được đặt trước bởi một dấu gạch chéo ngược không được phân loại, tất cả các ký tự từ
re.search(pattern, string, flags=0)
39 đến cuối cùng bên trái cho đến cuối dòng đều bị bỏ qua.

Điều này có nghĩa là hai đối tượng biểu thức chính quy sau phù hợp với số thập phân có chức năng bằng nhau:

re.match(pattern, string, flags=0)
3

Tương ứng với cờ nội tuyến

re.search(pattern, string, flags=0)
41.

Chức năng¶

________ 370 ________ 443 (mẫu, cờ = 0) ¶(pattern, flags=0)

Biên dịch một mẫu biểu thức chính quy thành một đối tượng biểu thức chính quy, có thể được sử dụng để kết hợp bằng cách sử dụng

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 và các phương pháp khác, được mô tả dưới đây.regular expression object, which can be used for matching using its
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 and other methods, described below.

Hành vi biểu thức có thể được sửa đổi bằng cách chỉ định giá trị cờ. Các giá trị có thể là bất kỳ biến nào sau đây, kết hợp bằng bitwise hoặc (toán tử

re.match(pattern, string, flags=0)
80).

Trình tự

re.match(pattern, string, flags=0)
4

tương đương với

re.match(pattern, string, flags=0)
5

Nhưng sử dụng

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
16 và lưu đối tượng biểu thức chính quy kết quả để sử dụng lại hiệu quả hơn khi biểu thức sẽ được sử dụng nhiều lần trong một chương trình.

Ghi chú

Các phiên bản được biên dịch của các mẫu gần đây nhất được chuyển đến

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
16 và các hàm khớp cấp mô-đun được lưu trữ, vì vậy các chương trình chỉ sử dụng một vài biểu thức thông thường tại một thời điểm cần phải lo lắng về việc biên dịch các biểu thức chính quy.

________ 370 ________ 450 (mẫu, chuỗi, cờ = 0) ¶(pattern, string, flags=0)

Quét qua chuỗi Tìm kiếm vị trí đầu tiên nơi mẫu biểu thức chính quy tạo ra một khớp và trả về một đối tượng khớp tương ứng. Trả về

re.search(pattern, string, flags=0)
51 nếu không có vị trí nào trong chuỗi khớp với mẫu; Lưu ý rằng điều này khác với việc tìm một trận đấu có độ dài bằng không tại một số điểm trong chuỗi.match object. Return
re.search(pattern, string, flags=0)
51 if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

________ 370 ________ 453 (mẫu, chuỗi, cờ = 0) ¶(pattern, string, flags=0)

Nếu số không hoặc nhiều ký tự ở đầu chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một đối tượng khớp tương ứng. Trả về

re.search(pattern, string, flags=0)
51 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return
re.search(pattern, string, flags=0)
51 if the string does not match the pattern; note that this is different from a zero-length match.

Lưu ý rằng ngay cả trong chế độ

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
2,
re.search(pattern, string, flags=0)
56 sẽ chỉ khớp ở đầu chuỗi chứ không phải ở đầu mỗi dòng.

Nếu bạn muốn xác định vị trí đối sánh ở bất cứ đâu trong chuỗi, hãy sử dụng

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 thay thế (xem thêm search () so với match ()).search() vs. match()).

________ 370 ________ 459 (mẫu, chuỗi, cờ = 0) ¶(pattern, string, flags=0)

Nếu toàn bộ chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một đối tượng khớp tương ứng. Trả về

re.search(pattern, string, flags=0)
51 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return
re.search(pattern, string, flags=0)
51 if the string does not match the pattern; note that this is different from a zero-length match.

Mới trong phiên bản 3.4.

________ 370 ________ 462 (mẫu, chuỗi, maxsplit = 0, cờ = 0) ¶(pattern, string, maxsplit=0, flags=0)

Chuỗi phân chia theo các lần xuất hiện của mẫu. Nếu chụp dấu ngoặc đơn được sử dụng trong mẫu, thì văn bản của tất cả các nhóm trong mẫu cũng được trả về như một phần của danh sách kết quả. Nếu MAXSplit là không khác biệt, tại hầu hết các phân tách MaxSplit xảy ra và phần còn lại của chuỗi được trả về làm yếu tố cuối cùng của danh sách.

re.match(pattern, string, flags=0)
6

Nếu có các nhóm bắt giữ trong dấu phân cách và nó khớp với đầu chuỗi, kết quả sẽ bắt đầu bằng một chuỗi trống. Tương tự giữ cho phần cuối của chuỗi:

re.match(pattern, string, flags=0)
7

Bằng cách đó, các thành phần phân tách luôn được tìm thấy tại cùng một chỉ số tương đối trong danh sách kết quả.

Các khớp trống cho mẫu chỉ chia chuỗi khi không liền kề với trận đấu trống trước đó.

re.match(pattern, string, flags=0)
8

Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument.

Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ chia tách trên một mẫu có thể khớp với một chuỗi trống.Added support of splitting on a pattern that could match an empty string.

________ 370 ________ 464 (mẫu, chuỗi, cờ = 0) ¶(pattern, string, flags=0)

Trả về tất cả các trận đấu không chồng chéo của mẫu trong chuỗi, như một danh sách các chuỗi hoặc bộ dữ liệu. Chuỗi được quét từ trái sang phải và các trận đấu được trả về theo thứ tự được tìm thấy. Các trận đấu trống được bao gồm trong kết quả.

Kết quả phụ thuộc vào số lượng nhóm chụp trong mẫu. Nếu không có nhóm, hãy trả lại một danh sách các chuỗi phù hợp với toàn bộ mẫu. Nếu có chính xác một nhóm, hãy trả lại một danh sách các chuỗi khớp với nhóm đó. Nếu có nhiều nhóm có mặt, hãy trả lại một danh sách các bộ dữ liệu phù hợp với các nhóm. Các nhóm không bắt giữ không ảnh hưởng đến hình thức của kết quả.

re.match(pattern, string, flags=0)
9

Đã thay đổi trong phiên bản 3.7: Các trận đấu không trống hiện có thể bắt đầu ngay sau trận đấu trống trước đó.Non-empty matches can now start just after a previous empty match.

________ 370 ________ 466 (mẫu, chuỗi, cờ = 0) ¶(pattern, string, flags=0)

Trả về một iterator mang lại các đối tượng khớp trên tất cả các kết quả không chồng chéo cho mẫu RE trong chuỗi. Chuỗi được quét từ trái sang phải và các trận đấu được trả về theo thứ tự được tìm thấy. Các trận đấu trống được bao gồm trong kết quả.iterator yielding match objects over all non-overlapping matches for the RE pattern in string. The string is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result.

Đã thay đổi trong phiên bản 3.7: Các trận đấu không trống hiện có thể bắt đầu ngay sau trận đấu trống trước đó.Non-empty matches can now start just after a previous empty match.

________ 370 ________ 466 (mẫu, chuỗi, cờ = 0) ¶(pattern, repl, string, count=0, flags=0)

Trả về một iterator mang lại các đối tượng khớp trên tất cả các kết quả không chồng chéo cho mẫu RE trong chuỗi. Chuỗi được quét từ trái sang phải và các trận đấu được trả về theo thứ tự được tìm thấy. Các trận đấu trống được bao gồm trong kết quả.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
0

________ 370 ________ 468 (mẫu, repl, chuỗi, đếm = 0, cờ = 0)match object argument, and returns the replacement string. For example:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
1

Các mẫu có thể là một chuỗi hoặc một đối tượng mẫu.pattern object.

Số lượng đối số tùy chọn là số lượng tối đa của các lần xuất hiện mẫu được thay thế; Đếm phải là một số nguyên không âm. Nếu bị bỏ qua hoặc không, tất cả các lần xuất hiện sẽ được thay thế. Các trận đấu trống cho mẫu chỉ được thay thế khi không liền kề với trận đấu trống trước đó, do đó

re.search(pattern, string, flags=0)
73 trả về
re.search(pattern, string, flags=0)
74.

Trong các đối số thay thế loại chuỗi, ngoài các ký tự thoát ra và các bản sao lưu được mô tả ở trên,

re.search(pattern, string, flags=0)
75 sẽ sử dụng chuỗi con phù hợp với nhóm có tên
re.search(pattern, string, flags=0)
76, theo định nghĩa của cú pháp
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
00.
re.search(pattern, string, flags=0)
78 sử dụng số nhóm tương ứng; Do đó,
re.search(pattern, string, flags=0)
79 tương đương với
re.search(pattern, string, flags=0)
80, nhưng không phải là mơ hồ trong việc thay thế như
re.search(pattern, string, flags=0)
81.
re.search(pattern, string, flags=0)
82 sẽ được hiểu là tham chiếu đến nhóm 20, không phải là tham chiếu đến nhóm 2, sau đó là ký tự nghĩa đen
re.split(pattern, string, maxsplit=0, flags=0)
5. Các bản thay thế lại
re.search(pattern, string, flags=0)
84 trong toàn bộ chuỗi con phù hợp với RE.

Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument.

Thay đổi trong phiên bản 3.5: Các nhóm chưa từng có được thay thế bằng một chuỗi trống.Unmatched groups are replaced with an empty string.

Đã thay đổi trong phiên bản 3.6: Các ESCAPES chưa biết trong mẫu bao gồm

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và một chữ cái ASCII hiện là lỗi.Unknown escapes in pattern consisting of
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 and an ASCII letter now are errors.

Đã thay đổi trong phiên bản 3.7: Các lối thoát không xác định trong việc thay thế bao gồm

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và một chữ cái ASCII hiện là lỗi.Unknown escapes in repl consisting of
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 and an ASCII letter now are errors.

Đã thay đổi trong phiên bản 3.7: Các khớp trống cho mẫu được thay thế khi liền kề với trận đấu không trống trước đó.Empty matches for the pattern are replaced when adjacent to a previous non-empty match.

________ 370 ________ 488 (mẫu, repl, chuỗi, đếm = 0, cờ = 0)(pattern, repl, string, count=0, flags=0)

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

re.search(pattern, string, flags=0)
89, nhưng trả về một tuple
re.search(pattern, string, flags=0)
90.

Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument.

Thay đổi trong phiên bản 3.5: Các nhóm chưa từng có được thay thế bằng một chuỗi trống.Unmatched groups are replaced with an empty string.

Đã thay đổi trong phiên bản 3.6: Các ESCAPES chưa biết trong mẫu bao gồm
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và một chữ cái ASCII hiện là lỗi.(pattern)

Đã thay đổi trong phiên bản 3.7: Các lối thoát không xác định trong việc thay thế bao gồm

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1 và một chữ cái ASCII hiện là lỗi.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
2

Đã thay đổi trong phiên bản 3.7: Các khớp trống cho mẫu được thay thế khi liền kề với trận đấu không trống trước đó.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
3

________ 370 ________ 488 (mẫu, repl, chuỗi, đếm = 0, cờ = 0)The

re.search(pattern, string, flags=0)
95 character is no longer escaped.

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

re.search(pattern, string, flags=0)
89, nhưng trả về một tuple
re.search(pattern, string, flags=0)
90.Only characters that can have special meaning in a regular expression are escaped. As a result,
re.search(pattern, string, flags=0)
96,
re.search(pattern, string, flags=0)
97,
re.search(pattern, string, flags=0)
98,
re.search(pattern, string, flags=0)
99,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
00,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
01,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
02,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
03,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
90,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
05,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
91,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
07, and
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
08 are no longer escaped.

________ 370 ________ 492 (mẫu) ¶()

Thoát khỏi các ký tự đặc biệt trong mẫu. Điều này rất hữu ích nếu bạn muốn khớp với một chuỗi theo nghĩa đen tùy ý có thể có các metacharacters biểu thức thông thường trong đó. Ví dụ:

Chức năng này không được sử dụng cho chuỗi thay thế trong re.search(pattern, string, flags=0) 89 và re.search(pattern, string, flags=0) 94, chỉ nên thoát khỏi các dấu gạch chéo ngược. Ví dụ:

Đã thay đổi trong phiên bản 3.3: ký tự
re.search(pattern, string, flags=0)
95 không còn thoát ra được.(msg, pattern=None, pos=None)

Thay đổi trong phiên bản 3.7: Chỉ các ký tự có thể có ý nghĩa đặc biệt trong một biểu thức chính quy được thoát ra. Kết quả là,

re.search(pattern, string, flags=0)
96,
re.search(pattern, string, flags=0)
97,
re.search(pattern, string, flags=0)
98,
re.search(pattern, string, flags=0)
99,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
00,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
01,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
02,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
03,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
90,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
05,
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
91,
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
07 và
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
08.

________ 370 ________ 510 ()

Xóa bộ đệm biểu thức thông thường.

Ngoại lệ ha

Ngoại lệ ________ 370 ________ 512 (tin nhắn, mẫu = none, pos = none) ¶

Ngoại lệ được nêu ra khi một chuỗi được truyền cho một trong các hàm ở đây không phải là biểu thức chính quy hợp lệ (ví dụ, nó có thể chứa dấu ngoặc đơn chưa từng có) hoặc khi một số lỗi khác xảy ra trong quá trình biên dịch hoặc khớp. Nó không bao giờ là một lỗi nếu một chuỗi không có khớp với một mẫu. Trường hợp lỗi có các thuộc tính bổ sung sau:

________ 513¶

Thông báo lỗi chưa được định dạng.

________ 514¶

Các mẫu biểu thức chính quy.

________ 515¶

Chỉ số trong mẫu trong đó biên dịch không thành công (có thể là

re.search(pattern, string, flags=0)
51).Added additional attributes.

________ 517¶

Dòng tương ứng với POS (có thể là

re.search(pattern, string, flags=0)
51).

________ 519¶(string[, pos[, endpos]])

Cột tương ứng với POS (có thể là

re.search(pattern, string, flags=0)
51).match object. Return
re.search(pattern, string, flags=0)
51 if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

Đã thay đổi trong phiên bản 3.5: Đã thêm các thuộc tính bổ sung.

Đối tượng biểu thức chính quy

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
4

Đã biên dịch các đối tượng biểu thức chính quy hỗ trợ các phương thức và thuộc tính sau:(string[, pos[, endpos]])

________ 521 ________ 450 (Chuỗi [, pos [, endpos]])match object. Return

re.search(pattern, string, flags=0)
51 if the string does not match the pattern; note that this is different from a zero-length match.

Các tham số POS và EndPOS tùy chọn có cùng ý nghĩa với phương thức

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
5

Nếu bạn muốn xác định vị trí đối sánh ở bất cứ đâu trong chuỗi, hãy sử dụng

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 thay thế (xem thêm search () so với match ()).search() vs. match()).

________ 521 ________ 459 (Chuỗi [, pos [, endpos]])(string[, pos[, endpos]])

Nếu toàn bộ chuỗi khớp với biểu thức chính quy này, hãy trả về một đối tượng khớp tương ứng. Trả về

re.search(pattern, string, flags=0)
51 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return
re.search(pattern, string, flags=0)
51 if the string does not match the pattern; note that this is different from a zero-length match.

Các tham số POS và EndPOS tùy chọn có cùng ý nghĩa với phương thức

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
6

Mới trong phiên bản 3.4.

________ 521 ________ 462 (Chuỗi, MaxSplit = 0) ¶(string, maxsplit=0)

Giống hệt với hàm

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
40, sử dụng mẫu được biên dịch.

________ 521 ________ 464 (Chuỗi [, pos [, endpos]])(string[, pos[, endpos]])

Tương tự như hàm

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
43, sử dụng mẫu được biên dịch, nhưng cũng chấp nhận các tham số POS và EndPOS tùy chọn giới hạn vùng tìm kiếm như
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79.

________ 521 ________ 466 (Chuỗi [, pos [, endpos]])(string[, pos[, endpos]])

Tương tự như hàm

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
47, sử dụng mẫu được biên dịch, nhưng cũng chấp nhận các tham số POS và EndPOS tùy chọn giới hạn vùng tìm kiếm như
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79.

________ 521 ________ 468 (repl, chuỗi, đếm = 0) ¶(repl, string, count=0)

Giống hệt với hàm

re.search(pattern, string, flags=0)
89, sử dụng mẫu được biên dịch.

________ 521 ________ 488 (repl, chuỗi, đếm = 0) ¶(repl, string, count=0)

Giống hệt với hàm

re.search(pattern, string, flags=0)
94, sử dụng mẫu được biên dịch.

________ 521 ________ 556¶

Các lá cờ phù hợp với regex. Đây là sự kết hợp của các cờ được cung cấp cho

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
57, bất kỳ cờ nội tuyến
re.match(pattern, string, flags=0)
96 nào trong mẫu và các cờ ẩn như
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
59 nếu mẫu là chuỗi Unicode.

________ 521 ________ 561¶

Số lượng các nhóm chụp trong mẫu.

________ 521 ________ 563¶

Một bản đồ từ điển lập bản đồ bất kỳ tên nhóm tượng trưng nào được xác định bởi

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
64 cho các số nhóm. Từ điển trống nếu không có nhóm tượng trưng nào được sử dụng trong mẫu.

________ 521 ________ 514¶

Chuỗi mẫu mà từ đó đối tượng mẫu được biên dịch.

Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ của

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
67 và
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
68. Biên dịch các đối tượng biểu thức chính quy được xem xét nguyên tử.Added support of
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
67 and
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
68. Compiled regular expression objects are considered atomic.

Khớp đối tượng lor

Các đối tượng khớp luôn có giá trị boolean là

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
69. Vì
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 và
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 Trả về
re.search(pattern, string, flags=0)
51 Khi không có khớp, bạn có thể kiểm tra xem có một trận đấu với câu lệnh
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
73 đơn giản:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
7

Đối tượng khớp hỗ trợ các phương thức và thuộc tính sau:

________ 574 ________ 575 (mẫu)(template)

Trả về chuỗi thu được bằng cách thực hiện thay thế Backslash trên mẫu chuỗi mẫu, như được thực hiện bằng phương thức

re.search(pattern, string, flags=0)
89. Các lối thoát như
re.search(pattern, string, flags=0)
69 được chuyển đổi thành các ký tự thích hợp và các bản sao lưu số (
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
52,
re.search(pattern, string, flags=0)
80) và được đặt tên là Backreferences (
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
57,
re.search(pattern, string, flags=0)
75) được thay thế bằng nội dung của nhóm tương ứng.

Thay đổi trong phiên bản 3.5: Các nhóm chưa từng có được thay thế bằng một chuỗi trống.Unmatched groups are replaced with an empty string.

________ 574 ________ 583 ([Nhóm1, ...])([group1, ...])

Trả về một hoặc nhiều nhóm con của trận đấu. Nếu có một đối số duy nhất, kết quả là một chuỗi duy nhất; Nếu có nhiều đối số, kết quả là một tuple với một mục cho mỗi đối số. Không có đối số, Group1 mặc định về 0 (toàn bộ trận đấu được trả về). Nếu một đối số nhóm bằng không, giá trị trả về tương ứng là toàn bộ chuỗi khớp; Nếu nó nằm trong phạm vi bao gồm [1..99], thì đó là chuỗi phù hợp với nhóm dấu ngoặc đơn tương ứng. Nếu một số nhóm âm hoặc lớn hơn số lượng nhóm được xác định trong mẫu, ngoại lệ

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
84 sẽ được nâng lên. Nếu một nhóm được chứa trong một phần của mẫu không khớp, kết quả tương ứng là
re.search(pattern, string, flags=0)
51. Nếu một nhóm được chứa trong một phần của mẫu phù hợp với nhiều lần, trận đấu cuối cùng sẽ được trả về.

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
8

Nếu biểu thức chính quy sử dụng cú pháp

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
00, các đối số nhóm cũng có thể là các chuỗi xác định các nhóm theo tên nhóm của chúng. Nếu một đối số chuỗi không được sử dụng làm tên nhóm trong mẫu, ngoại lệ
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
84 sẽ được nêu ra.

Một ví dụ phức tạp vừa phải:

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
9

Các nhóm được đặt tên cũng có thể được đề cập bởi chỉ mục của họ:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
0

Nếu một nhóm khớp với nhiều lần, chỉ có thể truy cập được trận đấu cuối cùng:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
1

________ 574 ________ 589 (g) ¶(g)

Điều này giống hệt với

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
90. Điều này cho phép truy cập dễ dàng hơn vào một nhóm cá nhân từ một trận đấu:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
2

Mới trong phiên bản 3.6.

________ 574 ________ 561 (mặc định = không) ¶(default=None)

Trả về một tuple chứa tất cả các nhóm nhỏ của trận đấu, từ 1 trở lên tuy nhiên nhiều nhóm nằm trong mẫu. Đối số mặc định được sử dụng cho các nhóm không tham gia vào trận đấu; Nó mặc định là

re.search(pattern, string, flags=0)
51.

Ví dụ:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
3

Nếu chúng ta thực hiện vị trí thập phân và mọi thứ sau khi nó tùy chọn, không phải tất cả các nhóm có thể tham gia vào trận đấu. Các nhóm này sẽ mặc định là

re.search(pattern, string, flags=0)
51 trừ khi đối số mặc định được đưa ra:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
4

________ 574 ________ 596 (mặc định = không) ¶(default=None)

Trả về một từ điển chứa tất cả các nhóm nhỏ được đặt tên của trận đấu, được khóa bởi tên phân nhóm. Đối số mặc định được sử dụng cho các nhóm không tham gia vào trận đấu; Nó mặc định là

re.search(pattern, string, flags=0)
51. Ví dụ:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
5

________ 574 ________ 599 ([Nhóm]) ________ 574 ________ 601 ([Nhóm]) ¶([group])
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
74
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
01([group])

Trả về các chỉ số của phần bắt đầu và kết thúc của chuỗi con phù hợp với nhóm; Nhóm mặc định về 0 (có nghĩa là toàn bộ chuỗi con phù hợp). Trả lại

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
02 nếu nhóm tồn tại nhưng không đóng góp cho trận đấu. Đối với một đối tượng khớp m và nhóm G đã đóng góp cho trận đấu, phần phụ phù hợp với nhóm G (tương đương với
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
90) là

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
6

Lưu ý rằng

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
04 sẽ bằng
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
05 nếu nhóm khớp với chuỗi null. Ví dụ, sau
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
06,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
07 là 1,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
08 là 2,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
09 và
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
10 đều là 2 và
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
11 làm tăng ngoại lệ
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
84.

Một ví dụ sẽ loại bỏ Remove_this khỏi địa chỉ email:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
7

________ 574 ________ 614 ([Nhóm])([group])

Đối với một trận đấu M, trả lại 2-Tuple

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
15. Lưu ý rằng nếu nhóm không đóng góp cho trận đấu, đây là
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
16. Nhóm mặc định về 0, toàn bộ trận đấu.

________ 574 ________ 515¶

Giá trị của POS được chuyển đến phương thức

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 của một đối tượng regex. Đây là chỉ mục vào chuỗi mà động cơ RE bắt đầu tìm kiếm một trận đấu.regex object. This is the index into the string at which the RE engine started looking for a match.

________ 574 ________ 622¶

Giá trị của các endpos được chuyển đến phương thức

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 của một đối tượng regex. Đây là chỉ mục vào chuỗi mà động cơ RE sẽ không đi.regex object. This is the index into the string beyond which the RE engine will not go.

________ 574 ________ 626¶

Chỉ số số nguyên của nhóm bắt giữ phù hợp cuối cùng, hoặc

re.search(pattern, string, flags=0)
51 nếu không có nhóm nào được khớp. Ví dụ: các biểu thức
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
28,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
29 và
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
30 sẽ có
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
31 nếu được áp dụng cho chuỗi
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
32, trong khi biểu thức
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
33 sẽ có
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
34, nếu được áp dụng cho cùng một chuỗi.

________ 574 ________ 636¶

Tên của nhóm bắt giữ phù hợp cuối cùng, hoặc

re.search(pattern, string, flags=0)
51 nếu nhóm không có tên, hoặc nếu không có nhóm nào được khớp.

________ 574 ________ 639¶

Đối tượng biểu thức chính quy có phương thức

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 đã tạo ra thể hiện đối sánh này.regular expression object whose
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 or
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 method produced this match instance.

________ 574 ________ 643¶

Chuỗi được chuyển đến

pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 hoặc
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79.

Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ của

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
67 và
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
68. Các đối tượng phù hợp được xem xét nguyên tử.Added support of
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
67 and
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
68. Match objects are considered atomic.

Ví dụ biểu hiện chính quy

Kiểm tra một cặp

Trong ví dụ này, chúng tôi sẽ sử dụng chức năng trợ giúp sau để hiển thị các đối tượng phù hợp hơn một chút một cách duyên dáng hơn một chút:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
8

Giả sử bạn đang viết một chương trình poker trong đó bàn tay của người chơi được thể hiện dưới dạng chuỗi 5 ký tự với mỗi nhân vật đại diện cho một thẻ, một cách Càng Tiên cho 10, và 2 2, thông qua 9 9, đại diện cho thẻ có giá trị đó.

Để xem liệu một chuỗi đã cho là một bàn tay hợp lệ, người ta có thể làm như sau:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
9

Tay cuối cùng đó,

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
48, chứa một cặp, hoặc hai trong số cùng một thẻ có giá trị. Để phù hợp với biểu thức thông thường, người ta có thể sử dụng các bản sao lưu như vậy:

re.search(pattern, string, flags=0)
0

Để tìm hiểu thẻ nào mà cặp bao gồm, người ta có thể sử dụng phương thức

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
49 của đối tượng đối sánh theo cách sau:

re.search(pattern, string, flags=0)
1

Mô phỏng scanf ()

Python hiện không có tương đương với

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
50. Các biểu thức thông thường thường mạnh mẽ hơn, mặc dù cũng nhiều hơn so với các chuỗi định dạng
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
50. Bảng dưới đây cung cấp một số ánh xạ tương đương hoặc ít hơn giữa các mã thông báo định dạng
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
50 và các biểu thức thông thường.

Mã thông báo

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
50

Biểu hiện thông thường

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
54

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp để loại bỏ pattern
maxsplit: số phần chia giới hạn. Trong quá trình split khi số phần đã đến maxspit thì dừng lại và trả về mảng gồm các phần chia trước đó và chuỗi còn lại.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
9

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
56

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
57

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
58

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
59

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
60,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
61,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
62,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
63

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
64

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
65

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
66

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
67

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
68

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
69

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
70

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
71

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
72

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
73,
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
74

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
75

Để trích xuất tên tệp và số từ một chuỗi như

re.search(pattern, string, flags=0)
2

bạn sẽ sử dụng định dạng

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
50 như

re.search(pattern, string, flags=0)
3

Biểu thức chính quy tương đương sẽ là

re.search(pattern, string, flags=0)
4

search () so với match ()

Python cung cấp hai hoạt động nguyên thủy khác nhau dựa trên các biểu thức thông thường:

re.search(pattern, string, flags=0)
56 chỉ kiểm tra một trận đấu ở đầu chuỗi, trong khi
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
78 kiểm tra một trận đấu ở bất cứ đâu trong chuỗi (đây là những gì Perl làm theo mặc định).

Ví dụ:

re.search(pattern, string, flags=0)
5

Các biểu thức thông thường bắt đầu bằng

re.match(pattern, string, flags=0)
64 có thể được sử dụng với
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 để hạn chế trận đấu ở đầu chuỗi:

re.search(pattern, string, flags=0)
6

Tuy nhiên, lưu ý rằng ở chế độ

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
2
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
80 chỉ khớp ở đầu chuỗi, trong khi sử dụng
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 với biểu thức chính quy bắt đầu với
re.match(pattern, string, flags=0)
64 sẽ khớp ở đầu mỗi dòng.

re.search(pattern, string, flags=0)
7

Làm một danh bạ

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
40 chia một chuỗi vào một danh sách được phân định bởi mẫu được truyền. Phương pháp này là vô giá để chuyển đổi dữ liệu văn bản thành các cấu trúc dữ liệu có thể dễ dàng đọc và sửa đổi bởi Python như được trình bày trong ví dụ sau tạo ra một danh bạ.

Đầu tiên, đây là đầu vào. Thông thường nó có thể đến từ một tệp, ở đây chúng tôi đang sử dụng cú pháp chuỗi được trích xuất ba

re.search(pattern, string, flags=0)
8

Các mục được phân tách bằng một hoặc nhiều dòng mới. Bây giờ chúng tôi chuyển đổi chuỗi thành một danh sách với mỗi dòng không có giá trị có mục nhập riêng:

re.search(pattern, string, flags=0)
9

Cuối cùng, chia mỗi mục vào một danh sách với tên, họ, số điện thoại và địa chỉ. Chúng tôi sử dụng tham số

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
86 của
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
40 vì địa chỉ có khoảng trắng, mẫu phân tách của chúng tôi, trong đó:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
0

Mẫu

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
88 khớp với dấu hai chấm sau tên cuối cùng, để nó không xảy ra trong danh sách kết quả. Với
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
86 của
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
90, chúng tôi có thể tách số nhà khỏi tên đường phố:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
1

Nhắn tin MUNGING¶

re.search(pattern, string, flags=0)
89 Thay thế mọi lần xuất hiện của một mẫu bằng một chuỗi hoặc kết quả của một hàm. Ví dụ này thể hiện bằng cách sử dụng
re.search(pattern, string, flags=0)
89 với chức năng cho văn bản của Mung Munge, hoặc ngẫu nhiên thứ tự của tất cả các ký tự trong mỗi từ của một câu ngoại trừ các ký tự đầu tiên và cuối cùng:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
2

Tìm tất cả các trạng từ

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
43 phù hợp với tất cả các lần xuất hiện của một mẫu, không chỉ mô hình đầu tiên như
pattern : Đây là chuỗn cần so khớp.
string : Đây là chuỗi để tìm kiếm pattern cón tồn tại trong đó không.
flags : Bạn có thể xác định các flag khác nhau bởi sử dụng toán tử |. Các modifier này sẽ được liệt kê ở bảng bên dưới.
79 làm. Ví dụ: nếu một người viết muốn tìm tất cả các trạng từ trong một số văn bản, họ có thể sử dụng
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
43 theo cách sau:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
3

Tìm tất cả các trạng từ và vị trí của chúng

Nếu người ta muốn nhiều thông tin hơn về tất cả các trận đấu của một mẫu so với văn bản phù hợp,

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
47 rất hữu ích vì nó cung cấp các đối tượng phù hợp thay vì chuỗi. Tiếp tục với ví dụ trước, nếu một nhà văn muốn tìm tất cả các trạng từ và vị trí của chúng trong một số văn bản, họ sẽ sử dụng
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
47 theo cách sau:match objects instead of strings. Continuing with the previous example, if a writer wanted to find all of the adverbs and their positions in some text, they would use
pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
47 in the following manner:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
4

Ký hiệu chuỗi thô

Ký hiệu chuỗi thô (

>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
98) giữ cho các biểu thức thường xuyên lành mạnh. Không có nó, mọi dấu gạch chéo ngược (
>>> email = ""
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
''
1) trong một biểu thức chính quy sẽ phải được đặt trước với một biểu thức khác để thoát khỏi nó. Ví dụ: hai dòng mã sau đây có chức năng giống hệt nhau:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
5

Khi một người muốn kết hợp một dấu gạch chéo ngược theo nghĩa đen, nó phải được thoát trong biểu thức thông thường. Với ký hiệu chuỗi thô, điều này có nghĩa là

re.split(pattern, string, maxsplit=0, flags=0)
00. Không có ký hiệu chuỗi thô, người ta phải sử dụng
re.split(pattern, string, maxsplit=0, flags=0)
01, tạo các dòng mã sau giống hệt nhau về mặt chức năng:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
6

Viết Tokenizer¶

Một tokenizer hoặc máy quét phân tích một chuỗi để phân loại các nhóm ký tự. Đây là bước đầu tiên hữu ích khi viết trình biên dịch hoặc trình thông dịch.

Các danh mục văn bản được chỉ định với các biểu thức thông thường. Kỹ thuật này là kết hợp những người đó thành một biểu thức thông thường chính và lặp lại các trận đấu liên tiếp:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
7

Tokenizer tạo ra đầu ra sau:

pattern: là chuỗi regular expression.
string: là chuỗi cần so khớp.
flags: là các kiểu so khớp mà bạn muốn thực hiện. Nếu để trống thì flags sẽ bằng 0.
8

Frie09

Friedl, Jeffrey. Làm chủ các biểu thức thường xuyên. Tái bản lần thứ 3, O hèReilly Media, 2009. Phiên bản thứ ba của cuốn sách không còn bao gồm Python, nhưng phiên bản đầu tiên bao gồm viết các mẫu biểu thức thông thường tốt rất chi tiết.