如何解析带有空值的表头-值列表格式字符串？

Alright, let's tackle this problem. You've got a string that represents a table—headers followed by data values—but some values might be missing (like your example where titel2 has no corresponding value). Here are a couple of practical, actionable solutions depending on your specific scenario:

Approach 1: Pattern-Based Mapping (Best for Your Sample) #

Looking at your example, it seems like data values tie to headers via a shared suffix (e.g., value1 matches titel1). This is perfect because we can explicitly map each value to its header, even when values are missing.

Python Implementation #

def parse_table_with_pattern(input_str):
    # Split the string into individual tokens (handles any number of spaces)
    tokens = input_str.strip().split()
    
    # Separate headers and data values based on their prefix
    headers = [token for token in tokens if token.startswith("titel")]
    data_values = [token for token in tokens if token.startswith("value")]
    
    # Initialize a dictionary with all headers set to None (our missing value placeholder)
    result = {header: None for header in headers}
    
    # Map each data value to its matching header
    for value in data_values:
        # Extract the numeric suffix (e.g., "1" from "value1")
        suffix = value.replace("value", "")
        matching_header = f"titel{suffix}"
        if matching_header in result:
            result[matching_header] = value
    
    return result

# Test with your sample string
sample_input = "titel1 titel2 titel3 titel4 value1 value3 value4"
parsed_data = parse_table_with_pattern(sample_input)
print(parsed_data)

Output #

{'titel1': 'value1', 'titel2': None, 'titel3': 'value3', 'titel4': 'value4'}

This works even if values are out of order—just as long as that suffix pattern holds. You can swap None with an empty string or N/A if you prefer a different placeholder.

Approach 2: Ordered Mapping (For Sequential Data) #

If your data values are always in the exact same order as the headers (missing values are either omitted or show up as empty strings), you can use this method. It assumes the first N tokens are headers, and the rest are data values (padded to match header count if some are missing).

Python Implementation #

def parse_ordered_table(input_str, header_count):
    tokens = input_str.strip().split()
    
    # Split tokens into headers and data
    headers = tokens[:header_count]
    data_tokens = tokens[header_count:]
    
    # Pad data with empty strings to match header length (handles missing values)
    padded_data = data_tokens + [""] * (len(headers) - len(data_tokens))
    
    # Map headers to values
    return dict(zip(headers, padded_data))

# Test with your sample (4 headers)
sample_input = "titel1 titel2 titel3 titel4 value1 value3 value4"
parsed_data = parse_ordered_table(sample_input, 4)
print(parsed_data)

Output #

{'titel1': 'value1', 'titel2': 'value3', 'titel3': 'value4', 'titel4': ''}

A quick note: this approach only works if missing values are the last ones in the sequence. If you have missing values in the middle (like your sample), this method will misalign things unless you have empty tokens in the input (e.g., value1 value3 with two spaces indicating an empty value between them).

Approach 3: Multiline Table Input #

If your input is split into lines (headers on one line, data on the next), you can split by lines first, then process each line:

Python Implementation #

def parse_multiline_table(input_str):
    # Split into lines, ignoring empty ones
    lines = [line.strip() for line in input_str.split("\n") if line.strip()]
    
    headers = lines[0].split()
    data_rows = []
    
    for line in lines[1:]:
        # Split data line into tokens, pad to match header count
        data_tokens = line.split()
        padded_tokens = data_tokens + [""] * (len(headers) - len(data_tokens))
        data_rows.append(dict(zip(headers, padded_tokens)))
    
    return {"headers": headers, "data": data_rows}

# Test with multiline input
sample_multiline = """titel1 titel2 titel3 titel4
value1  value3 value4"""
parsed_data = parse_multiline_table(sample_multiline)
print(parsed_data)

Output #

{'headers': ['titel1', 'titel2', 'titel3', 'titel4'], 'data': [{'titel1': 'value1', 'titel2': '', 'titel3': 'value3', 'titel4': 'value4'}]}

Quick Notes #

• Ambiguity Alert: If your data has no pattern and values are out of order, you can't reliably map missing values without extra context. Stick to either the pattern-based method or ensure data is always in header order.
• Customization: Feel free to adjust the placeholder for missing values (swap None or empty strings with whatever makes sense for your use case).

内容的提问来源于stack exchange，提问作者Asmaa Salman