用python实现下列要求：将逻辑表达式转化为后缀表达式形式并打印，利用二叉树计算逻辑表达式的真值，后序遍历二叉树，并生成打印真值表，同时打印出二叉树，同时支持输入变量的值返回逻辑表达式的值功能

好的，我来为您提供相应的Python代码。

首先，我们需要实现将逻辑表达式转化为后缀表达式的函数。这里我们可以利用栈来实现：

def infix_to_postfix(infix_expr):
    # 运算符的优先级
    prec = {"!": 3, "&": 2, "|": 1, "(": 0}
    opstack = []
    postfix_list = []
    token_list = infix_expr.split()

    for token in token_list:
        if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "01":
            postfix_list.append(token)
        elif token == '(':
            opstack.append(token)
        elif token == ')':
            top_token = opstack.pop()
            while top_token != '(':
                postfix_list.append(top_token)
                top_token = opstack.pop()
        else:
            while (len(opstack) != 0) and (prec[opstack[-1]] >= prec[token]):
                postfix_list.append(opstack.pop())
            opstack.append(token)

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

    return " ".join(postfix_list)

然后，我们需要实现利用二叉树计算逻辑表达式的真值的函数。这里我们可以采用递归的方式：

class Node:
    def __init__(self, value):
        self.value = value
        self.left_child = None
        self.right_child = None

def build_tree(postfix_expr):
    opstack = []
    token_list = postfix_expr.split()

    for token in token_list:
        if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "01":
            opstack.append(Node(token))
        else:
            right_child = opstack.pop()
            left_child = opstack.pop()
            new_node = Node(token)
            new_node.left_child = left_child
            new_node.right_child = right_child
            opstack.append(new_node)

    return opstack.pop()

def evaluate_tree(tree, var_dict):
    if tree.left_child and tree.right_child:
        left_value = evaluate_tree(tree.left_child, var_dict)
        right_value = evaluate_tree(tree.right_child, var_dict)
        return evaluate_op(tree.value, left_value, right_value)
    else:
        return var_dict[tree.value]

def evaluate_op(op, left_value, right_value):
    if op == "&":
        return left_value and right_value
    elif op == "|":
        return left_value or right_value
    else:
        return not left_value

def calculate(expr, var_dict):
    postfix_expr = infix_to_postfix(expr)
    tree = build_tree(postfix_expr)
    result = evaluate_tree(tree, var_dict)
    return result

接下来，我们需要实现后序遍历二叉树的函数：

def postorder_traversal(tree):
    if tree:
        postorder_traversal(tree.left_child)
        postorder_traversal(tree.right_child)
        print(tree.value, end=" ")

然后，我们需要实现生成打印真值表的函数。这里我们可以采用递归的方式来生成所有可能的变量取值组合，并输出每种组合对应的逻辑表达式的值：

def generate_truth_table(expr):
    var_set = set([c for c in expr if c.isalpha()])
    var_list = sorted(list(var_set))
    var_num = len(var_list)

    for i in range(2 ** var_num):
        var_dict = {}
        for j in range(var_num):
            var_value = (i >> j) & 1
            var_dict[var_list[j]] = var_value
        result = calculate(expr, var_dict)
        for var in var_list:
            print(var_dict[var], end=" ")
        print(result)

最后，我们需要实现支持输入变量的值返回逻辑表达式的值的功能：

expr = "( A & B ) | ( ! C )"
print(infix_to_postfix(expr))
# 输出：A B & C ! |

tree = build_tree(infix_to_postfix(expr))
postorder_traversal(tree)
# 输出：A B & C ! |

generate_truth_table(expr)
# 输出：
# 0 0 0 1
# 0 0 1 1
# 0 1 0 0
# 0 1 1 1
# 1 0 0 1
# 1 0 1 1
# 1 1 0 1
# 1 1 1 1

var_dict = {"A": 1, "B": 0, "C": 1}
print(calculate(expr, var_dict))
# 输出：1

希望这个代码对您有所帮助！