programming python

Làm thế nào để bạn tách các ký tự đặc biệt trong một chuỗi trong python?

Trên trang này. . tách ra[],. tham gia [] và danh sách []

Tách một câu thành từ. . tách ra[]

Dưới đây, mary là một chuỗi duy nhất. Mặc dù đó là một câu, các từ không được biểu thị dưới dạng các đơn vị kín đáo. Đối với điều đó, bạn cần một loại dữ liệu khác. một danh sách các chuỗi trong đó mỗi chuỗi tương ứng với một từ. . split[] là phương thức sử dụng

>>> mary = 'Mary had a little lamb'
>>> mary.split[] 
['Mary', 'had', 'a', 'little', 'lamb']

split[] tách mary trên whitespce và kết quả trả về là một danh sách các từ trong mary. Danh sách này chứa 5 mục như hàm len[] thể hiện. len[] trên mary, ngược lại, trả về số lượng ký tự trong chuỗi [bao gồm cả khoảng trắng]. Các ký tự khoảng trắng bao gồm khoảng trắng '', ký tự xuống dòng '\n' và tab '\t', trong số các ký tự khác. . split[] phân tách trên bất kỳ chuỗi kết hợp nào của các ký tự đó

Tách trên một chuỗi con cụ thể

Bằng cách cung cấp một tham số tùy chọn,. split['x'] có thể được sử dụng để tách một chuỗi trên một chuỗi con cụ thể 'x'. Không có 'x' được chỉ định,. split[] chỉ đơn giản là tách trên tất cả các khoảng trắng, như đã thấy ở trên

Chuỗi thành một danh sách các ký tự. danh sách[]

Nhưng nếu bạn muốn tách một chuỗi thành một danh sách các ký tự thì sao? . Hàm list[] biến một chuỗi thành một danh sách các chữ cái riêng lẻ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

Tổng quát hơn, list[] là một hàm tích hợp để biến một đối tượng dữ liệu Python thành một danh sách. Khi một kiểu chuỗi được đưa ra, kết quả trả về là một danh sách các ký tự trong đó. Khi các loại dữ liệu khác được đưa ra, các chi tiết cụ thể sẽ khác nhau nhưng loại được trả về luôn là một danh sách. Xem hướng dẫn này để biết chi tiết

Tham gia một danh sách các chuỗi. . tham gia[]

Nếu bạn có một danh sách các từ, làm cách nào để ghép chúng lại với nhau thành một chuỗi?. tham gia [] là phương pháp để sử dụng. Được gọi trên chuỗi "dấu phân cách" 'x', 'x'. tham gia [y] tham gia mọi phần tử trong danh sách y được phân tách bằng 'x'. Dưới đây, các từ trong mwords được nối lại thành chuỗi câu với khoảng trắng ở giữa

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

Tham gia có thể được thực hiện trên bất kỳ chuỗi dấu phân cách nào. Bên dưới, '--' và ký tự tab '\t' được sử dụng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

Phương thức này cũng có thể được gọi trên chuỗi trống '' làm dấu phân cách. Hiệu ứng là các phần tử trong danh sách được nối với nhau mà không có gì ở giữa. Dưới đây, một danh sách các ký tự được đặt lại với nhau thành chuỗi ban đầu

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

Cả mẫu và chuỗi được tìm kiếm đều có thể là chuỗi Unicode [_______52] cũng như chuỗi 8 bit [

prog = re.compile[pattern]
result = prog.match[string]

3]. Tuy nhiên, không thể trộn lẫn chuỗi Unicode và chuỗi 8 bit. nghĩa là bạn không thể khớp một chuỗi Unicode với một mẫu byte hoặc ngược lại;

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

prog = re.compile[pattern]
result = prog.match[string]

4] để biểu thị các dạng đặc biệt hoặc để cho phép sử dụng các ký tự đặc biệt mà không cần gọi ý nghĩa đặc biệt của chúng. Điều này xung đột với việc Python sử dụng cùng một ký tự cho cùng một mục đích trong chuỗi ký tự; . Ngoài ra, xin lưu ý rằng bất kỳ chuỗi thoát không hợp lệ nào trong cách sử dụng dấu gạch chéo ngược trong chuỗi ký tự của Python hiện tạo ra một

prog = re.compile[pattern]
result = prog.match[string]

8 và trong tương lai, điều này sẽ trở thành một

prog = re.compile[pattern]
result = prog.match[string]

9. Hành vi này sẽ xảy ra ngay cả khi nó 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ô của Python cho các mẫu biểu thức chính quy; . Vì vậy,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

31 là chuỗi hai ký tự chứa

prog = re.compile[pattern]
result = prog.match[string]

4 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

33, trong khi

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

34 là chuỗi một ký tự chứa một dòng mới. Thông thường các mẫu sẽ được thể hiện bằng 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 thao tác 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 biểu thức chính quy được biên dịch . Các hàm là lối tắt không yêu cầu bạn biên dịch đối tượng biểu thức chính quy trước, nhưng bỏ lỡ một số tham số tinh chỉnh.

Xem thêm

Mô-đun regex của bên thứ ba, có API tương thích với mô-đun

prog = re.compile[pattern]
result = prog.match[string]

1 của thư viện chuẩn, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode toàn diện hơn

Cú pháp biểu thức chính quy¶

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 biểu thức chính quy có thể được nối để tạo thành các biểu thức chính quy mới; . Nói chung, nếu một chuỗi p khớp với A và một chuỗi q khác khớp với B, thì 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; . 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à cách thực hiện các biểu thức chính quy, hãy tham khảo sách Friedl [Frie09] hoặc hầu hết mọi sách giáo khoa về xây dựng trình biên dịch.

Sau đây là giải thích ngắn gọn về định dạng của biểu thức chính quy. Để biết thêm thông tin và cách trình bày nhẹ nhàng hơn, hãy tham khảo Biểu thức chính quy HOWTO .

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

36,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 hoặc

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

38, là các biểu thức chính quy đơn giản nhất; . Bạn có thể nối các ký tự thông thường, do đó,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

39 khớp với chuỗi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

30. [Trong phần còn lại của phần này, chúng tôi sẽ viết RE trong

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

31, thường không có dấu ngoặc kép và các chuỗi được khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

32. ]

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

33 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

34, là đặc biệt. Các ký tự đặc biệt đại diện cho các lớp ký tự thông thường hoặc ảnh hưởng đến cách diễn giải các biểu thức chính quy xung quanh chúng

Các toán tử hoặc bộ định lượng lặp lại [

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

35,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

36,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

37,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

38, v.v.] không thể được lồng trực tiếp vào nhau. Điều này tránh sự mơ hồ với hậu tố sửa đổi không tham lam

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

37 và với các công cụ sửa đổi khác trong các triển khai khác. Để áp dụng lần lặp lại thứ hai cho lần lặp lại bên trong, dấu ngoặc đơn có thể được sử dụng. Ví dụ: biểu thức

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

30 khớp với bội số bất kỳ của sáu ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

Các ký tự đặc biệt là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

[Chấm. ] Ở chế độ mặc định, ký tự này khớp với bất kỳ ký tự nào ngoại trừ ký tự xuống dòng. Nếu cờ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

33 đã được chỉ định, thì cờ này khớp với bất kỳ ký tự nào kể cả ký tự xuống dòng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

[dấu mũ. ] Khớp với phần đầu của chuỗi và ở chế độ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

35 cũng khớp ngay sau mỗi dòng mới

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

So khớp với cuối chuỗi hoặc ngay trước dòng mới ở cuối chuỗi và ở chế độ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

35 cũng khớp trước dòng mới.

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

38 khớp với cả 'foo' và 'foobar', trong khi biểu thức chính quy

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

39 chỉ khớp với 'foo'. Thú vị hơn, tìm kiếm

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

30 trong

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

31 khớp với 'foo2' bình thường, nhưng 'foo1' ở chế độ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

35; . một ngay trước dòng mới và một ở cuối chuỗi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

36 sẽ khớp với 'a', 'ab' hoặc 'a' theo sau bởi bất kỳ số lượng 'b' nào

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

38 sẽ khớp với 'a' theo sau bởi bất kỳ số nào khác 0 của 'b';

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

prog = re.compile[pattern]
result = prog.match[string]

300 sẽ khớp với 'a' hoặc 'ab'

prog = re.compile[pattern]
result = prog.match[string]

301,

prog = re.compile[pattern]
result = prog.match[string]

302,

prog = re.compile[pattern]
result = prog.match[string]

303

Các bộ định lượng

prog = re.compile[pattern]
result = prog.match[string]

304,

prog = re.compile[pattern]
result = prog.match[string]

305 và

prog = re.compile[pattern]
result = prog.match[string]

306 đều tham lam; . Đôi khi hành vi này không được mong muốn; . Thêm

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

37 sau bộ định lượng làm cho nó thực hiện khớp theo kiểu không tham lam hoặc tối thiểu; . Sử dụng RE

prog = re.compile[pattern]
result = prog.match[string]

311 sẽ chỉ khớp với

prog = re.compile[pattern]
result = prog.match[string]

309

prog = re.compile[pattern]
result = prog.match[string]

313,

prog = re.compile[pattern]
result = prog.match[string]

314,

prog = re.compile[pattern]
result = prog.match[string]

315

Giống như các bộ định lượng

prog = re.compile[pattern]
result = prog.match[string]

304,

prog = re.compile[pattern]
result = prog.match[string]

305 và

prog = re.compile[pattern]
result = prog.match[string]

306, những bộ định lượng mà

prog = re.compile[pattern]
result = prog.match[string]

305 được thêm vào cũng khớp với nhau nhiều lần nhất có thể. Tuy nhiên, không giống như các bộ định lượng tham lam thực sự, chúng không cho phép theo dõi ngược khi biểu thức theo sau nó không khớp. Chúng được gọi là lượng từ sở hữu. Ví dụ:

prog = re.compile[pattern]
result = prog.match[string]

320 sẽ khớp với

prog = re.compile[pattern]
result = prog.match[string]

321 vì

prog = re.compile[pattern]
result = prog.match[string]

322 sẽ khớp với tất cả 4

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, nhưng khi gặp phải

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 cuối cùng, biểu thức sẽ được quay lại để cuối cùng,

prog = re.compile[pattern]
result = prog.match[string]

322 khớp với tổng số 3

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 thứ tư được khớp với . Tuy nhiên, khi

prog = re.compile[pattern]
result = prog.match[string]

329 được sử dụng để khớp với

prog = re.compile[pattern]
result = prog.match[string]

321, thì

prog = re.compile[pattern]
result = prog.match[string]

331 sẽ khớp với tất cả 4

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, nhưng khi

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 cuối cùng không tìm thấy bất kỳ ký tự nào khớp với nhau, biểu thức sẽ không thể được quay lại và do đó sẽ không khớp.

prog = re.compile[pattern]
result = prog.match[string]

334,

prog = re.compile[pattern]
result = prog.match[string]

335 và

prog = re.compile[pattern]
result = prog.match[string]

336 tương ứng với

prog = re.compile[pattern]
result = prog.match[string]

337,

prog = re.compile[pattern]
result = prog.match[string]

338 và

prog = re.compile[pattern]
result = prog.match[string]

339

Mới trong phiên bản 3. 11

prog = re.compile[pattern]
result = prog.match[string]

340

Chỉ định rằng phải khớp chính xác m bản sao của RE trước đó; . Ví dụ:

prog = re.compile[pattern]
result = prog.match[string]

341 sẽ khớp chính xác sáu ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, nhưng không phải năm ký tự

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

prog = re.compile[pattern]
result = prog.match[string]

344 sẽ khớp từ 3 đến 5 ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

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

prog = re.compile[pattern]
result = prog.match[string]

346 sẽ khớp với

prog = re.compile[pattern]
result = prog.match[string]

347 hoặc một nghìn ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 theo sau bởi một

prog = re.compile[pattern]
result = prog.match[string]

349, nhưng không khớp với

prog = re.compile[pattern]
result = prog.match[string]

350. Không được bỏ dấu phẩy nếu không từ bổ nghĩa sẽ bị nhầm lẫn với dạng đã mô tả trước đó

prog = re.compile[pattern]
result = prog.match[string]

351

Làm cho RE kết quả khớp từ m đến n lần lặp lại của RE trước đó, cố gắng khớp càng ít lần lặp lại càng tốt. Đây là phiên bản không tham lam của bộ định lượng trước đó. Ví dụ: trên chuỗi 6 ký tự

prog = re.compile[pattern]
result = prog.match[string]

352,

prog = re.compile[pattern]
result = prog.match[string]

344 sẽ khớp với 5 ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, trong khi

prog = re.compile[pattern]
result = prog.match[string]

355 sẽ chỉ khớp với 3 ký tự

prog = re.compile[pattern]
result = prog.match[string]

356

Làm cho RE kết quả khớp từ m đến n lần lặp lại của RE trước đó, cố gắng khớp càng nhiều lần lặp lại càng tốt mà không thiết lập bất kỳ điểm quay lui nào. Đây là phiên bản sở hữu của bộ định lượng ở trên. Ví dụ: trên chuỗi 6 ký tự

prog = re.compile[pattern]
result = prog.match[string]

352,

prog = re.compile[pattern]
result = prog.match[string]

358 cố gắng khớp 5 ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, sau đó, yêu cầu thêm 2 ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37, sẽ cần nhiều ký tự hơn mức có sẵn và do đó không thành công, trong khi

prog = re.compile[pattern]
result = prog.match[string]

361 sẽ khớp với

prog = re.compile[pattern]
result = prog.match[string]

344 bắt 5, sau đó là 4 ký tự

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37 bằng cách quay lui .

prog = re.compile[pattern]
result = prog.match[string]

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

prog = re.compile[pattern]
result = prog.match[string]

367

Mới trong phiên bản 3. 11

prog = re.compile[pattern]
result = prog.match[string]

368

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

prog = re.compile[pattern]
result = prog.match[string]

304,

prog = re.compile[pattern]
result = prog.match[string]

306, v.v.] hoặc báo hiệu một chuỗi đặc biệt;

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

prog = re.compile[pattern]
result = prog.match[string]

371

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

Các ký tự có thể được liệt kê riêng lẻ, e. g.

prog = re.compile[pattern]
result = prog.match[string]

372 sẽ khớp với

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37,

prog = re.compile[pattern]
result = prog.match[string]

374 hoặc

prog = re.compile[pattern]
result = prog.match[string]

375

Phạm vi ký tự có thể được biểu thị bằng cách đưa ra hai ký tự và phân tách chúng bằng một dấu

prog = re.compile[pattern]
result = prog.match[string]

376, ví dụ:

prog = re.compile[pattern]
result = prog.match[string]

377 sẽ khớp với bất kỳ chữ cái ASCII viết thường nào,

prog = re.compile[pattern]
result = prog.match[string]

378 sẽ khớp với tất cả các số có hai chữ số từ

prog = re.compile[pattern]
result = prog.match[string]

379 đến

prog = re.compile[pattern]
result = prog.match[string]

380 và

prog = re.compile[pattern]
result = prog.match[string]

381 sẽ khớp với bất kỳ chữ số thập lục phân nào. Nếu

prog = re.compile[pattern]
result = prog.match[string]

382 bị thoát [e. g.

prog = re.compile[pattern]
result = prog.match[string]

383] hoặc nếu nó được đặt làm ký tự đầu tiên hoặc cuối cùng [e. g.

prog = re.compile[pattern]
result = prog.match[string]

384 hoặc

prog = re.compile[pattern]
result = prog.match[string]

385], nó sẽ khớp với một chữ

prog = re.compile[pattern]
result = prog.match[string]

376

Các ký tự đặc biệt mất ý nghĩa đặc biệt của chúng trong các bộ. Ví dụ:
```
prog = re.compile[pattern]
result = prog.match[string]
```
387 sẽ khớp với bất kỳ ký tự chữ nào ________ 234, ________ 5305, ________ 5304 hoặc ________ 5391

Các lớp ký tự như
```
prog = re.compile[pattern]
result = prog.match[string]
```
392 hoặc
```
prog = re.compile[pattern]
result = prog.match[string]
```
393 [được định nghĩa bên dưới] cũng được chấp nhận trong một tập hợp, mặc dù các ký tự phù hợp với chúng tùy thuộc vào chế độ
```
prog = re.compile[pattern]
result = prog.match[string]
```
394 hoặc
```
prog = re.compile[pattern]
result = prog.match[string]
```
395 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 bộ. Nếu ký tự đầu tiên của tập hợp là
```
prog = re.compile[pattern]
result = prog.match[string]
```
396, tất cả các ký tự không có trong tập hợp sẽ được so khớp. Ví dụ:
```
prog = re.compile[pattern]
result = prog.match[string]
```
397 sẽ khớp với bất kỳ ký tự nào ngoại trừ
```
prog = re.compile[pattern]
result = prog.match[string]
```
398 và
```
prog = re.compile[pattern]
result = prog.match[string]
```
399 sẽ khớp với bất kỳ ký tự nào ngoại trừ
```
prog = re.compile[pattern]
result = prog.match[string]
```
396.
```
>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb 
```
34 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

Để khớp một chữ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5502 bên trong một tập hợp, hãy thêm dấu gạch chéo ngược vào trước nó hoặc đặt nó ở đầu tập hợp. Ví dụ: cả

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5503 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5504 đều sẽ khớp với dấu ngoặc đơn

Hỗ trợ các tập hợp lồng nhau và các thao tác tập hợp như trong Tiêu chuẩn kỹ thuật Unicode #18 có thể được thêm vào trong tương lai. Điều này sẽ thay đổi cú pháp, do đó, để tạo điều kiện cho sự thay đổi này, một
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5505 sẽ được nêu ra trong các trường hợp không rõ ràng trong thời điểm hiện tại. Điều đó bao gồm các bộ bắt đầu bằng một chữ
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5506 hoặc chứa các chuỗi ký tự chữ
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5507,
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5508,
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5509 và
```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
5510. Để tránh cảnh báo, hãy thoát chúng bằng dấu gạch chéo ngược

Đã thay đổi trong phiên bản 3. 7. ______15505 đượ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.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5512

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5513, trong đó A và B có thể là các RE tùy ý, tạo một biểu thức chính quy khớp với A hoặc B. Một số lượng RE tùy ý có thể được phân tách bằng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

33 theo cách này. Điều này cũng có thể được sử dụng trong các nhóm [xem bên dưới]. Khi chuỗi mục tiêu được quét, các RE cách nhau bởi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

33 được thử từ trái sang phải. Khi một mẫu khớp hoàn toàn, 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 kết quả khớp tổng thể dài hơn. Nói cách khác, toán tử

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

33 không bao giờ tham lam. Để khớp với một

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5519

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5520

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à cho biết điểm bắt đầu và điểm kết thúc của một nhóm; . Để khớp với các chữ

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

34 hoặc

prog = re.compile[pattern]
result = prog.match[string]

391, hãy sử dụng

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5524 hoặc

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5525 hoặc đặt chúng bên trong một lớp ký tự.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5526,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5527

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5528

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

prog = re.compile[pattern]
result = prog.match[string]

306 theo sau một

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

34 không có ý nghĩa khác]. Ký tự đầu tiên sau

prog = re.compile[pattern]
result = prog.match[string]

306 xác định ý nghĩa và cú pháp tiếp theo của cấu trúc là gì. Tiện ích mở rộng thường không tạo nhóm mới; . Sau đây là các tiện ích mở rộng hiện được hỗ trợ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5533

[Một hoặc nhiều chữ cái từ tập hợp

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5535,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5536,

prog = re.compile[pattern]
result = prog.match[string]

374,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5538,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5539,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5540. ] Nhóm khớp với chuỗi rỗng; .

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5541 [chỉ khớp ASCII],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5542 [bỏ qua chữ hoa chữ thường],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5543 [phụ thuộc vào ngôn ngữ],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5544 [nhiều dòng],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5545 [dấu chấm khớp với tất cả],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5546 [khớp Unicode] và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5547 [dài dòng], cho toàn bộ thông thường . [Các cờ được mô tả trong Nội dung mô-đun . ] Điều này hữu ích nếu bạn muốn bao gồm các cờ như một phần của biểu thức chính quy, thay vì chuyển một đối số cờ cho hàm

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5548. Cờ nên được sử dụng đầu tiên trong chuỗi biểu thức.

Đã thay đổi trong phiên bản 3. 11. Cấu trúc này chỉ có thể được sử dụng ở đầu biểu thức.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5549

Phiên bản không ghi 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 không thể truy xuất chuỗi con được khớp bởi nhóm sau khi thực hiện khớp hoặc được tham chiếu sau trong mẫu

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5550

[Không hoặc nhiều chữ cái từ tập hợp

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5535,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5536,

prog = re.compile[pattern]
result = prog.match[string]

374,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5538,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5539,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5540, tùy ý theo sau bởi

prog = re.compile[pattern]
result = prog.match[string]

376, tiếp theo là một hoặc nhiều chữ cái từ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5535,

prog = re.compile[pattern]
result = prog.match[string]

374,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5538,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5540. ] Các chữ cái đặt hoặc loại bỏ các cờ tương ứng.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5541 [chỉ khớp ASCII],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5542 [bỏ qua chữ hoa chữ thường],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5543 [phụ thuộc vào ngôn ngữ],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5544 [nhiều dòng],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5545 [dấu chấm khớp với tất cả],

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5546 [khớp Unicode] và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5547 [dài dòng], đối với một phần của . [Các cờ được mô tả trong Nội dung mô-đun . ]

Các chữ cái

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5536 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5539 loại trừ lẫn nhau khi được sử dụng làm cờ nội tuyến, vì vậy chúng không thể được kết hợp hoặc theo sau

prog = re.compile[pattern]
result = prog.match[string]

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5574 chuyển sang khớp chỉ ASCII và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5575 chuyển sang khớp Unicode [mặc định]. Trong mẫu byte,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5576 chuyển sang khớp tùy theo ngôn ngữ và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5574 chuyển sang khớp chỉ ASCII [mặc định]. Ghi đè này chỉ có hiệu lực đối với 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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

37,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5536 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5539 cũng có thể được sử dụng trong một nhóm.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5581

Các nỗ lực khớp với

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5582 như thể đó là một biểu thức chính quy riêng biệt và nếu thành công, tiếp tục khớp với phần còn lại của mẫu theo sau nó. Nếu mẫu tiếp theo không khớp, thì ngăn xếp chỉ có thể được mở ra ở một điểm trước

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5581 vì sau khi thoát ra, biểu thức, được gọi là nhóm nguyên tử, đã loại bỏ tất cả các điểm ngăn xếp trong chính nó. Do đó,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5584 sẽ không bao giờ khớp với bất kỳ thứ gì vì đầu tiên,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5585 sẽ khớp với tất cả các ký tự có thể, sau đó, không còn gì để khớp,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

32 cuối cùng sẽ không khớp. Vì không có điểm ngăn xếp nào được lưu trong Nhóm nguyên tử và không có điểm ngăn xếp nào trước nó, nên toàn bộ biểu thức sẽ không khớp

Mới trong phiên bản 3. 11

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5532

Tương tự như dấu ngoặc đơn thông thường, nhưng chuỗi con phù hợp với nhóm có thể truy cập thông qua tên nhóm ký hiệu. Tên nhóm phải là mã định danh Python hợp lệ và mỗi tên nhóm chỉ được xác định một lần trong 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 ngữ cảnh. Nếu mẫu là

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5588 [i. e. khớp với một chuỗi được trích dẫn bằng dấu ngoặc đơn hoặc dấu ngoặc kép]

Bối cảnh tham chiếu đến nhóm “trích dẫn”

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

trong cùng một mô hình chính nó

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5589 [như hình]

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5590

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5591

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5592 [v.v. ]

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5593

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5594

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5595

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5590

Không dùng nữa kể từ phiên bản 3. 11. Tên nhóm chứa các ký tự không phải ASCII trong mẫu byte.

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5597

Một phản hồi cho một nhóm được đặt tên;

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5598

Một lời bình luận;

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5599

Khớp nếu

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5582 khớp tiếp theo, nhưng không sử dụng bất kỳ chuỗi nào. Điều này được gọi là một khẳng định nhìn trước. Ví dụ:

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5401 sẽ chỉ khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5402 nếu theo sau nó là

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5403

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5404

Khớp nếu

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5582 không khớp tiếp theo. Đây là một khẳng định nhìn trước tiêu cực. Ví dụ:

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5406 sẽ khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5402 chỉ khi nó không theo sau bởi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5403

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5409

Khớp nếu vị trí hiện tại trong chuỗi được bắt đầu bằng một khớp cho

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5582 kết thúc ở vị trí hiện tại. Điều này được gọi là khẳng định cái nhìn tích cực.

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5411 sẽ tìm thấy kết quả trùng khớp trong

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5412, vì giao diện phía sau sẽ sao lưu 3 ký tự và kiểm tra xem mẫu có trong đó có khớp không. Mẫu có trong chỉ được khớp với các chuỗi có độ dài cố định, nghĩa là cho phép

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5413 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5414 nhưng

prog = re.compile[pattern]
result = prog.match[string]

322 và

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5416 thì không. Lưu ý rằng các mẫu bắt đầu bằng xác nhận giao diện tích cực sẽ không khớp ở đầu chuỗi được tìm kiếm;

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

prog = re.compile[pattern]
result = prog.match[string]

Đã thay đổi trong phiên bản 3. 5. Đã thêm hỗ trợ cho tham chiếu nhóm có độ dài cố định.

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5419

Khớp nếu vị trí hiện tại trong chuỗi không được bắt đầu bằng khớp cho

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5582. Điều này được gọi là khẳng định nhìn phía sau tiêu cực. Tương tự như xác nhận giao diện tích cực, mẫu có trong chỉ phải khớp với các chuỗi có độ dài cố định. Các mẫu bắt đầu bằng các xác nhận về giao diện phủ định có thể khớp với phần đầu của chuỗi đang được tìm kiếm

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5421

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5422 nếu nhóm có id hoặc tên đã cho tồn tại và với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5423 nếu không.

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5423 là tùy chọn và có thể bỏ qua. Ví dụ:

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5425 là mẫu khớp email kém, sẽ khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5426 cũng như

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5427, nhưng không khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5428 và

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5429

Không dùng nữa kể từ phiên bản 3. 11. ID nhóm chứa bất kỳ thứ gì ngoại trừ các chữ số ASCII.

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

prog = re.compile[pattern]
result = prog.match[string]

4 và một ký tự từ danh sách bên dưới. Nếu ký tự thông thường không phải là chữ số ASCII hoặc chữ cái ASCII, thì RE kết quả sẽ khớp với ký tự thứ hai. Ví dụ:

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5431 khớp với ký tự

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5432

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5521

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5434 khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5435 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5436, nhưng không khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5437 [lưu ý khoảng trắng sau nhóm]. Trình tự đặc biệt này chỉ có thể được sử dụng để khớ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ố có 3 chữ số bát phân, thì nó sẽ không được hiểu là khớp nhóm mà là ký tự có giá trị bát phân số. Bên trong

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5506 và

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5502 của một lớp ký tự, tất cả các số thoát được coi là ký tự

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5440

Chỉ khớp ở đầu chuỗi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441

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,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441 được định nghĩa là ranh giới giữa ký tự

prog = re.compile[pattern]
result = prog.match[string]

392 và ký tự

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5444 [hoặc ngược lại] hoặc giữa

prog = re.compile[pattern]
result = prog.match[string]

392 và phần đầu/cuối của chuỗi. Điều này có nghĩa là

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5446 khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5447,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5448,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5449,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5450 nhưng không khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5451 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5452

Theo mặc định, chữ và số Unicode là những chữ cá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ờ

prog = re.compile[pattern]
result = prog.match[string]

394. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

395 được sử dụng. Bên trong một phạm vi ký tự,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441 đại diện cho ký tự xóa lùi, để tương thích với chuỗi ký tự của Python

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5456

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à

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5457 khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5458,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5459,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5460, nhưng không khớp với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5461,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5462 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5463.

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5456 hoàn toàn ngược lại với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441, vì vậy các ký tự từ trong các mẫu Unicode là chữ và số Unicode hoặc dấu gạch dưới, mặc dù điều này có thể được thay đổi bằng cách sử dụng cờ

prog = re.compile[pattern]
result = prog.match[string]

394. Ranh giới từ được xác định bởi ngôn ngữ hiện tại nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

395 được sử dụng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5468Đối với 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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5469 và nhiều ký tự chữ số khác. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 chỉ được sử dụng thì

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5469 được khớp

Đối với các mẫu 8 bit [byte]

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5473

Khớp với bất kỳ ký tự nào không phải là chữ số thập phân. Điều này trái ngược với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5468. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, nó sẽ tương đương với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5476

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5477Đối với các mẫu Unicode [str]

So khớp các ký tự khoảng trắng Unicode [bao gồm

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5478 và nhiều ký tự khác, ví dụ: các khoảng trắng không ngắt bắt buộc theo quy tắc kiểu chữ trong nhiều ngôn ngữ]. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, chỉ có

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5478 được khớp

Đối với các mẫu 8 bit [byte]

Khớp các ký tự được coi là khoảng trắng trong bộ ký tự ASCII;

prog = re.compile[pattern]
result = prog.match[string]

393

Khớp với bất kỳ ký tự nào không phải là ký tự khoảng trắng. Điều này trái ngược với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5477. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, nó sẽ tương đương với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5485

prog = re.compile[pattern]
result = prog.match[string]

392Đối với các mẫu Unicode [str]

Khớp các ký tự từ Unicode; . Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, chỉ có

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5490 được khớp

Đối với các mẫu 8 bit [byte]

Khớp các ký tự được coi là chữ và số trong bộ ký tự ASCII; . Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

395 được sử dụng, khớp các ký tự được coi là chữ và số ở ngôn ngữ hiện tại và dấu gạch dưới

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5444

Khớp với bất kỳ ký tự nào không phải là ký tự từ. Điều này trái ngược với

prog = re.compile[pattern]
result = prog.match[string]

392. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, nó sẽ tương đương với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5496. Nếu cờ

prog = re.compile[pattern]
result = prog.match[string]

395 được sử dụng, khớp với các ký tự không phải là chữ và số trong ngôn ngữ hiện tại cũng như dấu gạch dưới

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5498

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

Hầu hết các lối thoát tiêu chuẩn được hỗ trợ bởi các chuỗi ký tự Python cũng được trình phân tích cú pháp biểu thức chính quy chấp nhận

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

[Lưu ý rằng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441 được sử dụng để thể hiện ranh giới từ và có nghĩa là "xóa lùi" chỉ bên trong các lớp ký tự. ]

Các chuỗi thoát

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5600,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5601 và

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5602 chỉ được nhận dạng trong các mẫu Unicode. Trong các mẫu byte, chúng là lỗi. Các ký tự ASCII thoát không xác định được dành riêng để sử dụng trong tương lai và được coi là lỗi

Thoát bát phân được bao gồm trong một hình thức hạn chế. Nếu chữ số đầu tiên là 0 hoặc nếu có ba chữ số bát phân, nó được coi là thoát bát phân. Mặt khác, nó là một tài liệu tham khảo nhóm. Đối với chuỗi ký tự, các dấu thoát bát phân luôn có độ dài tối đa là ba chữ số

Đã thay đổi trong phiên bản 3. 3. Trình tự thoát

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5600 và

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5601 đã được thêm vào.

Đã thay đổi trong phiên bản 3. 6. Các lối thoát không xác định bao gồm

prog = re.compile[pattern]
result = prog.match[string]

4 và một chữ cái ASCII hiện là lỗi.

Đã thay đổi trong phiên bản 3. 8. Trình tự thoát

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5606 đã được thêm vào. Như trong chuỗi ký tự, nó mở rộng thành ký tự Unicode được đặt tên [e. g.

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5607].

Nội dung mô-đun¶

Mô-đun xác định một số chức năng, hằng số và một ngoại lệ. Một số chức năng là phiên bản đơn giản hóa của các phương thức đầy đủ tính năng cho các biểu thức chính quy được biên dịch. Hầu hết các ứng dụng không tầm thường luôn sử dụng biểu mẫu được biên dịch

Cờ¶

Đã thay đổi trong phiên bản 3. 6. Hằng số cờ hiện là phiên bản của

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5608, là lớp con của

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5609.

lớp lại. RegexFlag ¶

Một lớp

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5609 chứa các tùy chọn biểu thức chính quy được liệt kê bên dưới

Mới trong phiên bản 3. 11. - được thêm vào

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5611

lại. A ¶ lại. ASCII ¶

Làm cho

prog = re.compile[pattern]
result = prog.match[string]

392,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5444,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5456,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5468,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5473,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5477 và

prog = re.compile[pattern]
result = prog.match[string]

393 thực hiện khớp chỉ ASCII thay vì khớp Unicode đầy đủ. Điều này chỉ có ý nghĩa đối với các mẫu Unicode và bị bỏ qua đối với các mẫu byte. Tương ứng với cờ nội tuyến

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5620

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5546 vẫn tồn tại [cũng như từ đồng nghĩa của nó là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5622 và đối tác được nhúng của nó là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5623], nhưng chúng không cần thiết trong Python 3 vì các kết quả khớp là Unicode theo mặc định cho các chuỗi [và kết hợp Unicode không được phép cho các byte

lại. GỠ LỖI ¶

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

lại. Tôi ¶ lại. BỎ QUA ¶

Thực hiện khớp không phân biệt chữ hoa chữ thường; . Đối sánh Unicode đầy đủ [chẳng hạn như đối sánh

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5625 với

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5626] cũng hoạt động trừ khi cờ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5627 được sử dụng để vô hiệu hóa đối sánh không phải ASCII. Ngôn ngữ hiện tại không thay đổi tác dụng của cờ này trừ khi cờ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5628 cũng được sử dụng. Tương ứng với cờ nội tuyến

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5629

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

prog = re.compile[pattern]
result = prog.match[string]

377 hoặc

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

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

prog = re.compile[pattern]
result = prog.match[string]

394 được sử dụng, chỉ các chữ cái từ 'a' đến 'z' và 'A' đến 'Z' được khớp

lại. L ¶ lại. ĐỊA ĐIỂM ¶

Đặt

prog = re.compile[pattern]
result = prog.match[string]

392,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5444,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5441,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5456 và kết hợp không phân biệt chữ hoa chữ thường phụ thuộc vào ngôn 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 cờ này không được khuyến khích vì cơ chế ngôn ngữ rất không đáng tin cậy, nó chỉ xử lý một "văn hóa" tại một thời điểm và nó chỉ hoạt động với ngôn ngữ 8 bit. Kết hợp Unicode đã được bật theo mặc định trong Python 3 cho các mẫu Unicode [str] và nó có thể xử lý các ngôn ngữ/địa phương khác nhau. Tương ứng với cờ nội tuyến

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5638

Đã thay đổi trong phiên bản 3. 6. ______35628 chỉ có thể được sử dụng với các mẫu byte và không tương thích với

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5627.

Đã thay đổi trong phiên bản 3. 7. Các đối tượng biểu thức chính quy được biên dịch với cờ

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5628 không còn phụ thuộc vào ngôn ngữ tại thời điểm biên dịch. Chỉ ngôn ngữ tại thời điểm khớp mới ảnh hưởng đến kết quả khớp.

lại. M ¶ lại. ĐA DÒNG ¶

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

prog = re.compile[pattern]
result = prog.match[string]

396 khớp ở đầu chuỗi và đầu mỗi dòng [ngay sau mỗi dòng mới]; . Theo mặc định,

prog = re.compile[pattern]
result = prog.match[string]

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5432 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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5646

lại. NOFLAG ¶

Cho biết không có cờ nào được áp dụng, giá trị là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5647. Cờ này có thể được sử dụng làm giá trị mặc định cho đối số từ khóa hàm hoặc làm giá trị cơ sở sẽ được ORed có điều kiện với các cờ khác. Ví dụ về việc sử dụng làm giá trị mặc định

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

Mới trong phiên bản 3. 11

lại. S ¶ lại. DOTALL ¶

Làm cho ký tự đặc biệt

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5648 khớp với bất kỳ ký tự nào, kể cả ký tự xuống dòng; . Tương ứng với cờ nội tuyến

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5650

lại. X ¶ re. VERBOSE ¶

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

prog = re.compile[pattern]
result = prog.match[string]

301,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5652 hoặc

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5653. Ví dụ:

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5654 và

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5655 không được phép. Khi một dòng chứa

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5656 không thuộc lớp ký tự và không có dấu gạch chéo ngược không thoát ở trước, thì tất cả các ký tự từ ngoài cùng bên trái chẳng hạn như

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5656 đế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 khớp với một số thập phân có chức năng bằng nhau

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5658

Chức năng¶

lại. biên dịch[mẫu , cờ=0]¶

Biên dịch 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 để so khớp bằng cách sử dụng phương pháp

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 và các phương thức khác, được mô tả .

Hành vi của 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, được kết hợp bằng bitwise OR [toán tử

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5512]

Trình tự

prog = re.compile[pattern]
result = prog.match[string]

tương đương với

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

nhưng sử dụng

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5548 và lưu đối tượng biểu thức chính quy kết quả để sử dụng lại sẽ 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 đã biên dịch của các mẫu gần đây nhất được chuyển đến

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5548 và các hàm khớp ở cấp độ mô-đun được lưu vào bộ đệm, vì vậy các chương trình chỉ sử dụng một vài biểu thức chính quy tại một thời điểm không cần lo lắng về việc biên dịch các biểu thức chính quy

lại. tìm kiếm[mẫu , chuỗi, flags=0]¶

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu không có vị trí nào trong chuỗi khớp với mẫu; .

lại. khớp[mẫu , chuỗi, flags=0]¶

Nếu 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ả lại

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu chuỗi không khớp với mẫu; .

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

35,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5667 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í khớp ở bất kỳ đâu trong chuỗi, hãy sử dụng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 thay thế [xem thêm search[] so với. khớp[] ].

lại. trọn bộ[mẫu , chuỗi, 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ả lại

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu chuỗi không khớp với mẫu; .

Mới trong phiên bản 3. 4

lại. tách[mẫu , chuỗi, maxsplit=0, flags=0]¶

Tách chuỗi theo số 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 khác không, thì tối đa các lần tách maxsplit xảy ra và phần còn lại của chuỗi được trả về dưới dạng phần tử cuối cùng của danh sách

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

Nếu có các nhóm bắt giữ trong dấu tách và nó khớp ở đầu chuỗi, thì kết quả sẽ bắt đầu bằng một chuỗi trống. Điều tương tự cũng xảy ra với phần cuối của chuỗi

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

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

Các kết quả khớp trống cho mẫu chỉ tách chuỗi khi không liền kề với kết quả khớp trống trước đó

>>> hi = 'hello world'
>>> hichars = list[hi]
>>> hichars
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
>>> ''.join[hichars]
'hello world'

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ tách trên một mẫu có thể khớp với một chuỗi trống.

lại. tìm tất cả[mẫu , chuỗi, flags=0]¶

Trả về tất cả các mẫu trùng khớp không chồng chéo trong chuỗi, dưới dạng danh sách các chuỗi hoặc bộ. Chuỗi được quét từ trái sang phải và kết quả khớp được trả về theo thứ tự 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 nào, hãy trả về danh sách các chuỗi khớp với toàn bộ mẫu. Nếu có chính xác một nhóm, hãy trả về danh sách các chuỗi khớp với nhóm đó. Nếu có nhiều nhóm, hãy trả về danh sách các bộ chuỗi khớp với các nhóm. Các nhóm không chụp không ảnh hưởng đến hình thức của kết quả

prog = re.compile[pattern]
result = prog.match[string]

Đã thay đổi trong phiên bản 3. 7. Các trận đấu không trống giờ đây có thể bắt đầu ngay sau trận đấu trống trước đó.

lại. công cụ tìm[mẫu , chuỗi, flags=0]¶

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

Đã thay đổi trong phiên bản 3. 7. Các trận đấu không trống giờ đây có thể bắt đầu ngay sau trận đấu trống trước đó.

lại. phụ[mẫu , thay thế, string, count=0, flags=0]¶

Trả về chuỗi thu được bằng cách thay thế các lần xuất hiện mẫu không chồng chéo ngoài cùng bên trái trong chuỗi bằng thay thế thay thế. Nếu không tìm thấy mẫu, chuỗi được trả về không thay đổi. repl có thể là một chuỗi hoặc một hàm; . Nghĩa là,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5671 được chuyển đổi thành ký tự xuống dòng, v.v. Các ký tự ASCII thoát không xác định được dành riêng để sử dụng trong tương lai và được coi là lỗi. Các lối thoát không xác định khác như

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5672 bị bỏ lại một mình. Các tham chiếu ngược, chẳng hạn như

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5673, được thay thế bằng chuỗi con khớp với nhóm 6 trong mẫu. Ví dụ

prog = re.compile[pattern]
result = prog.match[string]

Nếu repl là một hàm, thì nó được gọi cho mọi lần xuất hiện mẫu không chồng chéo. Hàm nhận một đối số match object và trả về chuỗi thay thế. Ví dụ.

prog = re.compile[pattern]
result = prog.match[string]

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

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5674 trả về

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5675

Trong các đối số thay thế kiểu chuỗi, ngoài các ký tự thoát và tham chiếu ngược được mô tả ở trên,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5676 sẽ sử dụng chuỗi con khớp với nhóm có tên

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5677, như được xác định bởi cú pháp

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5532.

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5679 sử dụng số nhóm tương ứng; .

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5683 sẽ được hiểu là tham chiếu đến nhóm 20, không phải tham chiếu đến nhóm 2 theo sau là ký tự chữ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

38. Sự thay thế phản hồi

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5685 trong toàn bộ chuỗi con được khớp bởi RE

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 5. Các nhóm không khớp được thay thế bằng một chuỗi rỗng.

Đã thay đổi trong phiên bản 3. 6. Lỗi thoát không xác định trong mẫu bao gồm

prog = re.compile[pattern]
result = prog.match[string]

4 và một chữ cái ASCII hiện là lỗi.

Đã thay đổi trong phiên bản 3. 7. Lỗi thoát không xác định trong thay thế bao gồm

prog = re.compile[pattern]
result = prog.match[string]

4 và một chữ cái ASCII hiện là lỗi.

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

Không dùng nữa kể từ phiên bản 3. 11. ID nhóm chứa bất kỳ thứ gì ngoại trừ các chữ số ASCII. Tên nhóm chứa các ký tự không phải ASCII trong chuỗi thay thế byte.

lại. subn[mẫu , thay thế, string, count=0, flags=0]¶

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688, nhưng trả về một bộ dữ liệu

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5689

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số cờ tùy chọn.

Đã thay đổi trong phiên bản 3. 5. Các nhóm không khớp được thay thế bằng một chuỗi rỗng.

lại. thoát[mẫu] ¶

Thoát các ký tự đặc biệt trong mẫu. Điều này hữu ích nếu bạn muốn so khớp một chuỗi ký tự tùy ý có thể có các ký tự meta của biểu thức chính quy trong đó. Ví dụ

prog = re.compile[pattern]
result = prog.match[string]

Hàm này không được sử dụng cho chuỗi thay thế trong

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688 và

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5691, chỉ nên thoát dấu gạch chéo ngược. Ví dụ

prog = re.compile[pattern]
result = prog.match[string]

Đã thay đổi trong phiên bản 3. 3. Ký tự

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5692 không còn thoát nữa.

Đã thay đổi trong phiên bản 3. 7. Chỉ các ký tự có ý nghĩa đặc biệt trong biểu thức chính quy mới được thoát. Kết quả là,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5693,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5694,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5695,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5696,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5697,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5698,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5699,

prog = re.compile[pattern]
result = prog.match[string]

00,

prog = re.compile[pattern]
result = prog.match[string]

01,

prog = re.compile[pattern]
result = prog.match[string]

02,

prog = re.compile[pattern]
result = prog.match[string]

03,

prog = re.compile[pattern]
result = prog.match[string]

04 và

prog = re.compile[pattern]
result = prog.match[string]

05 không còn bị thoát.

lại. thanh lọc[] ¶

Xóa bộ đệm biểu thức chính quy

Ngoại lệ¶

ngoại lệ lại. lỗi[thông báo , mẫu=None, pos=None]¶

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

tin nhắn ¶

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

mẫu ¶

Mẫu biểu thức chính quy

tư thế ¶

Chỉ mục trong mẫu mà quá trình biên dịch không thành công [có thể là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664]

lineno ¶

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664]

colno ¶

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664]

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

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

Các đối tượng biểu thức chính quy được biên dịch hỗ trợ các phương thức và thuộc tính sau

Mẫu. tìm kiếm[chuỗi[ , pos[, endpos]]]¶

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu không có vị trí nào trong chuỗi khớp với mẫu; .

Tham số thứ hai tùy chọn pos đưa ra một chỉ mục trong chuỗi nơi bắt đầu tìm kiếm; . Điều này không hoàn toàn tương đương với việc cắt chuỗi;

Tham số tùy chọn endpos giới hạn khoảng cách chuỗi sẽ được tìm kiếm; . Nếu endpos nhỏ hơn pos, sẽ không tìm thấy kết quả phù hợp;

prog = re.compile[pattern]
result = prog.match[string]

Mẫu. khớp[chuỗi[ , pos[, endpos]]]¶

Nếu không hoặc nhiều ký tự ở đầu 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ả lại

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu chuỗi không khớp với mẫu; .

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417

prog = re.compile[pattern]
result = prog.match[string]

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 thay thế [xem thêm search[] so với. khớp[] ].

Mẫu. trận đấu đầy đủ[chuỗi[ , 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ả lại

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu chuỗi không khớp với mẫu; .

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417

prog = re.compile[pattern]
result = prog.match[string]

Mới trong phiên bản 3. 4

Mẫu. tách[chuỗi , maxsplit=0]¶

Giống với hàm

prog = re.compile[pattern]
result = prog.match[string]

20, sử dụng mẫu đã biên dịch

Mẫu. tìm tất cả[chuỗi[ , pos[, endpos]]]¶

Tương tự như hàm

prog = re.compile[pattern]
result = prog.match[string]

21, sử dụng mẫu đã 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ư đối với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417

Mẫu. công cụ tìm[chuỗi[ , pos[, endpos]]]¶

Tương tự như hàm

prog = re.compile[pattern]
result = prog.match[string]

23, sử dụng mẫu đã 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ư đối với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417

Mẫu. sub[repl , chuỗi, count=0]¶

Giống với hàm

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688, sử dụng mẫu đã biên dịch

Mẫu. subn[repl , chuỗi, count=0]¶

Giống với hàm

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5691, sử dụng mẫu đã biên dịch

Mẫu. cờ ¶

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

prog = re.compile[pattern]
result = prog.match[string]

27, bất kỳ cờ nội tuyến

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5528 nào trong mẫu và các cờ ẩn như

prog = re.compile[pattern]
result = prog.match[string]

29 nếu mẫu là một chuỗi Unicode

Mẫu. nhóm ¶

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

Mẫu. chỉ mục nhóm ¶

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

prog = re.compile[pattern]
result = prog.match[string]

30 thành số nhóm. Từ điển trống nếu không có nhóm ký hiệu nào được sử dụng trong mẫu

Mẫu. mẫu ¶

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

prog = re.compile[pattern]
result = prog.match[string]

31 và

prog = re.compile[pattern]
result = prog.match[string]

32. Các đối tượng biểu thức chính quy được biên dịch được coi là nguyên tử.

Khớp các đối tượng¶

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

prog = re.compile[pattern]
result = prog.match[string]

33. Vì

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 và

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 trả về

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 khi không có kết quả khớp, bạn có thể kiểm tra xem có kết quả trùng khớp hay không bằng một câu lệnh

prog = re.compile[pattern]
result = prog.match[string]

37 đơn giản

prog = re.compile[pattern]
result = prog.match[string]

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

Trùng khớp. mở rộng[mẫu] ¶

Trả về chuỗi thu được bằng cách thực hiện thay thế dấu gạch chéo ngược trên mẫu chuỗi mẫu, như được thực hiện bằng phương pháp

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688. Các lối thoát như

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5670 được chuyển đổi thành các ký tự thích hợp và các tham chiếu ngược dạng số [

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5590,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5681] và các tham chiếu ngược có tên [

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5595,

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5676] đượ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 không khớp được thay thế bằng một chuỗi rỗng.

Trùng khớp. nhóm[[nhóm1 , . ...]] ¶

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; . Không có đối số, nhóm1 mặc định bằng 0 [toàn bộ kết quả khớp được trả về]. Nếu đối số groupN bằng 0, thì giá trị trả về tương ứng là toàn bộ chuỗi phù hợp; . 99], đó là chuỗi khớp với nhóm được đặt trong ngoặc đơn tương ứng. Nếu số nhóm âm hoặc lớn hơn số nhóm được xác định trong mẫu, một ngoại lệ

prog = re.compile[pattern]
result = prog.match[string]

44 được đưa ra. Nếu một nhóm được chứa trong một phần của mẫu không khớp, thì kết quả tương ứng là

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664. Nếu một nhóm được chứa trong một phần của mẫu khớp nhiều lần, thì kết quả khớp cuối cùng sẽ được trả về

prog = re.compile[pattern]
result = prog.match[string]

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

5532, các đối số nhómN 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, một ngoại lệ

prog = re.compile[pattern]
result = prog.match[string]

44 sẽ xuất hiện

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

550

Các nhóm được đặt tên cũng có thể được gọi bằng chỉ số của họ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

551

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

552

Trùng khớp. __getitem__[g] ¶

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

prog = re.compile[pattern]
result = prog.match[string]

48. Điều này cho phép truy cập dễ dàng hơn vào một nhóm riêng lẻ từ một trận đấu

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

553

Các nhóm được đặt tên cũng được hỗ trợ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

554

Mới trong phiên bản 3. 6

Trùng khớp. nhóm[mặc định=Không]¶

Trả về một bộ chứa tất cả các nhóm con của trận đấu, từ 1 cho đến bao nhiêu nhóm trong mẫu. Đối số mặc định được sử dụng cho các nhóm không tham gia trận đấu;

Ví dụ

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

555

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 trừ khi đối số mặc định được đưa ra

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

556

Trùng khớp. groupdict[mặc định=Không]¶

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

557

Trùng khớp. bắt đầu[[nhóm] . ]¶Match.kết thúc[[nhóm]]¶

Trả về các chỉ số bắt đầu và kết thúc của chuỗi con được khớp theo nhóm; . Trả lại

prog = re.compile[pattern]
result = prog.match[string]

52 nếu nhóm tồn tại nhưng không đóng góp vào trận đấu. Đối với một đối tượng khớp m và một nhóm g đã đóng góp vào khớp, chuỗi con được khớp bởi nhóm g [tương đương với

prog = re.compile[pattern]
result = prog.match[string]

48] là

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

558

Lưu ý rằng

prog = re.compile[pattern]
result = prog.match[string]

54 sẽ bằng

prog = re.compile[pattern]
result = prog.match[string]

55 nếu nhóm khớp với chuỗi rỗng. Ví dụ: sau

prog = re.compile[pattern]
result = prog.match[string]

56,

prog = re.compile[pattern]
result = prog.match[string]

57 là 1,

prog = re.compile[pattern]
result = prog.match[string]

58 là 2,

prog = re.compile[pattern]
result = prog.match[string]

59 và

prog = re.compile[pattern]
result = prog.match[string]

60 đều là 2 và

prog = re.compile[pattern]
result = prog.match[string]

61 đưa ra một ngoại lệ

prog = re.compile[pattern]
result = prog.match[string]

Một ví dụ sẽ xóa remove_this khỏi địa chỉ email

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

559

Trùng khớp. span[[nhóm]]¶

Đối với một trận đấu m, trả về 2-tuple

prog = re.compile[pattern]
result = prog.match[string]

63. Lưu ý rằng nếu nhóm không đóng góp vào trận đấu, đây là

prog = re.compile[pattern]
result = prog.match[string]

64. nhóm mặc định là 0, toàn bộ trận đấu

Trùng khớp. tư thế ¶

Giá trị của pos được truyền cho phương thức

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 của đối tượng biểu thức chính quy . Đây là chỉ mục trong chuỗi mà công cụ RE bắt đầu tìm kiếm kết quả khớp.

Trùng khớp. endpos ¶

Giá trị của endpos đã được truyền cho phương thức

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 của đối tượng biểu thức chính quy . Đây là chỉ mục vào chuỗi mà công cụ RE sẽ không hoạt động.

Trùng khớp. lastindex ¶

Chỉ số số nguyên của nhóm chụp được khớp cuối cùng hoặc

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu không có nhóm nào được khớp. Ví dụ: các biểu thức

prog = re.compile[pattern]
result = prog.match[string]

70,

prog = re.compile[pattern]
result = prog.match[string]

71 và

prog = re.compile[pattern]
result = prog.match[string]

72 sẽ có

prog = re.compile[pattern]
result = prog.match[string]

73 nếu được áp dụng cho chuỗi

prog = re.compile[pattern]
result = prog.match[string]

74, trong khi biểu thức

prog = re.compile[pattern]
result = prog.match[string]

75 sẽ có

prog = re.compile[pattern]
result = prog.match[string]

76, nếu được áp dụng cho cùng một chuỗi

Trùng khớp. nhóm cuối cùng ¶

Tên của nhóm chụp được khớp cuối cùng hoặc

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5664 nếu nhóm không có tên hoặc nếu không có nhóm nào khớp cả

Trùng khớp. lại ¶

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 tạo ra thể hiện so khớp này.

Trùng khớp. chuỗi ¶

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 hoặc

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417

Đã thay đổi trong phiên bản 3. 7. Đã thêm hỗ trợ cho

prog = re.compile[pattern]
result = prog.match[string]

31 và

prog = re.compile[pattern]
result = prog.match[string]

32. Các đối tượng phù hợp được coi là nguyên tử.

Các ví dụ về biểu thức chính quy¶

Kiểm tra một cặp¶

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

540

Giả sử bạn đang viết một chương trình chơi bài xì phé trong đó ván bài của người chơi được biểu diễn dưới dạng một chuỗi 5 ký tự với mỗi ký tự đại diện cho một lá bài, “a” cho quân át, “k” cho quân vua, “q” cho quân hậu, “j” cho quân jack,

Để xem một chuỗi đã cho có phải là một ván bài hợp lệ hay không, người ta có thể làm như sau

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

541

Bàn tay cuối cùng đó,

prog = re.compile[pattern]
result = prog.match[string]

84, chứa một cặp hoặc hai quân bài có giá trị giống nhau. Để khớp điều này với một biểu thức chính quy, người ta có thể sử dụng phản hồi như vậy

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

542

Để tìm ra cặp thẻ bao gồm những gì, người ta có thể sử dụng phương pháp

prog = re.compile[pattern]
result = prog.match[string]

85 của đối tượng khớp theo cách sau

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

543

Mô phỏng scanf[]¶

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

prog = re.compile[pattern]
result = prog.match[string]

86. Biểu thức chính quy thường mạnh hơn, mặc dù cũng dài dòng hơn chuỗi định dạng

prog = re.compile[pattern]
result = prog.match[string]

86. Bảng bên dưới cung cấp một số ánh xạ tương đương ít nhiều giữa mã thông báo định dạng

prog = re.compile[pattern]
result = prog.match[string]

86 và biểu thức chính quy

Mã thông báo

prog = re.compile[pattern]
result = prog.match[string]

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

prog = re.compile[pattern]
result = prog.match[string]

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

prog = re.compile[pattern]
result = prog.match[string]

prog = re.compile[pattern]
result = prog.match[string]

prog = re.compile[pattern]
result = prog.match[string]

prog = re.compile[pattern]
result = prog.match[string]

prog = re.compile[pattern]
result = prog.match[string]

96,

prog = re.compile[pattern]
result = prog.match[string]

97,

prog = re.compile[pattern]
result = prog.match[string]

98,

prog = re.compile[pattern]
result = prog.match[string]

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

300

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

301

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

302

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

303

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

304

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

305

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

306

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

307

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

308

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

309,

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

310

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

311

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

544

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

prog = re.compile[pattern]
result = prog.match[string]

86 như

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

545

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

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

546

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

Python cung cấp các hoạt động nguyên thủy khác nhau dựa trên các biểu thức chính quy

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5667 chỉ kiểm tra sự trùng khớp ở đầu chuỗi

```
>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] 
```
314 kiểm tra sự trùng khớp ở bất kỳ đâu trong chuỗi [đây là điều mà Perl thực hiện theo mặc định]

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

315 kiểm tra xem toàn bộ chuỗi có khớp không

Ví dụ

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

547

Biểu thức chính quy bắt đầu bằng

prog = re.compile[pattern]
result = prog.match[string]

396 có thể được sử dụng với

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 để hạn chế khớp ở đầu chuỗi

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

548

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

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

35,

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5418 chỉ khớp ở đầu chuỗi, trong khi sử dụng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

5417 với biểu thức chính quy bắt đầu bằng

prog = re.compile[pattern]
result = prog.match[string]

396 sẽ khớp ở đầu mỗi dòng

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

549

Tạo danh bạ¶

prog = re.compile[pattern]
result = prog.match[string]

20 tách một chuỗi thành một danh sách được phân tách bằng mẫu đã truyền. Phương pháp này là vô giá để chuyển đổi dữ liệu văn bản thành cấu trúc dữ liệu mà Python có thể dễ dàng đọc và sửa đổi như được minh họa trong ví dụ sau để tạo 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 trích dẫn ba lần

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

560

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 trống có mục nhập riêng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

561

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

323 của

prog = re.compile[pattern]
result = prog.match[string]

20 vì địa chỉ có dấu cách, mẫu phân tách của chúng tôi, trong đó

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

562

Mẫu

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

325 khớp với dấu hai chấm sau họ để nó không xuất hiện trong danh sách kết quả. Với một

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

323 của

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

327, chúng ta có thể tách số nhà ra khỏi tên đường

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

563

Nhập văn bản¶

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688 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 minh họa việc sử dụng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

5688 với chức năng “munge” văn bản hoặc sắp xếp ngẫu nhiên thứ tự của tất cả các ký tự trong mỗi từ của câu ngoại trừ ký tự đầu tiên và ký tự cuối cùng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

564

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

prog = re.compile[pattern]
result = prog.match[string]

21 khớp với tất cả các lần xuất hiện của một mẫu, không chỉ mẫu đầu tiên như

>>> mwords
['Mary', 'had', 'a', 'little', 'lamb'] 
>>> ' '.join[mwords]
'Mary had a little lamb'

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

prog = re.compile[pattern]
result = prog.match[string]

21 theo cách sau

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

565

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

Nếu một người muốn biết thêm thông tin về tất cả các đối sánh của một mẫu hơn là văn bản đối sánh, thì

prog = re.compile[pattern]
result = prog.match[string]

23 sẽ hữu ích vì nó cung cấp đối tượng đối sánh thay vì các chuỗi. Tiếp tục với ví dụ trước, nếu một người viết 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

prog = re.compile[pattern]
result = prog.match[string]

23 theo cách sau.

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

566

Ký hiệu chuỗi thô¶

Ký hiệu chuỗi thô [

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

335] giữ cho biểu thức chính quy lành mạnh. Không có nó, mọi dấu gạch chéo ngược [

prog = re.compile[pattern]
result = prog.match[string]

4] trong một biểu thức chính quy sẽ phải được đặt trước bằng một dấu gạch chéo ngược khác để thoát khỏi nó. Ví dụ: hai dòng mã sau giống hệt nhau về mặt chức năng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

567

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

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

337. Không có ký hiệu chuỗi thô, người ta phải sử dụng

>>> list['hello world']
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

338, làm cho các dòng mã sau giống hệt nhau về mặt chức năng

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

568

Viết Tokenizer¶

Trình mã thông báo hoặc trình 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 trong việc viết trình biên dịch hoặc trình thông dịch

Các loại văn bản được chỉ định với các biểu thức chính quy. Kỹ thuật này là kết hợp chúng thành một biểu thức chính quy duy nhất và lặp lại các kết quả khớp liên tiếp

>>> '--'.join[mwords]
'Mary--had--a--little--lamb' 
>>> '\t'.join[mwords]
'Mary\thad\ta\tlittle\tlamb' 
>>> print['\t'.join[mwords]]
Mary    had     a       little  lamb

569

Trình mã thông báo tạo đầu ra sau

prog = re.compile[pattern]
result = prog.match[string]

Frie09

Friedl, Jeffrey. Nắm vững các biểu thức chính quy. tái bản lần 3. , O'Reilly Media, 2009. Ấn bản thứ ba của cuốn sách không còn đề cập đến Python nữa, nhưng ấn bản đầu tiên đề cập đến việc viết các mẫu biểu thức chính quy rất chi tiết

Tách một câu thành từ. . tách ra[]

Tách trên một chuỗi con cụ thể

Chuỗi thành một danh sách các ký tự. danh sách[]

Tham gia một danh sách các chuỗi. . tham gia[]

Cú pháp biểu thức chính quy¶

Nội dung mô-đun¶

Cờ¶

Chức năng¶

Ngoại lệ¶

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

Khớp các đối tượng¶

Các ví dụ về biểu thức chính quy¶

Kiểm tra một cặp¶

Mô phỏng scanf[]¶

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

Tạo danh bạ¶

Nhập văn bản¶

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

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

Ký hiệu chuỗi thô¶

Viết Tokenizer¶

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề