Hướng dẫn greedy and non greedy matching in python - kết hợp tham lam và không tham lam trong python

Sẵn sàng để kiếm đai đen của siêu cường Regex của bạn? Hướng dẫn này cho bạn thấy sự khác biệt tinh tế nhưng quan trọng giữa các bộ định lượng regex tham lam và không tham lam.

Bạn cũng có thể xem video giải thích mà tôi đã tạo cho bài viết này:

Python Regex tham lam so với định lượng không tham lam

Nếu bạn là một người bận rộn, thì đây là phiên bản ngắn của hướng dẫn này:

Định nghĩa định lượng lượng tử tham lam:

Một bộ định lượng tham lam như ?,

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Định nghĩa định lượng không màu xanh lá cây:

Một bộ định lượng không màu xanh lá cây như

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Các kỹ sư của Google, Facebook và Amazon là những bậc thầy biểu hiện thường xuyên. Nếu bạn cũng muốn trở thành một, hãy xem cuốn sách mới của chúng tôi: Cách thông minh nhất để học Python Regex (Amazon Kindle/Print, mở trong Tab mới).The Smartest Way to Learn Python Regex (Amazon Kindle/Print, opens in new tab).

Nhưng điều đầu tiên trước tiên: Dù sao thì định lượng của người Viking là gì? Câu hỏi tuyệt vời - Tôi rất vui vì bạn đã hỏi! Vì vậy, hãy để Lặn đi vào Python, ba bộ định lượng chính của Regex.what are “quantifiers” anyway? Great question – I’m glad you asked! So let’s dive into Python’s three main regex quantifiers.

• Định lượng Python Regex
• Trận đấu tham lam Python Regex
• Trận đấu không có màu xanh lá cây Python Regex
• Nhà điều hành đánh dấu câu hỏi không xanh (??)
• Nhà điều hành dấu hoa thị không xanh (*?)
• Nhà điều hành không có Greedy Plus (+?)
• Trận đấu tham lam vs không tham lam-Điều gì khác biệt?
• Ví dụ
• Cái nào nhanh hơn: tham lam vs không tham lam?
• Có nhiều hơn nữa: Trận đấu tham lam, ngoan ngoãn, lười biếng, hữu ích, sở hữu
• Đi đâu từ đây
• Regex hài hước
• Khóa học Python Regex

Từ Quantifier có nguồn gốc từ tiếng Latin: Ý nghĩa của nó là lượng tử = bao nhiêu / tần suất.quantus = how much / how often.

Đây chính xác là một bộ định lượng biểu thức thông thường có nghĩa là: bạn nói với động cơ regex, tần suất bạn muốn khớp với một mẫu nhất định.

Bài viết liên quan: Siêu cường Python Regex - Hướng dẫn cuối cùng Python Regex Superpower – The Ultimate Guide

Nếu bạn nghĩ rằng bạn không định nghĩa bất kỳ bộ định lượng nào, bạn sẽ làm điều đó một cách ngầm: không có định lượng định lượng nào để phù hợp với biểu thức chính xác chính xác một lần.

Vậy các bộ định lượng regex trong Python là gì?

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Lưu ý rằng trong hướng dẫn này, tôi cho rằng bạn có ít nhất một ý tưởng từ xa về những biểu thức thường xuyên thực sự là gì. Nếu bạn thiên đường, không có vấn đề gì, hãy xem hướng dẫn Regex chi tiết của tôi trên blog này.

Bạn có muốn thành thạo siêu cường Regex không? Kiểm tra cuốn sách mới của tôi Cách thông minh nhất để học các biểu thức thường xuyên trong Python với cách tiếp cận 3 bước sáng tạo để học tập tích cực: (1) Nghiên cứu một chương sách, (2) Giải câu đố mã và (3) xem video chương giáo dục . Check out my new book The Smartest Way to Learn Regular Expressions in Python with the innovative 3-step approach for active learning: (1) study a book chapter, (2) solve a code puzzle, and (3) watch an educational chapter video.

Bạn thấy trong bảng rằng các bộ định lượng ?,

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Hãy để một số ví dụ về một số ví dụ cho mỗi bộ định lượng:

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Trong mỗi dòng, bạn thử một bộ định lượng khác nhau trên cùng một văn bản

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

• Regex không hoặc một regex

  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a+?', 'aaaa')
  ['a', 'a', 'a', 'a']

  5 phù hợp bốn lần một

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  4. Lưu ý rằng nó không khớp với các ký tự bằng không nếu nó có thể tránh làm như vậy.
• Regex

  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a+?', 'aaaa')
  ['a', 'a', 'a', 'a']

  7 không hoặc không có kết quả khi bốn

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  4 và tiêu thụ chúng. Ở cuối chuỗi, nó vẫn có thể khớp với chuỗi trống.
• Regex

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  3 một hoặc-more phù hợp khi bốn

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  4s. Trái ngược với bộ định lượng trước đó, nó không thể khớp với một chuỗi trống.
• Regex

  >>> import re
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a+?', 'aaaa')
  ['a', 'a', 'a', 'a']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a*?', 'aaaa')
  ['', 'a', '', 'a', '', 'a', '', 'a', '']
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a??', 'aaaa')
  ['', 'a', '', 'a', '', 'a', '', 'a', '']

  1 lặp lại phù hợp với ba

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  4 trong một lần chạy. Nó có thể làm như vậy chỉ một lần.
• Regex

  >>> import re
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a+?', 'aaaa')
  ['a', 'a', 'a', 'a']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a*?', 'aaaa')
  ['', 'a', '', 'a', '', 'a', '', 'a', '']
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a??', 'aaaa')
  ['', 'a', '', 'a', '', 'a', '', 'a', '']

  3 lặp lại phù hợp với một hoặc hai

  >>> import re
  >>> re.findall('a?', 'aaaa')
  ['a', 'a', 'a', 'a', '']
  >>> re.findall('a*', 'aaaa')
  ['aaaa', '']
  >>> re.findall('a+', 'aaaa')
  ['aaaa']
  >>> re.findall('a{3}', 'aaaa')
  ['aaa']
  >>> re.findall('a{1,2}', 'aaaa')
  ['aa', 'aa']

  4. Nó cố gắng để phù hợp với càng nhiều càng tốt.

Bạn đã học được các định lượng cơ bản của các biểu thức thông thường Python. Bây giờ, nó đã đến lúc khám phá ý nghĩa của thuật ngữ tham lam. Chúng ta sẽ?

Trận đấu tham lam Python Regex

Trận đấu không có màu xanh lá cây Python Regex

Nhà điều hành đánh dấu câu hỏi không xanh (??)

Nói cách khác, các bộ định lượng tham lam cung cấp cho bạn trận đấu dài nhất từ ​​một vị trí nhất định trong chuỗi.longest match from a given position in the string.

Hóa ra, tất cả các bộ định lượng mặc định ?,

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Dưới đây là các ví dụ trên một lần nữa tất cả đều cho thấy động cơ Regex tham lam như thế nào:

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Trong mọi trường hợp, một trận đấu ngắn hơn cũng sẽ hợp lệ. Nhưng vì động cơ Regex là tham lam theo mặc định, chúng không đủ cho động cơ Regex.

Được rồi, vậy làm thế nào chúng ta có thể làm một trận đấu không màu xanh lá cây?

Trận đấu không có màu xanh lá cây Python Regex

Một trận đấu không màu xanh lá cây có nghĩa là động cơ Regex khớp với càng ít ký tự càng tốt để nó vẫn có thể khớp với mẫu trong chuỗi đã cho.

Ví dụ: Regex

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Nói cách khác, các bộ định lượng không màu xanh lá cây cung cấp cho bạn trận đấu ngắn nhất có thể từ một vị trí nhất định trong chuỗi.shortest possible match from a given position in the string.

Bạn có thể thực hiện các định lượng định lượng mặc định ?,

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> re.findall("a*", "aaaaaaaaaaaa")
['aaaaaaaaaaaa', '']
>>> re.findall("a*?", "aaaaaaaaaaaa")
['', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Dưới đây là một số ví dụ cho thấy cách kết hợp không có màu xanh lá cây hoạt động:

Nhà điều hành đánh dấu câu hỏi không xanh (??)

Hãy bắt đầu với dấu hỏi (toán tử không hoặc một):

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Trong trường hợp đầu tiên, bạn sử dụng regex không hoặc một

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Trong trường hợp thứ hai, bạn sử dụng phiên bản Zero-On One không có màu xanh lá cây

>>> timeit.timeit('import re;re.search("a*", "aaaaaaaaaaaa")')
0.8420328999998219
>>> timeit.timeit('import re;re.search("a*?", "aaaaaaaaaaaa")')
0.7955709000000297

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Nhà điều hành dấu hoa thị không xanh (*?)

Hãy bắt đầu với Asterisk (toán tử không hoặc không nhiều):

>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Đầu tiên, bạn sử dụng Asterisk Regex

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Thứ hai, bạn sử dụng phiên bản không hoặc một phiên bản không có màu xanh lá cây

>>> timeit.timeit('import re;re.search("a*", "aaaaaaaaaaaa")')
0.8420328999998219
>>> timeit.timeit('import re;re.search("a*?", "aaaaaaaaaaaa")')
0.7955709000000297

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Nhà điều hành không có Greedy Plus (+?)

Hãy để bắt đầu với Plus (toán tử một hoặc nhiều hơn):

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

Đầu tiên, bạn sử dụng REGEX

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Thứ hai, bạn sử dụng phiên bản một hoặc không tốt hơn

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Hãy để tóm tắt những gì bạn đã học được cho đến nay:

Trận đấu tham lam vs không tham lam-Điều gì khác biệt?

Đưa ra một mẫu có bộ định lượng (ví dụ: toán tử dấu hoa thị) cho phép động cơ Regex khớp với mẫu nhiều lần.

Một chuỗi đã cho có thể khớp với regex theo nhiều cách. Ví dụ: cả hai chuỗi con

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Vì vậy, sự khác biệt giữa sự tham lam và trận đấu không tham lam là như sau: Trận đấu tham lam sẽ cố gắng phù hợp với càng nhiều lần lặp lại của mẫu định lượng càng tốt. Trận đấu không màu xanh lá cây sẽ cố gắng khớp với ít sự lặp lại của mẫu được định lượng nhất có thể.

Ví dụ

Hãy cùng xem xét một loạt các ví dụ giúp bạn hiểu được sự khác biệt giữa các trận đấu tham lam và không tham gia trong Python:

>>> import re
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a+?', 'aaaa')
['a', 'a', 'a', 'a']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a*?', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Hãy chắc chắn rằng bạn hoàn toàn hiểu những ví dụ đó trước khi bạn tiếp tục. Nếu bạn không có, xin vui lòng đọc lại các đoạn trước.

Cái nào nhanh hơn: tham lam vs không tham lam?

Xem xét rằng các bộ định lượng tham lam phù hợp với một số lượng tối thiểu và không tham lam một số lượng tối thiểu, có bất kỳ sự khác biệt hiệu suất nào không?

Câu hỏi tuyệt vời!

Thật vậy, một số điểm chuẩn cho thấy rằng có một sự khác biệt hiệu suất đáng kể: bộ định lượng tham lam chậm hơn 100% trong các thí nghiệm thực tế trên dữ liệu điểm chuẩn.

Vì vậy, nếu bạn tối ưu hóa tốc độ và bạn không quan tâm đến các trận đấu tham lam hoặc không tham lam, và bạn không biết bất cứ điều gì khác.

Tuy nhiên, sự thật không đơn giản. Ví dụ, hãy xem xét các thử nghiệm cơ bản sau đây làm sai lệch giả thuyết trước đây rằng phiên bản không màu xanh lá cây nhanh hơn:

>>> import timeit
>>> timeit.timeit('import re;re.findall("a*", "aaaaaaaaaaaa")')
1.0579840000000331
>>> timeit.timeit('import re;re.findall("a*?", "aaaaaaaaaaaa")')
3.7830938000000742

Tôi đã sử dụng thời gian kiểm tra tốc độ cho phép ném vào một số câu lệnh Python đơn giản và kiểm tra thời gian chúng chạy. Mỗi mặc định, câu lệnh được thông qua được thực thi 1.000.000 lần.

Bạn có thể thấy sự khác biệt về hiệu suất đáng chú ý hơn 300%! Phiên bản không Greedy chậm hơn ba lần so với phiên bản tham lam.

Tại sao vậy?

Lý do là phương thức re.findall () trả về một danh sách các chuỗi con phù hợp. Ở đây, đầu ra, cả hai câu lệnh sẽ tạo ra:

>>> re.findall("a*", "aaaaaaaaaaaa")
['aaaaaaaaaaaa', '']
>>> re.findall("a*?", "aaaaaaaaaaaa")
['', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '']

Bạn có thể thấy rằng phiên bản tham lam tìm thấy một trận đấu và được thực hiện với nó. Phiên bản không màu xanh lá cây tìm thấy 25 trận đấu dẫn đến việc xử lý và chi phí bộ nhớ nhiều hơn nhiều.

Vậy điều gì xảy ra nếu bạn sử dụng phương thức RE.Search () chỉ trả về trận đấu đầu tiên thay vì phương thức re.findall () trả về tất cả các trận đấu?

>>> timeit.timeit('import re;re.search("a*", "aaaaaaaaaaaa")')
0.8420328999998219
>>> timeit.timeit('import re;re.search("a*?", "aaaaaaaaaaaa")')
0.7955709000000297

Như mong đợi, điều này thay đổi mọi thứ một lần nữa. Cả hai tìm kiếm Regex đều mang lại một kết quả duy nhất, nhưng trận đấu không màu xanh lá cây ngắn hơn nhiều: nó phù hợp với chuỗi trống ?9 thay vì toàn bộ chuỗi

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

Tuy nhiên, sự khác biệt là không đáng kể trong ví dụ tối thiểu này.

Có nhiều hơn nữa: Trận đấu tham lam, ngoan ngoãn, lười biếng, hữu ích, sở hữu

Trong bài viết này, tôi đã phân loại thế giới Regex thành các định lượng tham lam và không tham lam. Nhưng bạn có thể phân biệt các lớp học không có màu xanh lá cây của người Viking hơn nữa!

Tiếp theo, tôi sẽ cung cấp cho bạn một cái nhìn tổng quan ngắn dựa trên bài viết tuyệt vời này về các điều khoản quan trọng nhất về vấn đề này:

• Tham lam: Kết hợp càng nhiều trường hợp của mẫu định lượng càng tốt.: match as many instances of the quantified pattern as you can.
• Discile: khớp với nhiều trường hợp của mẫu được định lượng miễn là nó vẫn phù hợp với mẫu tổng thể nếu điều này là có thể. Lưu ý rằng những gì tôi gọi là người tham lam, trong bài viết này thực sự là một người ngoan ngoãn.: match as many instances of the quantified pattern as long as it still matches the overall pattern—if this is possible. Note that what I called “greedy” in this article is really “docile”.
• Lazy: khớp với một số trường hợp của mẫu được định lượng khi cần thiết. Đây là những gì tôi gọi là không có màu xanh lá cây trong bài viết này.: match as few instances of the quantified pattern as needed. This is what I called “non-greedy” in this article.
• Sở hữu: Không bao giờ từ bỏ một trận đấu một phần. Vì vậy, động cơ Regex thậm chí có thể không tìm thấy một trận đấu thực sự tồn tại, chỉ vì nó rất tham lam. Điều này là rất bất thường và bạn đã thắng được thấy nó rất nhiều trong thực tế.: never gives up a partial match. So the regex engine may not even find a match that actually exist—just because it’s so greedy. This is very unusual and you won’t see it a lot in practice.

Nếu bạn muốn tìm hiểu thêm về những điều đó, tôi sẽ khuyên bạn nên đọc hướng dẫn trực tuyến tuyệt vời này.

Đi đâu từ đây

Tóm tắt: Bạn đã học được rằng các bộ định lượng tham lam ?,

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a*', 'aaaa')
['aaaa', '']
>>> re.findall('a+', 'aaaa')
['aaaa']
>>> re.findall('a{3}', 'aaaa')
['aaa']
>>> re.findall('a{1,2}', 'aaaa')
['aa', 'aa']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

>>> import re
>>> re.findall('a?', 'aaaa')
['a', 'a', 'a', 'a', '']
>>> re.findall('a??', 'aaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '']

Nếu bạn muốn làm chủ Python và các cách diễn đạt thông thường, hãy tham gia Học viện Email miễn phí của tôi, đó là niềm vui!

Regex hài hước

Khóa học Python Regex

Các kỹ sư của Google là những bậc thầy biểu hiện thường xuyên. Công cụ tìm kiếm của Google là một công cụ xử lý văn bản khổng lồ, trích xuất giá trị từ hàng nghìn tỷ trang web. & NBSP; & NBSP;The Google search engine is a massive text-processing engine that extracts value from trillions of webpages.  

Các kỹ sư Facebook là những bậc thầy biểu hiện thường xuyên. Các mạng xã hội như Facebook, WhatsApp và Instagram kết nối con người qua tin nhắn văn bản. & NBSP; Social networks like Facebook, WhatsApp, and Instagram connect humans via text messages. 

Các kỹ sư Amazon là những bậc thầy biểu hiện thường xuyên. Gã khổng lồ thương mại sản phẩm tàu ​​điện tử dựa trên mô tả sản phẩm văn bản.Ecommerce giants ship products based on textual product descriptions.  Regular expressions ​rule the game ​when text processing ​meets computer science. 

Nếu bạn cũng muốn trở thành một bậc thầy biểu hiện thông thường, hãy xem khóa học Python Regex toàn diện nhất trên hành tinh:

Trong khi làm việc như một nhà nghiên cứu trong các hệ thống phân tán, Tiến sĩ Christian Mayer đã tìm thấy tình yêu của mình đối với việc dạy các sinh viên khoa học máy tính.

Để giúp học sinh đạt được thành công cao hơn của Python, ông đã thành lập trang web giáo dục chương trình Finxter.com. Ông là tác giả của cuốn sách lập trình phổ biến Python Oneer (Nostarch 2020), đồng tác giả của loạt sách Break Break Python, những cuốn sách tự xuất bản, người đam mê khoa học máy tính, freelancer và chủ sở hữu của một trong 10 blog Python lớn nhất trên toàn thế giới.

Niềm đam mê của ông là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ tăng cường các kỹ năng của họ. Bạn có thể tham gia học viện email miễn phí của anh ấy ở đây.

Tham lam là gì vs non

Trận đấu tham lam là gì?

Mẫu phù hợp trong Python là gì?

Làm thế nào để bạn phù hợp trong Python?