用python 编程，命 题 演 算 公 式 是 指 由 逻 辑 变 量 (其 值 为 真 或 假 )和 逻 辑 运 算 符 ∧ (and)、 ∨ (or) 和  (NOT)按 一 定 规 则 (蕴 涵 等 运 算 可 使 用 ∧ 、 ∨ 等 )组 成 的 公 式 并以 表 示 )。 公 式 运 算 的 顺 序 是  ， ∧ ， ∨ ， 括 号 ()可 以 改 变 优 先 级 。 给 定 一 个 命 题 演 算 公 式 和 每 个 变 量 的 值 ， 需 要 设 计 一 个 程 序 来 计 算 公 式 的 真 值 。 【 基 本 要 求 】 (1)使 用 二 叉 树 计 算 公 式 的 真 值 。 首 先 ， 利 用 堆 栈 将 公 式 的 中 缀 形 式 改 为 后 缀 形 式 。 其 次 ， 根 据 后 缀 形 式 ， 从 叶 节 点 构 造 相 应 的 二 叉 树 。 最 后 ， 按 后 序 遍 历 二 叉 树 ， 找 出 每 个 子 树 的 值 。

下面是一个Python程序，用于计算命题演算公式的真值。它实现了将中缀表达式转换为后缀表达式，构建二叉树，并遍历二叉树计算每个子树的值。

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def is_operator(c):
    if c == '∧' or c == '∨' or c == '':
        return True
    else:
        return False

def inorder_to_postorder(inorder_exp):
    precedence = {'': 3, '∧': 2, '∨': 1, '(': 0}
    operator_stack = []
    postfix_list = []
    token_list = inorder_exp.split()

    for token in token_list:
        if token == '(':
            operator_stack.append(token)
        elif token == ')':
            top_token = operator_stack.pop()
            while top_token != '(':
                postfix_list.append(top_token)
                top_token = operator_stack.pop()
        elif is_operator(token):
            while (len(operator_stack) != 0) and (precedence[operator_stack[-1]] >= precedence[token]):
                postfix_list.append(operator_stack.pop())
            operator_stack.append(token)
        else:
            postfix_list.append(token)

    while len(operator_stack) != 0:
        postfix_list.append(operator_stack.pop())

    return postfix_list

def build_tree(postfix_exp):
    operand_stack = []

    for token in postfix_exp:
        if not is_operator(token):
            node = Node(token)
            operand_stack.append(node)
        else:
            right_operand = operand_stack.pop()
            left_operand = operand_stack.pop()
            node = Node(token)
            node.left = left_operand
            node.right = right_operand
            operand_stack.append(node)

    return operand_stack.pop()

def evaluate(root, var_dict):
    if root.val not in var_dict:
        return False
    elif root.left == None and root.right == None:
        return var_dict[root.val]
    else:
        left_val = evaluate(root.left, var_dict)
        right_val = evaluate(root.right, var_dict)

        if root.val == '∧':
            return left_val and right_val
        elif root.val == '∨':
            return left_val or right_val
        elif root.val == '':
            return not left_val

def calculate(inorder_exp, var_dict):
    postfix_exp = inorder_to_postorder(inorder_exp)
    root = build_tree(postfix_exp)
    return evaluate(root, var_dict)

这个程序的使用方法是，首先定义一个字典，其中包含每个变量的值。然后调用`calculate`函数，传入命题演算公式和字典，即可计算出真值。例如：

var_dict = {'p': True, 'q': False, 'r': True}
inorder_exp = 'p ∧ (q ∨ r)'
print(calculate(inorder_exp, var_dict))  # 输出 True