description: "Doing is often better than thinking of doing"

url: "https://learnbyexample.github.io"

date_format: "%B %-d, %Y"

read_time: true

words_per_minute: 100

| Anchors | Description |

| ------------- | ----------- |

| `\n` | newline character is used as line separator |

| | word characters: alphabets, digits, underscore |

| `\B` | matches wherever `\b` doesn't match |

| `pat1.*pat2` | any number of characters between `pat1` and `pat2` |

| `pat1.*pat2|pat2.*pat1` | match both `pat1` and `pat2` in any order |

| Character class | Description |

| ------------- | ----------- |

| `(?-flags:pat)` | negate flags only for this `pat` |

| `(?flags-flags:pat)` | apply and negate particular flags only for this `pat` |

| `(?flags)` | apply flags for whole RE, can be used only at start of RE |

| Matched portion | Description |

| ------------- | ----------- |

| `m.groups()` | tuple of all the capture groups' matched portions |

| `m.span()` | start and end+1 index of entire matched portion |

| | pass a number to get span of that particular capture group |

| `\N` | backreference, gives matched portion of *N*th capture group |

| | applies to both search and replacement sections |

| | possible values: `\1`, `\2` up to `\99` provided no more digits |

| | refer as `'name'` in `re.Match` object |

| | refer as `(?P=name)` in search section |

| | refer as `\g<name>` in replacement section |

`\0` and `\100` onwards are considered as octal values, hence cannot be used as backreferences.

| | r-strings preferred to define RE |

| | Use byte pattern for byte input |

| | Python also maintains a small cache of recent RE |

| `re.compile` | Compile a pattern for reuse, outputs `re.Pattern` object |

| `re.sub` | search and replace |

| `re.sub(r'pat', f, s)` | function `f` with `re.Match` object as argument |

| `re.escape` | automatically escape all metacharacters |

| `re.split` | split a string based on RE |

| `re.findall` | returns all the matches as a list |

| | if 1 capture group is used, only its matches are returned |

| | 1+, each element will be tuple of capture groups |

| `re.finditer` | iterator with `re.Match` object for each match |

| `re.subn` | gives tuple of modified string and number of substitutions |

The function definitions are given below:

re.search(pattern, string, flags=0)

re.compile(pattern, flags=0)

re.sub(pattern, repl, string, count=0, flags=0)

re.escape(pattern)

re.subn(pattern, repl, string, count=0, flags=0)

As a good practice, always use **raw strings** to construct RE, unless other formats are required. This will avoid clash of special meaning of backslash character between RE and normal quoted strings.

>>> bool(re.search(r'\Ahi', 'hi hello\ntop spot'))

>>> [w for w in words if re.search(r'er\Z', w)]

['surrender', 'newer']

* examples for `re.findall`

>>> re.findall(r'\bs?pare?\b', 'par spar apparent spare part pare')

['par', 'spar', 'spare', 'pare']

>>> re.findall(r't.*?a', 'that is quite a fabricated tale')

['tha', 't is quite a', 'ted ta']

* backreferencing in replacement section

>>> re.sub(r'\b(\w+)( \1)+\b', r'\1', 'aa a a a 42 f_1 f_1 f_13.14')

>>> re.sub(r'foo(?!\d)', r'baz', 'hey food! foo42 foot5 foofoo')

>>> re.sub(r'(?<![:-])\b\w+\b', r'X', ':cart <apple -rest ;tea')

['20']

>>> bool(re.search(r'at((?!do).)*par', 'fox,cat,dog,parrot'))

>>> bool(pet.search('A cat crossed their path'))

Visit my repo [Python re(gex)?](https://github.com/learnbyexample/py_regular_expressions) for details about the book I wrote on Python regular expressions. The ebook uses plenty of examples to explain the concepts from the very beginning and step by step introduces more advanced concepts. The book also covers the [third party module regex](https://pypi.org/project/regex/). The cheatsheet and examples presented in this post are based on contents of this book.