Master Python’s parse Library: Simplify String Extraction Without Regex

If you often reach for regular expressions to extract data from strings, the Python parse library offers a more readable and maintainable alternative.

1. Real‑world example

Consider an OVS flow entry where we need to extract the number of bytes and packets for each in_port:

cookie=0x9816da8e872d717d, duration=298506.364s, table=0, n_packets=480, n_bytes=20160, priority=10,ip,in_port="tapbbdf080b-c2" actions=NORMAL

Using parse, we can define a pattern and directly obtain the desired fields.

2. parse results

The library returns two possible outcomes:

No match – the result is None.

Match – the result is a Result instance.

Examples:

>> parse("halo", "hello") is None
True
>>> parse("hello", "hello world")
<Result () {}

When field names are provided, the result behaves like a dictionary:

>> profile = parse("I am {name}, {age:d} years old, {gender}", "I am Jack, 27 years old, male")
<Result () {'gender': 'male', 'age': 27, 'name': 'Jack'}>
>>> profile['name']
'Jack'
>>> profile['age']
27

3. Reusing patterns

Just like the re module, parse supports compiled patterns for reuse:

from parse import compile
pattern = compile("I am {}, {} years old, {}")
pattern.parse("I am Jack, 27 years old, male")
<Result ('Jack', '27', 'male') {}>
pattern.parse("I am Tom, 26 years old, male")
<Result ('Tom', '26', 'male') {}>

4. Type conversion

By adding a type specifier, parse can convert extracted strings automatically:

profile = parse("I am {name}, {age:d} years old, {gender}", "I am Jack, 27 years old, male")
# profile['age'] is an int, not a string

Various built‑in specifiers exist (e.g., d for integers, f for floats, tg for ISO dates). See the official documentation for the full list.

5. Whitespace handling

Parse can trim spaces using format modifiers:

parse('hello {:^} , hello python', 'hello     world    , hello python')
<Result ('world') {}>
parse('hello {:>}', 'hello     world    , hello python')
<Result ('world   ') {}>
parse('hello {:<}', 'hello     world    , hello python')
<Result ('   world') {}>

6. Case‑sensitivity toggle

By default matching is case‑insensitive; set case_sensitive=True to enforce case matching.

parse('SPAM', 'spam') is None
parse('SPAM', 'spam', case_sensitive=True) is None  # returns False

7. Character count constraints

Exact or minimum length can be enforced with {:.N} or {:N} modifiers.

parse('{:.2}{:.2}', 'hell')
<Result ('he', 'll') {}>
parse('{:.2}{:2}', 'hello')
<Result ('h', 'ello') {}>

8. Three important attributes

fixed : tuple of values from anonymous fields.

named : dictionary of named fields.

spans : mapping of field names to their positions in the original string.

profile = parse("I am {name}, {age:d} years old, {}", "I am Jack, 27 years old, male")
profile.fixed  # ('male',)
profile.named  # {'age': 27, 'name': 'Jack'}
profile.spans  # {0: (25, 29), 'age': (11, 13), 'name': (5, 9)}

9. Custom type conversion

Provide a conversion function via the dict argument:

def myint(string):
    return int(string)
parse('I am {:myint}', 'I am 27', dict(myint=myint))
# Result (27) {}

Or transform the matched string, e.g., to uppercase:

def shouty(string):
    return string.upper()
parse('{:shouty} world', 'hello world', dict(shouty=shouty))
# Result ('HELLO') {}

10. Summary

The parse library makes string extraction straightforward, more readable than regular expressions, and supports powerful features such as pattern reuse, automatic type conversion, whitespace control, case sensitivity, and custom converters, making it a valuable tool for everyday Python development.