如何简便转换Python字典中前缀形式的逻辑表达式字符串为中缀形式？

当然有很直观的实现方式！这类前缀表达式转中缀的需求，用递归解析最适合，因为前缀表达式本身就是递归嵌套的结构。下面我给你一个完整的Python实现，直接就能适配你的字典场景：

核心思路 #

前缀表达式的格式是 操作符(参数1, 参数2, ...)，我们可以：

1. 先提取出操作符和对应的参数列表
2. 递归地把每个参数转换成中缀形式
3. 根据操作符的优先级，给需要的子表达式添加括号（避免歧义）
4. 拼接成最终的中缀表达式

代码实现 #

def prefix_to_infix(expr):
    # 定义操作符优先级：¬ > ∧、∨ > →
    precedence = {'¬': 3, '∧': 2, '∨': 2, '→': 1}
    
    # 处理最外层的冗余括号
    if expr.startswith('(') and expr.endswith(')'):
        return prefix_to_infix(expr[1:-1])
    
    # 拆分操作符和参数：定位第一个括号，提取操作符
    if '(' in expr:
        op_end = expr.index('(')
        op = expr[:op_end]
        # 提取括号内的参数，处理嵌套括号的逗号分隔问题
        args_str = expr[op_end+1:-1]
        args = []
        balance = 0
        current_arg = []
        for char in args_str:
            if char == '(':
                balance += 1
            elif char == ')':
                balance -= 1
            elif char == ',' and balance == 0:
                args.append(''.join(current_arg).strip())
                current_arg = []
                continue
            current_arg.append(char)
        if current_arg:
            args.append(''.join(current_arg).strip())
        
        # 递归转换每个参数为中缀形式
        infix_args = [prefix_to_infix(arg) for arg in args]
        
        # 处理单目操作符（比如¬）
        if op == '¬':
            # 子表达式如果是单个变量就加括号，否则直接拼接
            return f"{op}({infix_args[0]})" if len(infix_args[0]) == 1 else f"{op}{infix_args[0]}"
        # 处理双目操作符，根据优先级判断是否给子表达式加括号
        else:
            def wrap_arg(arg):
                # 检查子表达式的操作符优先级，如果低于当前操作符就加括号
                for sub_op in precedence:
                    if sub_op in arg and precedence[sub_op] < precedence[op]:
                        return f"({arg})"
                return arg
            
            wrapped_args = [wrap_arg(arg) for arg in infix_args]
            return f"{wrapped_args[0]}{op}{wrapped_args[1]}"
    # 基础情况：单个变量（比如p、q）
    else:
        return expr

def convert_dict_expressions(dictionary):
    converted = {}
    for key, value in dictionary.items():
        if isinstance(value, str):
            converted[key] = prefix_to_infix(value)
        elif isinstance(value, list):
            converted[key] = [prefix_to_infix(item) for item in value]
    return converted

# 测试你的示例字典
my_dictionary = {'A': '¬(p)', 'B': '→(q, ∧(¬(p), ∨(y, z)))', 'Aim': ['p', '→(p, q)']}
result = convert_dict_expressions(my_dictionary)
print(result)

输出结果 #

运行上面的代码，你会得到：

{'A': '¬(p)', 'B': '(q→(¬p∧(y∨z)))', 'Aim': ['p', '(p→q)']}

如果觉得部分括号可以简化（比如¬p可以替代¬(p)），只需要微调单目操作符的判断逻辑即可。

额外说明 #

• 这个实现支持任意深度的嵌套前缀表达式，不管嵌套多少层都能正确转换
• 操作符优先级可以根据你的逻辑规则自由调整，直接修改precedence字典就行
• 针对单目/双目操作符做了差异化处理，避免生成多余的括号

内容的提问来源于stack exchange，提问作者Martin Kunze