Regex: Greedy vs Lazy Operators

Regular expressions (regex) are a powerful tool used to search, extract, and manipulate strings of text. One of the most interesting and sometimes confusing features of regex is the distinction between greedy and lazy operators. Understanding the difference between these two types of operators is essential for effectively using regex.

Introduction to Regular Expressions

Before delving into the difference between greedy and lazy operators, it’s helpful to have a basic understanding of regular expressions. Regex are sequences of characters that define a search pattern. This pattern can be used to find, replace, or extract portions of text within larger strings. For example, the regex \d+ finds one or more consecutive digits within a string.

Greedy Operators

Greedy operators, as the name suggests, try to match as many characters as possible. Consider the operator .*, which matches any character (except newlines) repeated zero or more times. This operator, being greedy, will try to match the longest possible portion of the string that fits the pattern.


import re

text = 'hi <my> name <is> <tom jerry>'
result = re.findall(r'<.*>', text)
print(result) # Output: ['<my> name <is> <tom jerry>']

In this example, the pattern <.*> tries to match anything between the characters < and >. Since .* is greedy, it matches everything from <my> to the last > available, resulting in '<my> name <is> <tom jerry>'.

Lazy Operators

Conversely, lazy operators try to match as few characters as possible. This can be achieved by adding a question mark ? after the operator. For instance, .*? matches any character repeated zero or more times, but in a lazy manner.


import re

text = 'hi <my> name <is> <tom jerry>'
result = re.findall(r'<.*?>', text)
print(result) # Output: ['<my>', '<is>', '<tom jerry>']

Here, the pattern <.*?> matches the smallest possible portion between < and >, stopping as soon as it finds the first >, and then repeating the process. This results in three distinct matches: '<my>', '<is>', and '<tom jerry>'.

Practical Comparison

To better understand how and when to use greedy and lazy operators, consider a practical example. Suppose we have HTML text from which we want to extract all content between <div> tags.

Example text:

<div>Content 1</div>
<div>Content 2</div>
<div>Content 3</div>

Using a greedy operator:

import re

html = '<div>Content 1</div><div>Content 2</div><div>Content 3</div>'
result = re.findall(r'<div>.*</div>', html)
print(result) # Output: ['<div>Content 1</div><div>Content 2</div><div>Content 3</div>']

Here, the greedy .* operator matches everything from the first <div> to the last </div>, including all the intermediate text.

Using a lazy operator:

import re

html = '<div>Content 1</div><div>Content 2</div><div>Content 3</div>'
result = re.findall(r'<div>.*?</div>', html)
print(result) # Output: ['<div>Content 1</div>', '<div>Content 2</div>', '<div>Content 3</div>']

In this case, the lazy .*? operator stops at the first </div> it encounters after each <div>, thus matching each individual div element separately.

When to Use Greedy and Lazy

The choice between greedy and lazy operators depends on the context and the specific goal of the search:

  1. Greedy: Use greedy operators when you want to capture the largest possible portion of text that fits your pattern. This is useful when the entire block of text between two delimiters is relevant.
  2. Lazy: Lazy operators are preferable when you want to capture smaller, specific portions, especially when there are multiple delimited elements that need to be matched individually.


Understanding the difference between greedy and lazy operators is essential for effectively using regular expressions. While the former tries to match as much text as possible, the latter aims to minimize the match, stopping at the first occurrence that fits the pattern. Knowing how to choose the right approach based on context can significantly improve the effectiveness of your regex and reduce unwanted results.

The example of the pattern <.*> and <.*?> clearly demonstrates how a slight modification can drastically change the output. Practicing with different scenarios and testing your patterns on various texts will help you become more proficient and confident in using regular expressions.

Ultimately, both greedy and lazy operators have their place in regular expressions. The key is knowing when and how to use them to achieve the desired results.

This article provides a comprehensive overview of the differences between greedy and lazy operators in regular expressions, with clear examples and detailed explanations to help clarify their use in various contexts.

Leave a Comment