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à:
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áp
Một biểu thức chính quy [hoặc re] chỉ định một tập hợp các chuỗi phù hợp với nó; Các hàm trong mô -đun này cho phép bạn kiểm tra xem một chuỗi cụ thể có khớp với biểu thức chính quy nhất định không [hoặc nếu một biểu thức chính quy nhất định khớp với một chuỗi cụ thể, đi xuống cùng một điều].
Biểu thức thông thường có thể được nối để tạo thành các biểu thức thường xuyên mới; Nếu A và B đều là biểu thức chính quy, thì AB cũng là một biểu thức chính quy. Nói chung, nếu chuỗi P khớp với A và một chuỗi Q khác khớp với B, chuỗi PQ sẽ khớp với AB. Điều này giữ trừ khi A hoặc B chứa các hoạt động ưu tiên thấp; điều kiện biên giữa a và b; hoặc đã đánh số tài liệu tham khảo nhóm. Do đó, các biểu thức phức tạp có thể dễ dàng được xây dựng từ các biểu thức nguyên thủy đơn giản hơn như các biểu thức được mô tả ở đây. Để biết chi tiết về lý thuyết và thực hiện các biểu thức thường xuyên, hãy tham khảo cuốn sách Friedl [FRIE09] hoặc gần như bất kỳ cuốn sách giáo khoa nào về xây dựng trình biên dịch.[Frie09], or almost any textbook about compiler construction.
Một lời giải thích ngắn gọn về định dạng của các biểu thức thường xuyên sau. Để biết thêm thông tin và một bài thuyết trình nhẹ nhàng hơn, hãy tham khảo ý kiến biểu thức thường xuyên.Regular Expression HOWTO.
Biểu thức chính quy có thể chứa cả các ký tự đặc biệt và thông thường. Hầu hết các ký tự thông thường, như
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['[?>> import re >>> m = re.search['[?