How to extract required data from structured strings in Python?

When working with structured strings like log files or reports, you often need to extract specific data fields. Python provides several approaches to parse these strings efficiently when the format is known and consistent.

Understanding Structured String Format

Let's work with a structured report format:

Report: <> - Time: <> - Player: <> - Titles: <> - Country: <>

Here's our sample data:

report = 'Report: Daily_Report - Time: 2020-10-10T12:30:59.000000 - Player: Federer - Titles: 20 - Country: Switzerland'
print(report)

Report: Daily_Report - Time: 2020-10-10T12:30:59.000000 - Player: Federer - Titles: 20 - Country: Switzerland

Method 1: Using String Splitting

The basic approach uses the separator "-" to split fields:

report = 'Report: Daily_Report - Time: 2020-10-10T12:30:59.000000 - Player: Federer - Titles: 20 - Country: Switzerland'

# Split by separator
fields = report.split(' - ')
name, time, player, titles, country = fields

print("Raw fields:")
for field in fields:
    print(f"  {field}")

Raw fields:
  Report: Daily_Report
  Time: 2020-10-10T12:30:59.000000
  Player: Federer
  Titles: 20
  Country: Switzerland

Extracting Clean Values

Remove the labels by splitting on colon:

# Extract only the values after colons
formatted_name = name.split(':')[1].strip()
formatted_time = time.split(': ')[1]
formatted_player = player.split(':')[1].strip()
formatted_titles = int(titles.split(':')[1].strip())
formatted_country = country.split(':')[1].strip()

print(f"Extracted data: {formatted_name}, {formatted_time}, {formatted_player}, {formatted_titles}, {formatted_country}")

Extracted data: Daily_Report, 2020-10-10T12:30:59.000000, Federer, 20, Switzerland

Complete Parsing Function

def parse_report(log_string):
    """
    Parse structured log in format:
    Report: <> - Time: <> - Player: <> - Titles: <> - Country: <>
    """
    fields = log_string.split(' - ')
    name, time, player, titles, country = fields
    
    # Extract clean values
    clean_name = name.split(':')[1].strip()
    clean_time = time.split(': ')[1]
    clean_player = player.split(':')[1].strip()
    clean_titles = int(titles.split(':')[1].strip())
    clean_country = country.split(':')[1].strip()
    
    return {
        'name': clean_name,
        'time': clean_time,
        'player': clean_player,
        'titles': clean_titles,
        'country': clean_country
    }

# Test the function
report = 'Report: Daily_Report - Time: 2020-10-10T12:30:59.000000 - Player: Federer - Titles: 20 - Country: Switzerland'
data = parse_report(report)
print(data)

{'name': 'Daily_Report', 'time': '2020-10-10T12:30:59.000000', 'player': 'Federer', 'titles': 20, 'country': 'Switzerland'}

Method 2: Using the Parse Module

The parse module provides a simpler template-based approach. Install it first with pip install parse:

from parse import parse

report = 'Report: Daily_Report - Time: 2020-10-10T12:30:59.000000 - Player: Federer - Titles: 20 - Country: Switzerland'

# Define template matching the structure
template = 'Report: {name} - Time: {time} - Player: {player} - Titles: {titles} - Country: {country}'

# Parse the data
data = parse(template, report)
print(f"Parsed result: {data}")
print(f"Name: {data['name']}")
print(f"Player: {data['player']}")
print(f"Titles: {data['titles']}")

Parsed result: <Result () {'name': 'Daily_Report', 'time': '2020-10-10T12:30:59.000000', 'player': 'Federer', 'titles': '20', 'country': 'Switzerland'}>
Name: Daily_Report
Player: Federer
Titles: 20

Working with Timestamps

Convert ISO format timestamps to readable dates:

from datetime import datetime

time_str = '2020-10-10T12:30:59.000000'
formatted_date = datetime.fromisoformat(time_str)
print(f"Readable date: {formatted_date}")
print(f"Date only: {formatted_date.date()}")
print(f"Time only: {formatted_date.time()}")

Readable date: 2020-10-10 12:30:59
Date only: 2020-10-10
Time only: 12:30:59

Comparison

Conclusion

Use string splitting for simple structured data with consistent separators. For complex formats or multiple templates, the parse module provides cleaner, more maintainable code with template-based extraction.