Hướng dẫn python regex match 2 digits - khớp python regex 2 chữ số
|
Tôi đã có một tệp văn bản rất dài do kết quả của một bài kiểm tra đêm qua. Thật ngu ngốc, tôi quên định dạng nó một cách chính xác với a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")2. Một mẫu là: Show
a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")3 Như bạn có thể thấy không có khoảng trống giữa cuối dấu thời gian của Epoch và tên tệp văn bản. May mắn thay, mỗi tệp văn bản bắt đầu với hai số và dấu gạch nối. Vì vậy, mẫu trên sẽ trông như thế này: 01-someText151645.txt,Wed Feb 1 16:15:18 2012,1328112918.578 01-someText151646.txt,Wed Feb 1 16:15:18 2012,1328112918.578 Thật không may, một dự án trước đó, nơi tôi có rất nhiều phân tích cú pháp regex không phải là tay và do đó cần một chút trợ giúp để có được một regex cho việc này. Kế hoạch của tôi là sau đó sử dụng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")4 để có được thông tin tôi muốn. Chỉnh sửa: Chỉ để nói rõ ràng rằng mỗi dòng có tên tệp văn bản, dấu thời gian ngày và thời gian, tất cả được phân tách bằng "," (không có khoảng trắng). Mỗi tập tin bắt đầu với 2 chữ số và dấu gạch nối. Vì vậy, đó là: a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")5, TextFile = a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")6
Trong bài viết này, chúng tôi chỉ ra cách khớp một số với một lượng chữ số nhất định trong Python bằng cách sử dụng biểu thức thông thường. Giả sử, chúng tôi muốn phù hợp với năm trong một chuỗi. Một năm là một số 4 chữ số, chẳng hạn như 2016 hoặc 2017. Với Python, chúng ta có thể ra các chữ số có độ dài nhất định. Chúng tôi chỉ trích xuất các số 4 chữ số từ một chuỗi. Chúng ta chỉ có thể trích xuất các số 1 chữ số hoặc số 2 chữ số hoặc số 3 chữ số hoặc số 4 chữ số hoặc số 5 chữ số, v.v. Chúng tôi thực hiện điều này thông qua biểu thức chính quy, regex = "\ d {4}" Đầu tiên, chúng tôi chỉ định rằng chúng tôi muốn số là một chữ số theo, \ D Sau đó, chúng tôi, trong niềng răng squiggly, ở bên phải của điều này, đặt số chữ số chúng tôi muốn số lượng. Vì chúng tôi đang tìm cách trích xuất một năm, mà hầu hết thời gian được biểu diễn dưới dạng số 4 chữ số, chúng tôi có câu lệnh, regex = "\ d {4}" Hãy xem cách thức hoạt động trong ví dụ dưới đây. Vì vậy, bây giờ chúng ta hãy xem qua mã này. Re là mô -đun trong Python cho phép chúng tôi sử dụng các biểu thức thông thường. Vì vậy, trước tiên chúng tôi phải nhập RE trong mã của chúng tôi, để sử dụng các biểu thức chính quy. Sau này, chúng tôi có một biến, cụm từ, chứa chuỗi mà chúng tôi muốn tìm kiếm bằng cách sử dụng các biểu thức thông thường. Bạn có thể thấy rằng chuỗi này có nhiều số trong đó. Sau đó, chúng tôi có một biến, regex, được đặt bằng, "\ d {4}" Biểu thức chính quy này tìm thấy các chữ số có chiều dài 4 chữ số. Sau đó, chúng tôi sử dụng hàm re.findall () để tìm tất cả các khớp trong chuỗi. Điều này trả về ['1991'], mà bạn có thể thấy là một danh sách. Nếu bạn muốn trả về kết quả dưới dạng chuỗi, thì bạn nên thực hiện một vòng lặp và sau đó kết quả sẽ được trả về dưới dạng chuỗi. Vì vậy, bây giờ chúng tôi đã đi qua cách tìm kiếm một chữ số có độ dài nhất định trong Python bằng cách sử dụng các biểu thức thông thường. Nhưng điều gì sẽ xảy ra nếu chúng ta không muốn một chữ số hoàn toàn có độ dài cố định? Điều gì sẽ xảy ra nếu chúng ta muốn tìm kiếm một chữ số từ 4 đến 6 chữ số, ví dụ> Chúng tôi sẽ làm điều này với biểu thức thông thường, regex = "\ d {4,6}" Vì vậy, bây giờ bất kỳ số nào dài 4-6 chữ số sẽ được trả lại. Vì vậy, với mã sau đây, bạn thấy điều này. Vì vậy, bạn có thể thấy, 25, 1 và 300 bị loại bỏ, vì chúng dưới 4 chữ số. 1991, 14000 và 20000 là từ 4 đến 6 chữ số. Vì vậy, chúng được bao gồm. Và đây là cách bạn có thể khớp với một số với một lượng chữ số nhất định trong Python bằng cách sử dụng các biểu thức thông thường. Tài nguyên liên quan Mã nguồn: lib/re/ Lib/re/ Mô -đun này cung cấp các hoạt động khớp biểu thức thường xuyên tương tự như các hoạt động được tìm thấy trong Perl. Cả hai mẫu và chuỗi sẽ được tìm kiếm có thể là chuỗi Unicode ( a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")7) cũng như các chuỗi 8 bit ( a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")8). Tuy nhiên, các chuỗi unicode và chuỗi 8 bit không thể được trộn lẫn: nghĩa là, bạn không thể khớp với một chuỗi unicode với mẫu byte hoặc ngược lại; Tương tự, khi yêu cầu thay thế, chuỗi thay thế phải cùng loại với cả mẫu và chuỗi tìm kiếm. Biểu thức chính quy sử dụng ký tự dấu gạch chéo ngược ( a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9) để biểu thị các hình thức đặc biệt hoặc cho phép các ký tự đặc biệt được sử dụng mà không cần gọi ý nghĩa đặc biệt của chúng. Điều này va chạm với việc sử dụng Python sườn của cùng một nhân vật cho cùng một mục đích trong các chữ viết; Ví dụ, để phù hợp với một dấu gạch chéo ngược theo nghĩa đen, người ta có thể phải viết prog = re.compile(pattern) result = prog.match(string)0 dưới dạng chuỗi mẫu, bởi vì biểu thức thông thường phải là prog = re.compile(pattern) result = prog.match(string)1 và mỗi dấu gạch chéo ngược phải được biểu thị dưới dạng prog = re.compile(pattern) result = prog.match(string)1 bên trong một chuỗi python thông thường theo nghĩa đen. Ngoài ra, xin lưu ý rằng bất kỳ trình tự thoát hiểm không hợp lệ nào trong việc sử dụng Python, của dấu gạch chéo ngược trong các chữ viết hiện tại sẽ tạo ra một prog = re.compile(pattern) result = prog.match(string)3 và trong tương lai, điều này sẽ trở thành prog = re.compile(pattern) result = prog.match(string)4. Hành vi này sẽ xảy ra ngay cả khi đó là một chuỗi thoát hợp lệ cho một biểu thức chính quy. Giải pháp là sử dụng ký hiệu chuỗi thô Python sườn cho các mẫu biểu thức thông thường; Backslashes không được xử lý theo bất kỳ cách đặc biệt nào trong một chuỗi theo nghĩa đen được đặt trước với prog = re.compile(pattern) result = prog.match(string)5. Vì vậy, prog = re.compile(pattern) result = prog.match(string)6 là một chuỗi hai ký tự chứa a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 và prog = re.compile(pattern) result = prog.match(string)8, trong khi prog = re.compile(pattern) result = prog.match(string)9 là một chuỗi một ký tự có chứa một dòng mới. Thông thường các mẫu sẽ được thể hiện trong mã Python bằng cách sử dụng ký hiệu chuỗi thô này. Điều quan trọng cần lưu ý là hầu hết các hoạt động biểu thức chính quy đều có sẵn dưới dạng các hàm và phương thức cấp độ mô-đun trên các biểu thức được biên dịch thông thường. Các chức năng là các phím tắt mà don don yêu cầu bạn biên dịch một đối tượng Regex trước, nhưng bỏ lỡ một số tham số tinh chỉnh.compiled regular expressions. The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters. Xem thêm Mô-đun Regex của bên thứ ba, có API tương thích với mô-đun thư viện tiêu chuẩn result = re.match(pattern, string)0, nhưng cung cấp chức năng bổ sung và hỗ trợ Unicode kỹ lưỡng hơn. Biểu thức thông thường cú phápMột biểu thức chính quy (hoặc re) chỉ định một tập hợp các chuỗi phù hợp với nó; Các hàm trong mô -đun này cho phép bạn kiểm tra xem một chuỗi cụ thể có khớp với biểu thức chính quy nhất định không (hoặc nếu một biểu thức chính quy nhất định khớp với một chuỗi cụ thể, đi xuống cùng một điều). Biểu thức thông thường có thể được nối để tạo thành các biểu thức thường xuyên mới; Nếu A và B đều là biểu thức chính quy, thì AB cũng là một biểu thức chính quy. Nói chung, nếu chuỗi P khớp với A và một chuỗi Q khác khớp với B, chuỗi PQ sẽ khớp với AB. Điều này giữ trừ khi A hoặc B chứa các hoạt động ưu tiên thấp; điều kiện biên giữa a và b; hoặc đã đánh số tài liệu tham khảo nhóm. Do đó, các biểu thức phức tạp có thể dễ dàng được xây dựng từ các biểu thức nguyên thủy đơn giản hơn như các biểu thức được mô tả ở đây. Để biết chi tiết về lý thuyết và thực hiện các biểu thức thường xuyên, hãy tham khảo cuốn sách Friedl [FRIE09] hoặc gần như bất kỳ cuốn sách giáo khoa nào về xây dựng trình biên dịch.[Frie09], or almost any textbook about compiler construction. Một lời giải thích ngắn gọn về định dạng của các biểu thức thường xuyên sau. Để biết thêm thông tin và một bài thuyết trình nhẹ nhàng hơn, hãy tham khảo ý kiến biểu thức thường xuyên.Regular Expression HOWTO. Biểu thức chính quy có thể chứa cả các ký tự đặc biệt và thông thường. Hầu hết các ký tự thông thường, như result = re.match(pattern, string)1, result = re.match(pattern, string)2 hoặc result = re.match(pattern, string)3, là các biểu thức chính quy đơn giản nhất; Họ chỉ đơn giản là phù hợp với chính họ. Bạn có thể kết hợp các ký tự thông thường, vì vậy result = re.match(pattern, string)4 khớp với chuỗi result = re.match(pattern, string)5. . Một số ký tự, như result = re.match(pattern, string)8 hoặc result = re.match(pattern, string)9, là đặc biệt. Các ký tự đặc biệt là đại diện cho các lớp các ký tự thông thường hoặc ảnh hưởng đến cách các biểu thức chính quy xung quanh chúng được giải thích. Các toán tử hoặc định lượng lặp lại ( >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']0, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']1, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']2, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']3, v.v.) không thể được lồng trực tiếp. Điều này tránh sự mơ hồ với hậu tố biến đổi không màu xanh lá cây >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']2 và với các công cụ sửa đổi khác trong các triển khai khác. Để áp dụng sự lặp lại thứ hai cho sự lặp lại bên trong, dấu ngoặc đơn có thể được sử dụng. Ví dụ: biểu thức >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']5 khớp với bất kỳ bội số nào của sáu ký tự result = re.match(pattern, string)2. Các nhân vật đặc biệt là: >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']7 (Dot.) Trong chế độ mặc định, điều này phù hợp với bất kỳ ký tự nào ngoại trừ dòng mới. Nếu cờ >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']8 đã được chỉ định, điều này phù hợp với bất kỳ ký tự nào bao gồm cả dòng mới. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']9 . >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']1 Khớp với phần cuối của chuỗi hoặc ngay trước dòng mới ở cuối chuỗi và ở chế độ >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']0 cũng khớp với một dòng mới. >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']3 phù hợp với cả ‘foo, và‘ foobar, trong khi biểu thức thông thường >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']4 chỉ khớp với ‘foo. Thú vị hơn, việc tìm kiếm >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']5 trong >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']6 phù hợp với ‘FOO2, thông thường, nhưng‘ FOO1, ở chế độ >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']0; Tìm kiếm một >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']1 trong >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']9 sẽ tìm thấy hai đối sánh (trống): một ngay trước dòng mới và một ở cuối chuỗi. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']0 Làm cho RE kết quả khớp với 0 hoặc nhiều sự lặp lại của RE trước đó, càng nhiều lần lặp lại càng tốt. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'01 sẽ phù hợp với ’A,’ ab, hoặc ‘A, sau đó là bất kỳ số lượng‘ Biên. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']1 Làm cho RE kết quả phù hợp với 1 hoặc nhiều sự lặp lại của Re trước. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'03 sẽ phù hợp với ’A, theo sau là bất kỳ số lượng‘ Biên nào; Nó sẽ không chỉ phù hợp với ’a. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']2 Làm cho kết quả RE khớp với 0 hoặc 1 lần lặp lại của Re trước. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'05 sẽ phù hợp với ‘A, hoặc‘ AB. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'06, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'07, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'08 Các bộ định lượng >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'09, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'10 và >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'11 đều tham lam; Họ phù hợp với văn bản càng nhiều càng tốt. Đôi khi hành vi này không phải là mong muốn; Nếu RE >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'12 phù hợp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'13, nó sẽ khớp với toàn bộ chuỗi và không chỉ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'14. Thêm >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']2 sau khi bộ định lượng làm cho nó thực hiện trận đấu theo kiểu không xanh hoặc tối thiểu; Càng ít ký tự càng tốt sẽ được khớp. Sử dụng RE >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'16 sẽ chỉ khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'14. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'18, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'19, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'20 Giống như các bộ định lượng >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'09, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'10 và >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'11, những người trong đó >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'10 được thêm vào cũng phù hợp với càng nhiều lần càng tốt. 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à định lượng sở hữu. Ví dụ, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'25 sẽ khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'26 vì >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'27 sẽ khớp với tất cả 4 result = re.match(pattern, string)2s, nhưng, khi gặp phải result = re.match(pattern, string)2 cuối cùng, biểu thức được quay lại để cuối cùng >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'27 kết thúc. result = re.match(pattern, string)2 cuối cùng. Tuy nhiên, khi >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'34 được sử dụng để khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'26, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'36 sẽ khớp với tất cả 4 result = re.match(pattern, string)2, nhưng khi cuối cùng ____72 không tìm thấy bất kỳ ký tự nào để khớp, biểu thức không thể bị quay lại và do đó sẽ không khớp được. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'39, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'40 và >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'41 tương đương với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'42, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'43 và >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'44 tương ứng. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'45 Chỉ định rằng chính xác các bản sao m của RE trước đó phải được khớp; Ít trận đấu hơn khiến toàn bộ RE không phù hợp. Ví dụ: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'46 sẽ khớp chính xác sáu ký tự ____72, nhưng không phải năm ký tự. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']3 Làm cho RE kết quả phù hợp từ M đến N lặp lại của RE trước đó, cố gắng khớp với càng nhiều lần lặp lại càng tốt. Ví dụ: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'49 sẽ khớp từ 3 đến 5 result = re.match(pattern, string)2 ký tự. Bỏ qua M chỉ định giới hạn dưới bằng 0 và bỏ qua N chỉ định giới hạn trên vô hạn. Ví dụ, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'51 sẽ khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'52 hoặc một nghìn ký tự result = re.match(pattern, string)2 theo sau là >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'54, nhưng không phải >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'55. Dấu phẩy có thể không bị bỏ qua hoặc công cụ sửa đổi sẽ bị nhầm lẫn với mẫu được mô tả trước đó. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'56 Làm cho RE kết quả phù hợp từ M đến N lặp lại của Re trước, cố gắng khớp với càng ít sự lặp lại càng tốt. Đây là phiên bản không màu xanh của bộ định lượng trước đó. Ví dụ: trên chuỗi 6 ký tự >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'57, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'49 sẽ khớp với 5 result = re.match(pattern, string)2 ký tự, trong khi >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'60 sẽ chỉ khớp với 3 ký tự. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'61 Làm cho RE kết quả khớp với các lần lặp lại của M đến N 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 cần thiết lập bất kỳ điểm quay lại 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ự >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'57, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'63 Cố gắng khớp với 5 ký tự result = re.match(pattern, string)2, sau đó, yêu cầu thêm 2 result = re.match(pattern, string)2, sẽ cần nhiều ký tự hơn có sẵn và do đó thất bại, trong khi >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'66 sẽ khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'49. và sau đó 2 result = re.match(pattern, string)2 cuối cùng được khớp với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'70 cuối cùng trong mẫu. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'71 tương đương với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'72. Mới trong phiên bản 3.11. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'73 Hoặc thoát khỏi các ký tự đặc biệt (cho phép bạn khớp các ký tự như >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'09, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'11, v.v.) hoặc báo hiệu một chuỗi đặc biệt; Trình tự đặc biệt được thảo luận dưới đây. Nếu bạn không sử dụng một chuỗi thô để diễn đạt mẫu, hãy nhớ rằng Python cũng sử dụng dấu gạch chéo ngược như một chuỗi thoát trong các chữ viết; Nếu trình tự thoát được công nhận bởi trình phân tích cú pháp Python, thì dấu gạch chéo ngược và ký tự tiếp theo được bao gồm trong chuỗi kết quả. Tuy nhiên, nếu Python sẽ nhận ra chuỗi kết quả, dấu gạch chéo ngược nên được lặp lại hai lần. Điều này rất phức tạp và khó hiểu, vì vậy, nó rất khuyến khích bạn sử dụng các chuỗi thô cho tất cả nhưng các biểu thức đơn giản nhất. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'76 Được sử dụng để chỉ ra một tập hợp các ký tự. Trong một tập hợp:
Thay đổi trong phiên bản 3.7: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'10 is raised if a character set contains constructs that will change semantically in the future. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'17 >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'18, trong đó A và B có thể là res tùy ý, tạo ra một biểu thức chính quy sẽ khớp với A hoặc B. Một số lượng RES tùy ý có thể được phân tách bằng result = re.match(pattern, string)8 theo cách này. Điều này có thể được sử dụng bên trong các nhóm (xem bên dưới) là tốt. Khi chuỗi đích được quét, độ phân tách bởi result = re.match(pattern, string)8 được thử từ trái sang phải. Khi một mẫu hoàn toàn phù hợp, nhánh đó được chấp nhận. Điều này có nghĩa là một khi A khớp, B sẽ không được kiểm tra thêm, ngay cả khi nó sẽ tạo ra một trận đấu tổng thể dài hơn. Nói cách khác, toán tử result = re.match(pattern, string)8 không bao giờ tham lam. Để phù hợp với nghĩa đen result = re.match(pattern, string)8, sử dụng >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'23 hoặc đặt nó bên trong một lớp ký tự, như trong >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'24. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'25 Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn, và chỉ ra sự khởi đầu và kết thúc của một nhóm; Nội dung của một nhóm có thể được truy xuất sau khi một trận đấu được thực hiện và có thể được khớp sau trong chuỗi với chuỗi đặc biệt >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'26, được mô tả bên dưới. Để phù hợp với các chữ result = re.match(pattern, string)9 hoặc >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'96, hãy sử dụng >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'29 hoặc >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'30 hoặc gửi chúng bên trong một lớp ký tự: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'31, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'32. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'33 Đây là một ký hiệu mở rộng (A >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'11 sau result = re.match(pattern, string)9 không có ý nghĩa nếu không). Nhân vật đầu tiên sau >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'11 xác định ý nghĩa và cú pháp tiếp theo của cấu trúc là gì. Phần mở rộng thường không tạo ra một nhóm mới; >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'37 là ngoại lệ duy nhất cho quy tắc này. Sau đây là các phần mở rộng hiện được hỗ trợ. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'38 . Các chữ cái đặt các cờ tương ứng: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'46 (khớp ASCII-chỉ), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'47 (trường hợp bỏ qua), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'48 (phụ thuộc vào ngôn ngữ), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'49 (đa dòng), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'50 (DOT khớp với tất cả Verbose), cho toàn bộ biểu thức chính quy. . Cờ nên được sử dụng đầu tiên trong chuỗi biểu thức.Module Contents.) This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'53 function. Flags should be used first in the expression string. Đã thay đổi trong phiên bản 3.11: Công trình này chỉ có thể được sử dụng khi bắt đầu biểu thức.This construction can only be used at the start of the expression. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'54 Một phiên bản không bắt giữ của dấu ngoặc đơn thông thường. Khớp với bất kỳ biểu thức chính quy nào nằm trong dấu ngoặc đơn, nhưng phần phụ mà nhóm không thể được truy xuất sau khi thực hiện một trận đấu hoặc được tham chiếu sau trong mẫu. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'55 (0 hoặc nhiều chữ cái từ tập result = re.match(pattern, string)2, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'40, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'41, >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'79, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'43, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'45, Tùy chọn theo sau Cờ: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'46 (khớp ASCII-chỉ), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'47 (trường hợp bỏ qua), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'48 (phụ thuộc vào ngôn ngữ), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'49 (đa dòng), >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'50 (DOT khớp với tất cả một phần của biểu thức. (Các cờ được mô tả trong nội dung mô -đun.)Module Contents.) Các chữ cái result = re.match(pattern, string)2, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'41 và >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44 là loại trừ lẫn nhau khi được sử dụng làm cờ nội tuyến, vì vậy chúng có thể được kết hợp hoặc theo dõi >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'81. 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 >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'79 chuyển sang khớp ASCII-MONY và >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'80 chuyển sang khớp unicode (mặc định). Trong mẫu byte >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'81 chuyển sang địa phương tùy thuộc vào khớp và >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'79 chuyển sang khớp ASCII-chỉ (mặc định). Ghi đè này chỉ có hiệu lực cho nhóm nội tuyến hẹp và chế độ khớp ban đầu được khôi phục bên ngoài nhóm. Mới trong phiên bản 3.6. Đã thay đổi trong phiên bản 3.7: Các chữ cái result = re.match(pattern, string)2, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'41 and >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44 also can be used in a group. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'86 Nỗ lực phù hợp với >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'87 như thể nó 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 nó. Nếu mô hình tiếp theo không khớp, ngăn xếp chỉ có thể không được đưa ra một điểm trước >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'86 vì một khi đã thoát ra, biểu thức, được gọi là một nhóm nguyên tử, đã vứt bỏ tất cả các điểm xếp chồng trong chính nó. Do đó, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'89 sẽ không bao giờ khớp với bất cứ điều gì bởi vì trước tiên >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'90 sẽ phù hợp với tất cả các ký tự có thể, sau đó, không còn gì để phù hợp, cuối cùng >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']7 sẽ không phù hợ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 đó, toàn bộ biểu thức sẽ không khớp. Mới trong phiên bản 3.11. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'37 Tương tự như dấu ngoặc đơn thông thường, nhưng phần phụ được khớp với tên nhóm có thể truy cập thông qua tên nhóm tượng trưng. Tên nhóm phải là định danh Python hợp lệ và mỗi tên nhóm chỉ được xác định một lần trong một biểu thức chính quy. Một nhóm tượng trưng cũng là một nhóm được đánh số, giống như nhóm không được đặt tên. Các nhóm được đặt tên có thể được tham chiếu trong ba bối cảnh. Nếu mẫu là >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'93 (nghĩa là khớp một chuỗi được trích dẫn với trích dẫn đơn hoặc đôi):
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 các mẫu byte.Group names containing non-ASCII characters in bytes patterns. \a \b \f \n \N \r \t \u \U \v \x \\02 Một bản sao lưu cho một nhóm được đặt tên; Nó phù hợp với bất kỳ văn bản nào phù hợp với tên nhóm trước đó được đặt tên. \a \b \f \n \N \r \t \u \U \v \x \\03 Một lời bình luận; Nội dung của dấu ngoặc đơn giản là bỏ qua. \a \b \f \n \N \r \t \u \U \v \x \\04 Khớp nếu >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'87 khớp với tiếp theo, nhưng không tiêu thụ bất kỳ chuỗi nào. Đây được gọi là một khẳng định lookahead. Ví dụ: \a \b \f \n \N \r \t \u \U \v \x \\06 sẽ chỉ khớp với \a \b \f \n \N \r \t \u \U \v \x \\07 nếu nó theo sau là \a \b \f \n \N \r \t \u \U \v \x \\08. \a \b \f \n \N \r \t \u \U \v \x \\09 Phù hợp nếu >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'87 không phù hợp với tiếp theo. Đây là một khẳng định cái nhìn tiêu cực. Ví dụ: \a \b \f \n \N \r \t \u \U \v \x \\11 sẽ chỉ khớp với \a \b \f \n \N \r \t \u \U \v \x \\07 nếu nó không theo sau là \a \b \f \n \N \r \t \u \U \v \x \\08. \a \b \f \n \N \r \t \u \U \v \x \\14 Khớp nếu vị trí hiện tại trong chuỗi được đi trước bởi một trận đấu cho >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'87 kết thúc ở vị trí hiện tại. Điều này được gọi là một khẳng định tầm nhìn tích cực. \a \b \f \n \N \r \t \u \U \v \x \\16 sẽ tìm thấy một trận đấu trong \a \b \f \n \N \r \t \u \U \v \x \\17, vì Lookbehind sẽ sao lưu 3 ký tự và kiểm tra xem mẫu chứa có khớp không. Mẫu chứa chỉ phải khớp với các chuỗi có độ dài cố định, có nghĩa là \a \b \f \n \N \r \t \u \U \v \x \\18 hoặc \a \b \f \n \N \r \t \u \U \v \x \\19 được cho phép, nhưng không phải là >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'27 và \a \b \f \n \N \r \t \u \U \v \x \\21. Lưu ý rằng các mẫu bắt đầu với các xác nhận Lookehind tích cực sẽ không khớp khi bắt đầu chuỗi được tìm kiếm; Rất có thể bạn sẽ muốn sử dụng chức năng \a \b \f \n \N \r \t \u \U \v \x \\22 thay vì hàm \a \b \f \n \N \r \t \u \U \v \x \\23: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def' Ví dụ này tìm kiếm một từ sau một dấu gạch nối: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg' Đã thay đổi trong phiên bản 3.5: Đã thêm hỗ trợ cho các tài liệu tham khảo nhóm có độ dài cố định.Added support for group references of fixed length. \a \b \f \n \N \r \t \u \U \v \x \\24 Khớp nếu vị trí hiện tại trong chuỗi không đi trước một trận đấu cho >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'87. Đây được gọi là một khẳng định tiêu cực. Tương tự như các khẳng định hướng tích cực, mẫu chứa chỉ phải khớp với một số chuỗi có độ dài cố định. Các mẫu bắt đầu với các xác nhận trông tiêu cực có thể khớp với đầu chuỗi được tìm kiếm. \a \b \f \n \N \r \t \u \U \v \x \\26 Sẽ cố gắng khớp với \a \b \f \n \N \r \t \u \U \v \x \\27 nếu nhóm có ID hoặc tên đã cho tồn tại và với \a \b \f \n \N \r \t \u \U \v \x \\28 nếu nó không. \a \b \f \n \N \r \t \u \U \v \x \\28 là tùy chọn và có thể được bỏ qua. Ví dụ: \a \b \f \n \N \r \t \u \U \v \x \\30 là một mẫu khớp email kém, sẽ phù hợp với \a \b \f \n \N \r \t \u \U \v \x \\31 cũng như \a \b \f \n \N \r \t \u \U \v \x \\32, nhưng không phải với \a \b \f \n \N \r \t \u \U \v \x \\33 cũng như \a \b \f \n \N \r \t \u \U \v \x \\34. Đã không dùng từ phiên bản 3.11: ID nhóm chứa bất cứ thứ gì ngoại trừ các chữ số ASCII.Group id containing anything except ASCII digits. Các chuỗi đặc biệt bao gồm a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 và một ký tự từ danh sách dưới đây. Nếu ký tự thông thường không phải là chữ số ASCII hoặc chữ ASCII, thì kết quả sẽ phù hợp với ký tự thứ hai. Ví dụ, \a \b \f \n \N \r \t \u \U \v \x \\36 khớp với ký tự \a \b \f \n \N \r \t \u \U \v \x \\37. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'26 Khớp với nội dung của nhóm của cùng một số. Các nhóm được đánh số bắt đầu từ 1. Ví dụ: \a \b \f \n \N \r \t \u \U \v \x \\39 khớp với \a \b \f \n \N \r \t \u \U \v \x \\40 hoặc \a \b \f \n \N \r \t \u \U \v \x \\41, nhưng không phải \a \b \f \n \N \r \t \u \U \v \x \\42 (lưu ý không gian sau nhóm). Trình tự đặc biệt này chỉ có thể được sử dụng để phù hợp với một trong 99 nhóm đầu tiên. Nếu chữ số đầu tiên của số là 0, hoặc số dài 3 chữ số, nó sẽ không được hiểu là khớp nhóm, nhưng là ký tự có số giá trị bát phân. Bên trong >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'11 và >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'07 của một lớp ký tự, tất cả các lối thoát số được coi là ký tự. \a \b \f \n \N \r \t \u \U \v \x \\45 Chỉ khớp khi bắt đầu chuỗi. \a \b \f \n \N \r \t \u \U \v \x \\46 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, \a \b \f \n \N \r \t \u \U \v \x \\46 được định nghĩa là ranh giới giữa một ký tự >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'97 và \a \b \f \n \N \r \t \u \U \v \x \\49 (hoặc ngược lại) hoặc giữa >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'97 và đầu/đầu của chuỗi. Điều này có nghĩa là \a \b \f \n \N \r \t \u \U \v \x \\51 khớp với \a \b \f \n \N \r \t \u \U \v \x \\52, \a \b \f \n \N \r \t \u \U \v \x \\53, \a \b \f \n \N \r \t \u \U \v \x \\54, \a \b \f \n \N \r \t \u \U \v \x \\55 nhưng không phải \a \b \f \n \N \r \t \u \U \v \x \\56 hoặc \a \b \f \n \N \r \t \u \U \v \x \\57. Theo mặc định Unicode Alphanumerics là những người được sử dụng trong các mẫu Unicode, nhưng điều này có thể được thay đổi bằng cách sử dụng cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99. Ranh giới từ được xác định bởi địa phương hiện tại nếu cờ >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'00 được sử dụng. Bên trong một phạm vi ký tự, \a \b \f \n \N \r \t \u \U \v \x \\46 đại diện cho ký tự backspace, để tương thích với các chữ Python. \a \b \f \n \N \r \t \u \U \v \x \\61 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à \a \b \f \n \N \r \t \u \U \v \x \\62 khớp với \a \b \f \n \N \r \t \u \U \v \x \\63, \a \b \f \n \N \r \t \u \U \v \x \\64, \a \b \f \n \N \r \t \u \U \v \x \\65, nhưng không phải \a \b \f \n \N \r \t \u \U \v \x \\66, \a \b \f \n \N \r \t \u \U \v \x \\67 hoặc \a \b \f \n \N \r \t \u \U \v \x \\68. \a \b \f \n \N \r \t \u \U \v \x \\61 hoàn toàn trái ngược với \a \b \f \n \N \r \t \u \U \v \x \\46, vì vậy các ký tự từ trong các mẫu Unicode là Unicode Alphanumerics hoặc Undercore, mặc dù điều này có thể được thay đổi bằng cách sử dụng cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99. Ranh giới từ được xác định bởi địa phương hiện tại nếu cờ >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'00 được sử dụng. \a \b \f \n \N \r \t \u \U \v \x \\73 cho các mẫu Unicode (STR): Khớp với bất kỳ chữ số thập phân unicode nào (nghĩa là, bất kỳ ký tự nào trong danh mục ký tự Unicode [nd]). Điều này bao gồm \a \b \f \n \N \r \t \u \U \v \x \\74, và nhiều ký tự chữ số khác. Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 chỉ được sử dụng \a \b \f \n \N \r \t \u \U \v \x \\74 được khớp.Cho các mẫu 8 bit (byte): Phù hợp với bất kỳ chữ số thập phân; Điều này tương đương với \a \b \f \n \N \r \t \u \U \v \x \\74. \a \b \f \n \N \r \t \u \U \v \x \\78 Phù hợp với bất kỳ ký tự nào không phải là một chữ số thập phân. Đây là điều ngược lại với \a \b \f \n \N \r \t \u \U \v \x \\73. Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, điều này sẽ trở thành tương đương với \a \b \f \n \N \r \t \u \U \v \x \\81. \a \b \f \n \N \r \t \u \U \v \x \\82 cho các mẫu Unicode (STR): Khớp với các ký tự khoảng trắng Unicode (bao gồm \a \b \f \n \N \r \t \u \U \v \x \\83 và cũng có nhiều ký tự khác, ví dụ như các không gian không phá vỡ được ủy quyền bởi các quy tắc typography bằng nhiều ngôn ngữ). Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, chỉ \a \b \f \n \N \r \t \u \U \v \x \\83 được khớp.Cho các mẫu 8 bit (byte): Phù hợp với bất kỳ chữ số thập phân; Điều này tương đương với \a \b \f \n \N \r \t \u \U \v \x \\74. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'98 Phù hợp với bất kỳ ký tự nào không phải là một chữ số thập phân. Đây là điều ngược lại với \a \b \f \n \N \r \t \u \U \v \x \\73. Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, điều này sẽ trở thành tương đương với \a \b \f \n \N \r \t \u \U \v \x \\81. \a \b \f \n \N \r \t \u \U \v \x \\82 cho các mẫu Unicode (STR): Khớp với các ký tự khoảng trắng Unicode (bao gồm \a \b \f \n \N \r \t \u \U \v \x \\83 và cũng có nhiều ký tự khác, ví dụ như các không gian không phá vỡ được ủy quyền bởi các quy tắc typography bằng nhiều ngôn ngữ). Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, chỉ \a \b \f \n \N \r \t \u \U \v \x \\83 được khớp.Cho các mẫu 8 bit (byte): Phù hợp với bất kỳ chữ số thập phân; Điều này tương đương với \a \b \f \n \N \r \t \u \U \v \x \\74. \a \b \f \n \N \r \t \u \U \v \x \\49 Khớp với bất kỳ ký tự nào không phải là một ký tự từ. Đây là điều ngược lại với >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'97. Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, điều này sẽ trở thành tương đương với \a \b \f \n \N \r \t \u \U \v \x \\99. Nếu cờ >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'00 được sử dụng, khớp các ký tự không phải là chữ và số trong địa phương hiện tại cũng như dấu gạch dưới. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)01 Chỉ khớp ở cuối chuỗi. Hầu hết các ESCAPES tiêu chuẩn được hỗ trợ bởi các chuỗi chuỗi Python cũng được chấp nhận bởi trình phân tích cú pháp biểu thức thông thường: \a \b \f \n \N \r \t \u \U \v \x \\ . def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)03, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)04 và def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)05 Trình tự thoát chỉ được nhận ra trong các mẫu Unicode. Trong các mẫu byte chúng là lỗi. Những lần thoát khỏi các chữ cái ASCII được dành riêng cho việc sử dụng trong tương lai và được coi là lỗi. Escapes octal được bao gồm trong một hình thức giới hạn. Nếu chữ số đầu tiên là 0, hoặc nếu có ba chữ số bát phân, thì nó được coi là một lối thoát bát phân. Nếu không, nó là một tham chiếu nhóm. Đối với các chuỗi chữ, thoát hiểm luôn luôn có chiều dài tối đa ba chữ số. Đã thay đổi trong phiên bản 3.3: Trình tự thoát def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)03 and def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)04 escape sequences have been added. Đã thay đổi trong phiên bản 3.6: Các lối thoát chưa biết bao gồm a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 and an ASCII letter now are errors. Thay đổi trong phiên bản 3.8: Trình tự thoát def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)09 escape sequence has been added. As in string literals, it expands to the named Unicode character (e.g. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)10). Nội dung mô -đunMô -đ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 nổi bật đầy đủ cho các biểu thức thông thường đượ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à các trường hợp là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)11, which is a subclass of def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)12. Classre.Regexflag¶ re.RegexFlag¶ Một lớp def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)12 chứa các tùy chọn regex được liệt kê dưới đây. Mới trong phiên bản 3.11: - được thêm vào def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)14 Re.a¶ Re.ascii¶A¶ re.ASCII¶ Tạo >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'97, \a \b \f \n \N \r \t \u \U \v \x \\49, \a \b \f \n \N \r \t \u \U \v \x \\46, \a \b \f \n \N \r \t \u \U \v \x \\61, \a \b \f \n \N \r \t \u \U \v \x \\73, \a \b \f \n \N \r \t \u \U \v \x \\78, \a \b \f \n \N \r \t \u \U \v \x \\82 và >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'98 thực hiện khớp ASCII-chỉ khớp thay vì khớp unicode hoàn toàn. Điều này chỉ có ý nghĩa đối với các mẫu Unicode và bị bỏ qua cho các mẫu byte. Tương ứng với cờ nội tuyến def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)23. Lưu ý rằng để tương thích ngược, cờ >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'51 vẫn còn tồn tại (cũng như từ đồng nghĩa của nó def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)25 và đối tác nhúng của nó ). Re.debug¶DEBUG¶ 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. Re.I¶ re.ignorecase¶I¶ re.IGNORECASE¶Thực hiện kết hợp không nhạy cảm trường hợp; Biểu thức như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)27 cũng sẽ phù hợp với các chữ cái viết thường. Kết hợp unicode đầy đủ (chẳng hạn như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)28 khớp def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)29) cũng hoạt động trừ khi cờ def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)30 được sử dụng để vô hiệu hóa các trận đấu không ASCII. Địa điểm hiện tại không thay đổi hiệu ứng của cờ này trừ khi cờ def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)31 cũng được sử dụng. Tương ứng với cờ nội tuyến def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)32. Lưu ý rằng khi các mẫu Unicode >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'82 hoặc def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)27 được sử dụng kết hợp với cờ def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)35, chúng sẽ khớp với 52 chữ cái ASCII và 4 chữ cái không ASCII bổ sung: ' 'ı' (U+0131, chữ nhỏ Latin Dotless i), 'ſ' (u+017f, chữ nhỏ Latin dài s) và 'k' (u+212a, dấu hiệu Kelvin). Nếu cờ >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'99 được sử dụng, chỉ có các chữ cái ‘A, thành‘ Z, và ‘A, với’ Z, được khớp. Re.l¶ Re.Locale¶L¶ re.LOCALE¶ Tạo >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'97, \a \b \f \n \N \r \t \u \U \v \x \\49, \a \b \f \n \N \r \t \u \U \v \x \\46, \a \b \f \n \N \r \t \u \U \v \x \\61 và khớp không phân biệt trường hợp phụ thuộc vào địa phương hiện tại. Cờ này chỉ có thể được sử dụng với các mẫu byte. Việc sử dụng lá cờ này không được khuyến khích vì cơ chế địa phương rất không đáng tin cậy, nó chỉ xử lý một nền văn hóa của người Hồi giáo tại một thời điểm và nó chỉ hoạt động với các địa phương 8 bit. Kết hợp Unicode đã được bật theo mặc định trong Python 3 cho các mẫu Unicode (STR) và nó có thể xử lý các địa phương/ngôn ngữ khác nhau. Tương ứng với cờ nội tuyến def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)41. Đã thay đổi trong phiên bản 3.6: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)31 can be used only with bytes patterns and is not compatible with def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)30. Đã thay đổi trong phiên bản 3.7: Đã biên dịch các đối tượng biểu thức chính quy bằng cờ def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)31 flag no longer depend on the locale at compile time. Only the locale at matching time affects the result of matching. Re.m¶ Re.Multiline¶M¶ re.MULTILINE¶ Khi được chỉ định, ký tự mẫu >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01 khớp ở đầu chuỗi và ở đầu mỗi dòng (ngay sau mỗi dòng mới); và ký tự mẫu \a \b \f \n \N \r \t \u \U \v \x \\37 khớp ở cuối chuỗi và ở cuối mỗi dòng (ngay trước mỗi dòng mới). Theo mặc định, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01 chỉ khớp với đầu chuỗi và \a \b \f \n \N \r \t \u \U \v \x \\37 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 def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)49. Re.noflag¶NOFLAG¶ Cho biết không có cờ được áp dụng, giá trị là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)50. Cờ này có thể được sử dụng làm giá trị mặc định cho đối số từ khóa chức năng hoặc là giá trị cơ sở sẽ có điều kiện với các cờ khác. Ví dụ về sử dụng làm giá trị mặc định: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag) Mới trong phiên bản 3.11. Re.s¶ Re.Dotall¶S¶ re.DOTALL¶Làm cho nhân vật đặc biệt def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)51 khớp với bất kỳ ký tự nào, bao gồm cả dòng mới; Không có cờ này, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)51 sẽ khớp với bất cứ điều gì ngoại trừ một dòng mới. Tương ứng với cờ nội tuyến def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)53. Re.x¶ Re.verbose¶X¶ re.VERBOSE¶ Cờ này cho phép bạn viết các biểu thức thông thường trông đẹp hơn và dễ đọc hơn bằng cách cho phép bạn các phần logic tách biệt trực quan của mẫu và thêm nhận xét. Khoảng trắng trong mẫu bị bỏ qua, ngoại trừ khi trong một lớp ký tự hoặc khi đi trước bởi một dấu gạch chéo ngược không được phân loại hoặc trong các mã thông báo như >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'06, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)55 hoặc def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)56. Ví dụ, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)57 và def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)58 không được phép. Khi một dòng chứa một def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)59 không nằm trong một lớp ký tự và không được đặt trước bởi một dấu gạch chéo ngược không được phân loại, tất cả các ký tự từ def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)59 đến cuối cùng bên trái đều bị bỏ qua. Điều này có nghĩa là hai đối tượng biểu thức chính quy sau phù hợp với số thập phân có chức năng bằng nhau: a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*") Tương ứng với cờ nội tuyến def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)61. Chức năng¶re.compile (mẫu, cờ = 0) ¶compile(pattern, flags=0)¶Biên dịch một mẫu biểu thức chính quy thành một đối tượng biểu thức chính quy, có thể được sử dụng để kết hợp bằng cách sử dụng \a \b \f \n \N \r \t \u \U \v \x \\23, \a \b \f \n \N \r \t \u \U \v \x \\22 và các phương pháp khác, được mô tả dưới đây.regular expression object, which can be used for matching using its \a \b \f \n \N \r \t \u \U \v \x \\23, \a \b \f \n \N \r \t \u \U \v \x \\22 and other methods, described below. Hành vi biểu thức có thể được sửa đổi bằng cách chỉ định giá trị cờ. Các giá trị có thể là bất kỳ biến nào sau đây, kết hợp bằng bitwise hoặc (toán tử >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'17). Trình tự prog = re.compile(pattern) result = prog.match(string) tương đương với result = re.match(pattern, string) Nhưng sử dụng >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'53 và lưu đối tượng biểu thức chính quy kết quả để sử dụng lại hiệu quả hơn khi biểu thức sẽ được sử dụng nhiều lần trong một chương trình. Ghi chú Các phiên bản được biên dịch của các mẫu gần đây nhất được chuyển đến >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'53 và các hàm khớp cấp mô-đun được lưu trữ, vì vậy các chương trình chỉ sử dụng một vài biểu thức thông thường tại một thời điểm cần phải lo lắng về việc biên dịch các biểu thức chính quy. Re.Search (mẫu, chuỗi, cờ = 0) ¶search(pattern, string, flags=0)¶ Quét qua chuỗi Tìm kiếm vị trí đầu tiên nơi mẫu biểu thức chính quy tạo ra một khớp và trả về một đối tượng khớp tương ứng. Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 Nếu không có vị trí nào trong chuỗi khớp với mẫu; Lưu ý rằng điều này khác với việc tìm một trận đấu có độ dài bằng không tại một số điểm trong chuỗi.match object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string. Re.match (mẫu, chuỗi, cờ = 0) ¶match(pattern, string, flags=0)¶ Nếu số không hoặc nhiều ký tự ở đầu chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một đối tượng khớp tương ứng. Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if the string does not match the pattern; note that this is different from a zero-length match. Lưu ý rằng ngay cả trong chế độ >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']0, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)70 sẽ chỉ khớp ở đầu chuỗi chứ không phải ở đầu mỗi dòng. Nếu bạn muốn xác định vị trí đối sánh ở bất cứ đâu trong chuỗi, hãy sử dụng \a \b \f \n \N \r \t \u \U \v \x \\22 thay thế (xem thêm search () so với match ()).search() vs. match()). re.fullmatch (mẫu, chuỗi, cờ = 0) ¶fullmatch(pattern, string, flags=0)¶ Nếu toàn bộ chuỗi khớp với mẫu biểu thức chính quy, hãy trả về một đối tượng khớp tương ứng. Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if the string does not match the pattern; note that this is different from a zero-length match. Mới trong phiên bản 3.4. Chuỗi phân chia theo các lần xuất hiện của mẫu. Nếu chụp dấu ngoặc đơn được sử dụng trong mẫu, thì văn bản của tất cả các nhóm trong mẫu cũng được trả về như một phần của danh sách kết quả. Nếu MAXSplit là không khác biệt, tại hầu hết các phân tách MaxSplit xảy ra và phần còn lại của chuỗi được trả về làm yếu tố cuối cùng của danh sách. >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9'] Nếu có các nhóm bắt giữ trong dấu phân cách và nó khớp với đầu chuỗi, kết quả sẽ bắt đầu bằng một chuỗi trống. Tương tự giữ cho phần cuối của chuỗi: >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', ''] Bằng cách đó, các thành phần phân tách luôn được tìm thấy tại cùng một chỉ số tương đối trong danh sách kết quả. Các khớp trống cho mẫu chỉ chia chuỗi khi không liền kề với trận đấu trống trước đó. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'0 Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument. Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ chia tách trên một mẫu có thể khớp với một chuỗi trống.Added support of splitting on a pattern that could match an empty string. re.findall (mẫu, chuỗi, cờ = 0) ¶findall(pattern, string, flags=0)¶Trả về tất cả các trận đấu không chồng chéo của mẫu trong chuỗi, như một danh sách các chuỗi hoặc bộ dữ liệu. Chuỗi được quét từ trái sang phải và các trận đấu được trả về theo thứ tự được tìm thấy. Các trận đấu trống được bao gồm trong kết quả. Kết quả phụ thuộc vào số lượng nhóm chụp trong mẫu. Nếu không có nhóm, hãy trả lại một danh sách các chuỗi phù hợp với toàn bộ mẫu. Nếu có chính xác một nhóm, hãy trả lại một danh sách các chuỗi khớp với nhóm đó. Nếu có nhiều nhóm có mặt, hãy trả lại một danh sách các bộ dữ liệu phù hợp với các nhóm. Các nhóm không bắt giữ không ảnh hưởng đến hình thức của kết quả. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'1 Đã thay đổi trong phiên bản 3.7: Các trận đấu không trống hiện có thể bắt đầu ngay sau trận đấu trống trước đó.Non-empty matches can now start just after a previous empty match. re.finditer (mẫu, chuỗi, cờ = 0) ¶finditer(pattern, string, flags=0)¶Trả về một iterator mang lại các đối tượng khớp trên tất cả các kết quả không chồng chéo cho mẫu RE trong chuỗi. Chuỗi được quét từ trái sang phải và các trận đấu được trả về theo thứ tự được tìm thấy. Các trận đấu trống được bao gồm trong kết quả.iterator yielding match objects over all non-overlapping matches for the RE pattern in string. The string is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result. Đã thay đổi trong phiên bản 3.7: Các trận đấu không trống hiện có thể bắt đầu ngay sau trận đấu trống trước đó.Non-empty matches can now start just after a previous empty match. Re.sub (mẫu, repl, chuỗi, đếm = 0, cờ = 0) ¶sub(pattern, repl, 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 không chồng chéo bên trái của mẫu trong chuỗi bằng cách thay thế. Nếu mẫu được tìm thấy, chuỗi được trả về không thay đổi. REPREP có thể là một chuỗi hoặc một hàm; Nếu đó là một chuỗi, bất kỳ dấu gạch chéo ngược nào thoát trong đó được xử lý. Đó là, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)73 được chuyển đổi thành một ký tự mới, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)74 được chuyển đổi thành một trở lại vận chuyển, v.v. Những lần thoát khỏi các chữ cái ASCII được dành riêng cho việc sử dụng trong tương lai và được coi là lỗi. Những trốn thoát chưa biết khác như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)75 bị bỏ lại một mình. Các bản sao lưu, chẳng hạn như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)76, được thay thế bằng chuỗi con phù hợp với nhóm 6 trong mẫu. Ví dụ: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'2 Nếu thay thế là một hàm, nó được gọi cho mọi lần xuất hiện không chồng chéo của mẫu. Hàm có một đối số đối tượng khớp và trả về chuỗi thay thế. Ví dụ:match object argument, and returns the replacement string. For example: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'3 Các mẫu có thể là một chuỗi hoặc một đối tượng mẫu.pattern object. Số lượng đối số tùy chọn là số lượng tối đa của các lần xuất hiện mẫu được thay thế; Đếm phải là một số nguyên không âm. Nếu bị bỏ qua hoặc không, tất cả các lần xuất hiện sẽ được thay thế. Các trận đấu trống cho mẫu chỉ được thay thế khi không liền kề với trận đấu trống trước đó, do đó def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)77 trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)78. Trong các đối số thay thế loại chuỗi, ngoài các ký tự thoát ra và các bản sao lưu được mô tả ở trên, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)79 sẽ sử dụng chuỗi con phù hợp với nhóm có tên def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)80, theo định nghĩa của cú pháp >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'37. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)82 sử dụng số nhóm tương ứng; Do đó, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)83 tương đương với def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)84, nhưng không phải là mơ hồ trong việc thay thế như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)85. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)86 sẽ được hiểu là tham chiếu đến nhóm 20, không phải là tham chiếu đến nhóm 2, sau đó là ký tự nghĩa đen result = re.match(pattern, string)3. Các bản thay thế lại def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)88 trong toàn bộ chuỗi con phù hợp với RE. Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument. Thay đổi trong phiên bản 3.5: Các nhóm chưa từng có được thay thế bằng một chuỗi trống.Unmatched groups are replaced with an empty string. Đã thay đổi trong phiên bản 3.6: Các ESCAPES chưa biết trong mẫu bao gồm a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 and an ASCII letter now are errors. Đã thay đổi trong phiên bản 3.7: Những lối thoát không xác định trong việc thay thế bao gồm a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 and an ASCII letter now are errors. Đã thay đổi trong phiên bản 3.7: Các khớp trống cho mẫu được thay thế khi liền kề với trận đấu không trống trước đó.Empty matches for the pattern are replaced when adjacent to a previous non-empty match. Đã không dùng từ phiên bản 3.11: ID nhóm chứa bất cứ 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.Group id containing anything except ASCII digits. Group names containing non-ASCII characters in bytes replacement strings. Re.subn (mẫu, repl, chuỗi, đếm = 0, cờ = 0) ¶subn(pattern, repl, string, count=0, flags=0)¶Thực hiện thao tác tương tự như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91, nhưng trả về một tuple def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)92. Đã thay đổi trong phiên bản 3.1: Đã thêm đối số cờ tùy chọn.Added the optional flags argument. Thay đổi trong phiên bản 3.5: Các nhóm chưa từng có được thay thế bằng một chuỗi trống.Unmatched groups are replaced with an empty string. Đã thay đổi trong phiên bản 3.6: Các ESCAPES chưa biết trong mẫu bao gồma = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 và một chữ cái ASCII hiện là lỗi.escape(pattern)¶ Đã thay đổi trong phiên bản 3.7: Những lối thoát không xác định trong việc thay thế bao gồm a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9 và một lá thư ASCII hiện là lỗi. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'4 Đã thay đổi trong phiên bản 3.7: Các khớp trống cho mẫu được thay thế khi liền kề với trận đấu không trống trước đó. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'5 Đã không dùng từ phiên bản 3.11: ID nhóm chứa bất cứ 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.The def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)95 character is no longer escaped. Re.subn (mẫu, repl, chuỗi, đếm = 0, cờ = 0) ¶Only characters that can have special meaning in a regular expression are escaped. As a result, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)96, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)97, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)98, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)99, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")00, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")01, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")02, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")03, \a \b \f \n \N \r \t \u \U \v \x \\33, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")05, \a \b \f \n \N \r \t \u \U \v \x \\34, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")07, and a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")08 are no longer escaped. Thực hiện thao tác tương tự như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91, nhưng trả về một tuple def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)92.purge()¶ Re.escape (mẫu) Thoát khỏi các ký tự đặc biệt trong mẫu. Điều này rất hữu ích nếu bạn muốn khớp với một chuỗi theo nghĩa đen tùy ý có thể có các metacharacters biểu thức thông thường trong đó. Ví dụ:Chức năng này không được sử dụng cho chuỗi thay thế trongdef myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91 và def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)94, chỉ nên thoát khỏi các dấu gạch chéo ngược. Ví dụ: re.error(msg, pattern=None, pos=None)¶ Đã thay đổi trong phiên bản 3.3: ký tự def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)95 không còn thoát ra được. Thay đổi trong phiên bản 3.7: Chỉ các ký tự có thể có ý nghĩa đặc biệt trong một biểu thức chính quy được thoát ra. Kết quả là, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)96, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)97, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)98, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)99, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")00, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")01, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")02, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")03, \a \b \f \n \N \r \t \u \U \v \x \\33, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")05, \a \b \f \n \N \r \t \u \U \v \x \\34, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")07 và a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")08.¶ Re.purge () Xóa bộ đệm biểu thức thông thường.¶Ngoại lệ ha Exceptionre.error (MSG, MPLENT = none, POS = none) ¶¶Ngoại lệ được nêu ra khi một chuỗi được truyền cho một trong các hàm ở đây không phải là biểu thức chính quy hợp lệ (ví dụ, nó có thể chứa dấu ngoặc đơn chưa từng có) hoặc khi một số lỗi khác xảy ra trong quá trình biên dịch hoặc khớp. Nó không bao giờ là một lỗi nếu một chuỗi không có khớp với một mẫu. Trường hợp lỗi có các thuộc tính bổ sung sau: tin nhắn¶Thông báo lỗi chưa được định dạng. họa tiết¶¶Các mẫu biểu thức chính quy. vị của nước nàyAdded additional attributes. Chỉ số trong mẫu trong đó biên dịch không thành công (có thể là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag) 67).vải mỏng Dòng tương ứng với POS (có thể làdef myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67).search(string[, pos[, endpos]])¶ một thứ lớn tiếngmatch object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string. Cột tương ứng với POS (có thể là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67). Đã thay đổi trong phiên bản 3.5: Đã thêm các thuộc tính bổ sung. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'6 Đối tượng biểu thức chính quymatch(string[, pos[, endpos]])¶ Nếu số 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ả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if the string does not match the pattern; note that this is different from a zero-length match. Các tham số POS và EndPOS tùy chọn có cùng ý nghĩa với phương thức \a \b \f \n \N \r \t \u \U \v \x \\22. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'7 Nếu bạn muốn xác định vị trí đối sánh ở bất cứ đâu trong chuỗi, hãy sử dụng \a \b \f \n \N \r \t \u \U \v \x \\22 thay thế (xem thêm search () so với match ()).search() vs. match()). Mẫu.FullMatch (String [, Pos [, EndPos]])fullmatch(string[, pos[, endpos]])¶ Nếu toàn bộ chuỗi khớp với biểu thức chính quy này, hãy trả về một đối tượng khớp tương ứng. Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không.match object. Return def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 if the string does not match the pattern; note that this is different from a zero-length match. Các tham số POS và EndPOS tùy chọn có cùng ý nghĩa với phương thức \a \b \f \n \N \r \t \u \U \v \x \\22. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'8 Nếu bạn muốn xác định vị trí đối sánh ở bất cứ đâu trong chuỗi, hãy sử dụng Nếu toàn bộ chuỗi khớp với biểu thức chính quy này, hãy trả về một đối tượng khớp tương ứng. Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu chuỗi không khớp với mẫu; Lưu ý rằng điều này khác với một trận đấu có độ dài bằng không. Mới trong phiên bản 3.4.findall(string[, pos[, endpos]])¶ Mẫu.split (chuỗi, maxsplit = 0) ¶ Giống hệt với hàma = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")23, sử dụng mẫu được biên dịch.finditer(string[, pos[, endpos]])¶ Mẫu.findall (chuỗi [, pos [, endpos]]) ¶ Tương tự như hàma = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")24, sử dụng mẫu được biên dịch, nhưng cũng chấp nhận các tham số POS và EndPOS tùy chọn giới hạn vùng tìm kiếm như \a \b \f \n \N \r \t \u \U \v \x \\22.sub(repl, string, count=0)¶ Mẫu.finditer (chuỗi [, pos [, endpos]]) ¶ Tương tự như hàma = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")26, sử dụng mẫu được biên dịch, nhưng cũng chấp nhận các tham số POS và EndPOS tùy chọn giới hạn vùng tìm kiếm như \a \b \f \n \N \r \t \u \U \v \x \\22.subn(repl, string, count=0)¶ Mẫu.sub (repl, chuỗi, đếm = 0) ¶ Giống hệt với hàmdef myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91, sử dụng mẫu được biên dịch.flags¶ Mẫu.subn (repl, chuỗi, đếm = 0) ¶ Giống hệt với hàmdef myfunc(text, flag=re.NOFLAG): return re.match(text, flag)94, sử dụng mẫu được biên dịch.groups¶ Mẫu.flags¶ Các lá cờ phù hợp với regex. Đây là sự kết hợp của các cờ được cung cấp choa = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")30, bất kỳ cờ nội tuyến >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'33 nào trong mẫu và các cờ ẩn như a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")32 nếu mẫu là chuỗi Unicode.groupindex¶ Mẫu.groups¶ Số lượng các nhóm chụp trong mẫu.pattern¶Mẫu.groupindex¶ Một bản đồ từ điển lập bản đồ bất kỳ tên nhóm tượng trưng nào được xác định bởi a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")34 and a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")35. Compiled regular expression objects are considered atomic. Mẫu.Potyern¶Chuỗi mẫu mà từ đó đối tượng mẫu được biên dịch. >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def'9 Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ của a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")34 và a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")35. Biên dịch các đối tượng biểu thức chính quy được xem xét nguyên tử. Khớp đối tượng lorexpand(template)¶ Các đối tượng khớp luôn có giá trị boolean là a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")36. Vì \a \b \f \n \N \r \t \u \U \v \x \\23 và \a \b \f \n \N \r \t \u \U \v \x \\22 Trả về def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 Khi không có khớp, bạn có thể kiểm tra xem có trận đấu với câu lệnh a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")40 đơn giản không: Đối tượng khớp hỗ trợ các phương thức và thuộc tính sau:Unmatched groups are replaced with an empty string. Match.expand (mẫu) ¶group([group1, ...])¶Trả về chuỗi thu được bằng cách thực hiện thay thế Backslash trên mẫu chuỗi mẫu, như được thực hiện bằng phương thức def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91. Các lối thoát như def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)73 được chuyển đổi thành các ký tự thích hợp và các bản sao lưu số ( >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'95, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)84) và được đặt tên là Backreferences ( \a \b \f \n \N \r \t \u \U \v \x \\00, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)79) được thay thế bằng nội dung của nhóm tương ứng. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'0 Nếu biểu thức chính quy sử dụng cú pháp >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'37, các đối số nhóm cũng có thể là các chuỗi xác định các nhóm theo tên nhóm của chúng. Nếu một đối số chuỗi không được sử dụng làm tên nhóm trong mẫu, ngoại lệ a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")47 sẽ được nêu ra. Một ví dụ phức tạp vừa phải: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'1 Các nhóm được đặt tên cũng có thể được đề cập bởi chỉ mục của họ: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'2 Nếu một nhóm khớp với nhiều lần, chỉ có thể truy cập được trận đấu cuối cùng: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'3 Khớp .__ getItem __ (g) ¶__getitem__(g)¶ Điều này giống hệt với a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")51. Điều này cho phép truy cập dễ dàng hơn vào một nhóm cá nhân từ một trận đấu: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'4 Các nhóm được đặt tên cũng được hỗ trợ: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'5 Mới trong phiên bản 3.6. Match.groups (mặc định = none) ¶groups(default=None)¶Trả về một tuple chứa tất cả các nhóm nhỏ của trận đấu, từ 1 trở lên tuy nhiên nhiều nhóm nằm trong mẫu. Đối số mặc định được sử dụng cho các nhóm không tham gia vào trận đấu; Nó mặc định là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67. Ví dụ: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'6 Nếu chúng ta thực hiện vị trí thập phân và mọi thứ sau khi nó tùy chọn, không phải tất cả các nhóm có thể tham gia vào trận đấu. Các nhóm này sẽ mặc định là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 trừ khi đối số mặc định được đưa ra: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'7 Match.groupdict (mặc định = none) ¶groupdict(default=None)¶ Trả về một từ điển chứa tất cả các nhóm nhỏ được đặt tên của trận đấu, được khóa bởi tên phân nhóm. Đối số mặc định được sử dụng cho các nhóm không tham gia vào trận đấu; Nó mặc định là def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67. Ví dụ: >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'8 Match.start ([nhóm]) ¶ match.end ([nhóm]) ¶start([group])¶ Match.end([group])¶ Trả về các chỉ số của phần bắt đầu và kết thúc của chuỗi con phù hợp với nhóm; Nhóm mặc định về 0 (có nghĩa là toàn bộ chuỗi con phù hợp). Trả lại a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")55 nếu nhóm tồn tại nhưng không đóng góp cho trận đấu. Đối với một đối tượng khớp m và nhóm G đã đóng góp cho trận đấu, phần phụ phù hợp với nhóm G (tương đương với a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")51) là >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'9 Lưu ý rằng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")57 sẽ bằng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")58 nếu nhóm khớp với chuỗi null. Ví dụ, sau a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")59, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")60 là 1, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")61 là 2, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")62 và a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")63 đều là 2 và a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64 làm tăng ngoại lệ a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")47. Một ví dụ sẽ loại bỏ Remove_this khỏi địa chỉ email: \a \b \f \n \N \r \t \u \U \v \x \\0 Match.span ([nhóm]) ¶span([group])¶ Đối với một trận đấu M, trả lại 2-Tuple a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")66. Lưu ý rằng nếu nhóm không đóng góp cho trận đấu, đây là a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")67. Nhóm mặc định về 0, toàn bộ trận đấu. Match.Pos¶pos¶ Giá trị của POS được chuyển đến phương pháp \a \b \f \n \N \r \t \u \U \v \x \\22 hoặc \a \b \f \n \N \r \t \u \U \v \x \\23 của một đối tượng regex. Đây là chỉ mục vào chuỗi mà động cơ RE bắt đầu tìm kiếm một trận đấu.regex object. This is the index into the string at which the RE engine started looking for a match. Match.endpos¶endpos¶ Giá trị của các endpos được chuyển đến phương thức \a \b \f \n \N \r \t \u \U \v \x \\22 hoặc \a \b \f \n \N \r \t \u \U \v \x \\23 của một đối tượng regex. Đây là chỉ mục vào chuỗi mà động cơ RE sẽ không đi.regex object. This is the index into the string beyond which the RE engine will not go. Match.lastindex¶lastindex¶ Chỉ số số nguyên của nhóm bắt giữ phù hợp cuối cùng, hoặc def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu không có nhóm nào được khớp. Ví dụ: các biểu thức a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")73, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")74 và a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")75 sẽ có a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")76 nếu được áp dụng cho chuỗi a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")77, trong khi biểu thức a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")78 sẽ có a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")79, nếu được áp dụng cho cùng một chuỗi. Match.lastgroup¶lastgroup¶ Tên của nhóm bắt giữ phù hợp cuối cùng, hoặc def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)67 nếu nhóm không có tên, hoặc nếu không có nhóm nào được khớp. Khớp.re¶re¶ Đối tượng biểu thức chính quy có phương pháp \a \b \f \n \N \r \t \u \U \v \x \\23 hoặc \a \b \f \n \N \r \t \u \U \v \x \\22 đã tạo ra thể hiện đối sánh này.regular expression object whose \a \b \f \n \N \r \t \u \U \v \x \\23 or \a \b \f \n \N \r \t \u \U \v \x \\22 method produced this match instance. Match.String¶string¶ Chuỗi được chuyển đến \a \b \f \n \N \r \t \u \U \v \x \\23 hoặc \a \b \f \n \N \r \t \u \U \v \x \\22. Đã thay đổi trong phiên bản 3.7: Đã thêm hỗ trợ của a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")34 and a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")35. Match objects are considered atomic. Ví dụ biểu hiện chính quyKiểm tra một cặpTrong ví dụ này, chúng tôi sẽ sử dụng chức năng trợ giúp sau để hiển thị các đối tượng phù hợp hơn một chút một cách duyên dáng hơn một chút: \a \b \f \n \N \r \t \u \U \v \x \\1 Giả sử bạn đang viết một chương trình poker trong đó bàn tay của người chơi được thể hiện dưới dạng chuỗi 5 ký tự với mỗi nhân vật đại diện cho một thẻ, một cách Càng Tiên cho 10, và 2 2, thông qua 9 9, đại diện cho thẻ có giá trị đó. Để xem liệu một chuỗi đã cho là một bàn tay hợp lệ, người ta có thể làm như sau: \a \b \f \n \N \r \t \u \U \v \x \\2 Tay cuối cùng đó, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")87, chứa một cặp, hoặc hai trong số cùng một thẻ có giá trị. Để phù hợp với biểu thức thông thường, người ta có thể sử dụng các bản sao lưu như vậy: \a \b \f \n \N \r \t \u \U \v \x \\3 Để tìm hiểu thẻ nào mà cặp bao gồm, người ta có thể sử dụng phương thức a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")88 của đối tượng đối sánh theo cách sau: \a \b \f \n \N \r \t \u \U \v \x \\4 Mô phỏng scanf ()Python hiện không có tương đương với a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")89. Các biểu thức thông thường thường mạnh mẽ hơn, mặc dù cũng nhiều hơn so với các chuỗi định dạng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")89. Bảng dưới đây cung cấp một số ánh xạ tương đương hoặc ít hơn giữa các mã thông báo định dạng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")89 và các biểu thức thông thường.
Để trích xuất tên tệp và số từ một chuỗi như \a \b \f \n \N \r \t \u \U \v \x \\5 bạn sẽ sử dụng định dạng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")89 như \a \b \f \n \N \r \t \u \U \v \x \\6 Biểu thức chính quy tương đương sẽ là \a \b \f \n \N \r \t \u \U \v \x \\7 search () so với match ()Python cung cấp hai hoạt động nguyên thủy khác nhau dựa trên các biểu thức thông thường: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)70 chỉ kiểm tra một trận đấu ở đầu chuỗi, trong khi prog = re.compile(pattern) result = prog.match(string)17 kiểm tra đối sánh ở bất cứ đâu trong chuỗi (đây là những gì Perl làm theo mặc định). Ví dụ: \a \b \f \n \N \r \t \u \U \v \x \\8 Các biểu thức thông thường bắt đầu bằng >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01 có thể được sử dụng với \a \b \f \n \N \r \t \u \U \v \x \\22 để hạn chế trận đấu ở đầu chuỗi: \a \b \f \n \N \r \t \u \U \v \x \\9 Tuy nhiên, lưu ý rằng ở chế độ >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']0 \a \b \f \n \N \r \t \u \U \v \x \\23 chỉ khớp ở đầu chuỗi, trong khi sử dụng \a \b \f \n \N \r \t \u \U \v \x \\22 với biểu thức thông thường bắt đầu với >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01 sẽ khớp ở đầu mỗi dòng. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)0 Làm một danh bạa = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")23 chia một chuỗi thành một danh sách được phân định bởi mẫu được truyền. Phương pháp này là vô giá để chuyển đổi dữ liệu văn bản thành các cấu trúc dữ liệu có thể dễ dàng đọc và sửa đổi bởi Python như được trình bày trong ví dụ sau tạo ra một danh bạ. Đầu tiên, đây là đầu vào. Thông thường nó có thể đến từ một tệp, ở đây chúng tôi đang sử dụng cú pháp chuỗi được trích xuất ba def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)1 Các mục được phân tách bằng một hoặc nhiều dòng mới. Bây giờ chúng tôi chuyển đổi chuỗi thành một danh sách với mỗi dòng không có giá trị có mục nhập riêng: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)2 Cuối cùng, chia mỗi mục vào một danh sách với tên, họ, số điện thoại và địa chỉ. Chúng tôi sử dụng tham số prog = re.compile(pattern) result = prog.match(string)25 của a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")23 vì địa chỉ có khoảng trắng, mẫu phân tách của chúng tôi, trong đó: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)3 Mẫu prog = re.compile(pattern) result = prog.match(string)27 khớp với dấu hai chấm sau tên cuối cùng, do đó nó không xảy ra trong danh sách kết quả. Với prog = re.compile(pattern) result = prog.match(string)25 của prog = re.compile(pattern) result = prog.match(string)29, chúng tôi có thể tách số nhà khỏi tên đường phố: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)4 Nhắn tin MUNGING¶def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91 Thay thế mọi lần xuất hiện của một mẫu bằng một chuỗi hoặc kết quả của một hàm. Ví dụ này thể hiện bằng cách sử dụng def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)91 với chức năng cho văn bản của Mung Munge, hoặc ngẫu nhiên thứ tự của tất cả các ký tự trong mỗi từ của một câu ngoại trừ các ký tự đầu tiên và cuối cùng: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)5 Tìm tất cả các trạng từa = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")24 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ô hình đầu tiên như \a \b \f \n \N \r \t \u \U \v \x \\22. 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 a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")24 theo cách sau: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)6 Tìm tất cả các trạng từ và vị trí của chúngNếu người ta muốn nhiều thông tin hơn về tất cả các trận đấu của một mẫu so với văn bản phù hợp, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")26 rất hữu ích vì nó cung cấp các đối tượng phù hợp thay vì chuỗi. Tiếp tục với ví dụ trước, nếu một nhà văn muốn tìm tất cả các trạng từ và vị trí của chúng trong một số văn bản, họ sẽ sử dụng a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")26 theo cách sau:match objects instead of strings. Continuing with the previous example, if a writer wanted to find all of the adverbs and their positions in some text, they would use a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")26 in the following manner: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)7 Ký hiệu chuỗi thôKý hiệu chuỗi thô ( prog = re.compile(pattern) result = prog.match(string)37) giữ các biểu thức thường xuyên lành mạnh. Không có nó, mọi dấu gạch chéo ngược ( a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")9) trong một biểu thức chính quy sẽ phải được đặt trước với một biểu thức khác để thoát khỏi nó. Ví dụ: hai dòng mã sau đây có chức năng giống hệt nhau: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)8 Khi một người muốn kết hợp một dấu gạch chéo ngược theo nghĩa đen, nó phải được thoát trong biểu thức thông thường. Với ký hiệu chuỗi thô, điều này có nghĩa là prog = re.compile(pattern) result = prog.match(string)39. Không có ký hiệu chuỗi thô, người ta phải sử dụng prog = re.compile(pattern) result = prog.match(string)40, tạo các dòng mã sau giống hệt nhau về mặt chức năng: def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)9 Viết Tokenizer¶Một tokenizer hoặc máy quét phân tích một chuỗi để phân loại các nhóm ký tự. Đây là bước đầu tiên hữu ích khi viết trình biên dịch hoặc trình thông dịch. Các danh mục văn bản được chỉ định với các biểu thức thông thường. Kỹ thuật này là kết hợp những người đó thành một biểu thức thông thường chính và lặp lại các trận đấu liên tiếp: a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")0 Tokenizer tạo ra đầu ra sau: a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")1Frie09 Friedl, Jeffrey. Làm chủ các biểu thức thường xuyên. Tái bản lần thứ 3, O hèReilly Media, 2009. Phiên bản thứ ba của cuốn sách không còn bao gồm Python, nhưng phiên bản đầu tiên bao gồm viết các mẫu biểu thức thông thường tốt rất chi tiết. Làm thế nào để bạn khớp số trong Python?\ d \ d \ d sẽ khớp với các chữ số như 111, 222, 786. will match digits like 111 , 222 , 786 .
Làm thế nào để bạn sử dụng Re phụ?Sử dụng cơ bản trong Re.sub (), chỉ định một mẫu regex trong đối số đầu tiên, một chuỗi mới trong chuỗi thứ hai và một chuỗi được xử lý trong chuỗi thứ ba.Như với thay thế (), bạn có thể chỉ định số lượng thay thế tối đa trong tham số thứ tư, đếm.Bạn cũng có thể tạo một đối tượng mẫu biểu thức thông thường với RE.specify a regex pattern in the first argument, a new string in the second, and a string to be processed in the third. As with replace() , you can specify the maximum count of replacements in the fourth parameter, count . You can also create a regular expression pattern object with re.
Re là gì trong Python?Hàm Sub () thuộc về mô -đun biểu thức chính quy (RE) trong Python.Nó trả về một chuỗi trong đó tất cả các lần xuất hiện của mẫu được chỉ định được thay thế bằng chuỗi thay thế.Để sử dụng chức năng này, chúng ta cần nhập mô -đun RE trước.Nhập RE.returns a string where all matching occurrences of the specified pattern are replaced by the replace string. To use this function, we need to import the re module first. import re.
Làm thế nào để bạn khớp một chuỗi trong Python?Chuỗi bằng kiểm tra trong Python trong lập trình Python, chúng tôi có thể kiểm tra xem các chuỗi có bằng hay không sử dụng hàm === hay bằng cách sử dụng chức năng.Ví dụ: S1 = 'String' S2 = 'String' S3 = 'String' # Case Sensitive bằng kiểm tra nếu S1 == S2: In ('S1 và S2 bằng nhau.using the “==” or by using the “. __eq__” function. Example: s1 = 'String' s2 = 'String' s3 = 'string' # case sensitive equals check if s1 == s2: print('s1 and s2 are equal. |
