含文件名的嵌套模板字符串递归排列处理方案及工具问询

一、解决嵌套解析的核心逻辑（替代易挂起的正则） #

正则处理嵌套括号容易因回溯导致程序挂起，尤其是深度较大或模板较长时，改用递归+栈定位的方式更可靠：

• 遍历模板字符串，定位最外层的{...}块（用栈记录嵌套层级，栈空时的{和}就是最外层边界）
• 拆分模板块内的元素：
  • 若元素是{filename.txt}格式，直接读取文件内容，将文件中的项（按逗号或换行拆分）作为子元素
  • 若元素是嵌套模板（如{a, {b.txt}}），递归调用解析逻辑展开
• 逐层展开所有嵌套后，再生成所有排列组合

二、结合已有函数的实现步骤 #

假设你已实现expand_template()（展开单个模板块）和generate_permutations()（生成笛卡尔积排列），可以按以下流程整合：

1. 递归展开所有嵌套与文件引用 #

def resolve_nested(template):
    # 找第一个最外层{的位置
    start = template.find('{')
    if start == -1:
        return [template]
    
    # 匹配对应的}
    stack = 1
    end = start + 1
    while end < len(template) and stack > 0:
        if template[end] == '{':
            stack += 1
        elif template[end] == '}':
            stack -= 1
        end += 1
    if stack != 0:
        raise ValueError("Unbalanced brackets in template")
    
    prefix = template[:start]
    content = template[start+1:end-1]
    suffix = template[end:]
    
    # 拆分并处理模板内容里的每个元素
    elements = []
    for elem in [e.strip() for e in content.split(',') if e.strip()]:
        if elem.startswith('{') and elem.endswith('}'):
            nested_content = elem[1:-1]
            if '.' in nested_content:
                # 处理文件引用
                with open(nested_content, 'r') as f:
                    # 按逗号拆分文件内容，可根据实际调整为换行
                    file_items = [item.strip() for item in f.read().split(',') if item.strip()]
                    elements.extend(file_items)
            else:
                # 递归处理嵌套模板
                nested_results = resolve_nested(f'{{{nested_content}}}')
                elements.extend(nested_results)
        else:
            elements.append(elem)
    
    # 拼接前缀、元素、后缀，递归处理剩余模板
    final_output = []
    for elem in elements:
        combined = prefix + elem + suffix
        final_output.extend(resolve_nested(combined))
    
    return final_output

2. 调用已有函数生成排列 #

如果你的generate_permutations()是用来处理多模板块的笛卡尔积，那么resolve_nested()返回的结果已经是所有可能的排列组合（比如"{a,b} {x,y}"会直接返回["a x", "a y", "b x", "b y"]），可以直接使用；如果需要对展开后的元素列表做进一步排列，直接将resolve_nested()输出的元素传入你的函数即可。

三、正则挂起的原因 #

正则表达式处理嵌套结构时，依赖回溯匹配嵌套的括号，当模板嵌套深度大或内容过长时，会触发指数级的回溯操作，导致程序卡顿甚至挂起。递归+栈的方式是线性遍历，无回溯问题，稳定性和效率更高。

四、现成工具推荐 #

• Jinja2/Mako：这类模板引擎支持自定义过滤器和函数，可以通过扩展实现文件读取与嵌套解析，配合循环语法生成排列，适合复杂模板场景。
• PyParsing：专门处理嵌套语法的库，无需手动写栈逻辑，直接定义语法规则即可解析任意深度的{...}结构，示例代码：

  from pyparsing import nestedExpr, delimitedList, Word, alphas, nums, Combine
  
  # 定义模板语法规则
  element = Combine(Word(alphas + nums + '.') | nestedExpr('{', '}'))
  template_parser = nestedExpr('{', '}', content=delimitedList(element))
  
  # 解析示例模板
  parsed_result = template_parser.parseString("{person, fox, bear, joe, mary, lou, {animals.txt}}")
  

内容的提问来源于stack exchange，提问作者Kenny J