如何使用 Python 正则表达式精准提取文本文件中的多组参数与对应数据

本文介绍一种健壮、可扩展的方法，利用正则表达式从结构化文本日志中批量提取几何参数（如 g1–g5、l1）及关联的频率–rcs 数值对，并组织为规整的二维表格，彻底规避字符串切分导致的索引越界与格式解析错误。

本文介绍一种健壮、可扩展的方法，利用正则表达式从结构化文本日志中批量提取几何参数（如 g1–g5、l1）及关联的频率–rcs 数值对，并组织为规整的二维表格，彻底规避字符串切分导致的索引越界与格式解析错误。

在处理由电磁仿真软件（如 CST、HFSS）导出的多组参数扫描结果时，常见一种“块状嵌套”文本格式：每个数据块以 #Parameters = {...} 开头，紧随其后是带标题行的数值表格（频率 + RCS）。原始代码尝试用 str.split(';') 粗粒度解析参数行，但因未剥离 { 和空格，导致 params[0] 实际为 '#Parameters = {g5'，从而引发 ValueError: could not convert string to float: '{g5' 错误——这正是硬编码索引+简单分割在面对格式噪声时的典型缺陷。

更可靠的方式是采用正则表达式（regex）进行语义化匹配：先定位参数块主体，再从中精确抽取键值对，最后将参数与后续数值行动态绑定。以下是完整、生产就绪的实现方案：

Favird No-Code Tools

无代码工具的聚合器

下载

✅ 推荐实现：基于 regex 的稳健解析器

import re
import pandas as pd
from typing import List, Dict, Tuple, Optional

def extract_parameters_and_data(file_path: str) -> pd.DataFrame:
    """
    从多块参数-数据混合文本中提取 g1/g2/g3/g4/g5/l1 及对应 Frequency/RCS 序列。

    返回 DataFrame，每行代表一个参数组合下的全部频点数据（宽表格式）。
    """
    # 1. 预编译正则：匹配 #Parameters 行内的完整参数字典内容（不含花括号）
    param_block_pattern = re.compile(r"#Parameters\s*=\s*\{([^}]*)\}")
    # 2. 匹配单个参数键值对：支持 g1–g5、l1 等目标字段，值为浮点数（含小数点）
    kv_pattern = re.compile(r"(g[1-5]|l1)\s*=\s*([\d.]+)")
    # 3. 匹配数值行：以数字开头、含两个浮点数（频率 + RCS），忽略注释和空行
    data_line_pattern = re.compile(r"^\s*([\d.]+)\s+([\d.-]+)\s*$")

    blocks: List[Dict[str, float]] = []   # 存储每个参数块的 {key: value}
    all_frequencies: List[List[float]] = []
    all_rcs: List[List[float]] = []

    current_params: Optional[Dict[str, float]] = None
    current_freqs: List[float] = []
    current_rcs: List[float] = []

    with open(file_path, 'r', encoding='utf-8') as f:
        for line_num, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue

            # 情况1：遇到新参数块 → 保存上一块数据（如有），并解析当前参数
            if param_block_pattern.match(line):
                if current_params is not None and current_freqs:
                    # 保存上一完整块的数据
                    blocks.append(current_params)
                    all_frequencies.append(current_freqs)
                    all_rcs.append(current_rcs)

                # 解析当前参数块
                match = param_block_pattern.search(line)
                if match:
                    content = match.group(1)
                    # 提取所有 g1–g5 和 l1（忽略其他参数）
                    kv_matches = kv_pattern.findall(content)
                    current_params = {k: float(v) for k, v in kv_matches 
                                    if k in ('g1','g2','g3','g4','g5','l1')}
                    # 重置当前频点列表
                    current_freqs, current_rcs = [], []
                else:
                    raise ValueError(f"Line {line_num}: Failed to parse Parameters block: {line}")
                continue

            # 情况2：数值行（仅当已有参数块时才收集）
            if current_params is not None:
                data_match = data_line_pattern.match(line)
                if data_match:
                    freq, rcs = float(data_match.group(1)), float(data_match.group(2))
                    current_freqs.append(freq)
                    current_rcs.append(rcs)

        # 不要遗漏最后一块！
        if current_params is not None and current_freqs:
            blocks.append(current_params)
            all_frequencies.append(current_freqs)
            all_rcs.append(current_rcs)

    # 构建宽表：每个参数组合占一行，频率与 RCS 作为列
    # 获取最大频点数（应对不同块长度差异）
    max_len = max(len(fs) for fs in all_frequencies) if all_frequencies else 0
    freq_cols = [f"Frequency_{i+1} / GHz" for i in range(max_len)]
    rcs_cols = [f"RCS_{i+1} [dB]" for i in range(max_len)]

    # 初始化结果字典
    result_dict = {
        'g1': [], 'g2': [], 'g3': [], 'g4': [], 'g5': [], 'l1': []
    }
    result_dict.update({col: [] for col in freq_cols + rcs_cols})

    # 填充每一行
    for i, params in enumerate(blocks):
        # 参数列
        result_dict['g1'].append(params.get('g1', float('nan')))
        result_dict['g2'].append(params.get('g2', float('nan')))
        result_dict['g3'].append(params.get('g3', float('nan')))
        result_dict['g4'].append(params.get('g4', float('nan')))
        result_dict['g5'].append(params.get('g5', float('nan')))
        result_dict['l1'].append(params.get('l1', float('nan')))

        # 频率 & RCS 列（补零或 NaN 对齐）
        freqs = all_frequencies[i] + [float('nan')] * (max_len - len(all_frequencies[i]))
        rcs_vals = all_rcs[i] + [float('nan')] * (max_len - len(all_rcs[i]))
        for j, (f, r) in enumerate(zip(freqs, rcs_vals)):
            result_dict[freq_cols[j]].append(f)
            result_dict[rcs_cols[j]].append(r)

    return pd.DataFrame(result_dict)

# ✅ 使用示例
if __name__ == "__main__":
    df = extract_parameters_and_data("simulation_data.txt")
    print(df.head())
    # 输出示例（首行）：
    #    g1   g2   g3   g4   g5  l1  Frequency_1 / GHz  ...  RCS_1 [dB]
    # 0  1.0  0.8  0.6  0.6  0.6  20.0                1.0  ...     -61.4567

⚠️ 关键注意事项

• 避免硬编码索引：原始代码依赖 params[0]、params[7] 等位置，一旦参数顺序变动或新增字段即崩溃；正则通过键名（如 'g5'）匹配，完全解耦顺序。
• 鲁棒性增强：自动跳过空行、注释行；对缺失参数填充 NaN；支持不同长度的频点序列（通过 max_len 对齐）。
• 编码安全：显式指定 encoding='utf-8'，防止 Windows 系统下中文路径或特殊字符报错。
• 性能提示：对于超大文件（>1GB），可改用 mmap 或逐块读取，但本方案已足够应对千级参数块场景。
• 扩展建议：如需提取 w, ct 等更多字段，只需在 kv_pattern 中添加 |w|ct，并在 result_dict 初始化中加入对应键即可。

该方法将文本解析从“脆弱的字符串手术”升级为“语义驱动的模式识别”，显著提升代码可维护性与工程可靠性。