请用python语言实现以下问题： 要求不用evaluate函数，改用栈实现这个问题 The objective of the program you are going to produce is to evaluate boolean expressions as the one shown next: Expression: ( V | V ) & F & ( F | V )where V is for True, and F is for False. The expressions may include the following operators: ! for not, & for and, | for or, the use of parenthesis for operations grouping is also allowed. To perform the evaluation of an expression, it will be considered the priority of the operators, the not having the highest, and the or the lowest. The program must yield V or F, as the result for each expression in the input file. Input The expressions are of a variable length, although will never exceed 100 symbols. Symbols may be separated by any number of spaces or no spaces at all, therefore, the total length of an expression, as a number of characters, is unknown. The number of expressions in the input file is variable and will never be greater than 20. Each expression is presented in a new line, as shown below. Output For each test expression, print "Expression " followed by its sequence number, ": ", and the resulting value of the corresponding test expression. Separate the output for consecutive test expressions with a new line. Use the same format as that shown in the sample output shown below. Sample Input ( V | V ) & F & ( F| V) !V | V & V & !F & (F | V ) & (!F | F | !V & V) (F&F|V|!V&!F&!(F|F&V)) Sample Output Expression 1: F Expression 2: V Expression 3: V

以下是用Python实现的代码，使用了栈来处理布尔表达式的求值：

def evaluate(expression):
    # 将表达式中的空格去掉
    expression = expression.replace(' ', '')
    # 将表达式转换为逆波兰表达式
    postfix = to_postfix(expression)
    # 创建一个栈来存储运算结果
    stack = []
    # 遍历逆波兰表达式，进行求值
    for token in postfix:
        if token in ['V', 'F']:
            # 如果是变量，将其入栈
            stack.append(token == 'V')
        elif token == '!':
            # 如果是非运算符，将栈顶元素取反
            operand = stack.pop()
            stack.append(not operand)
        else:
            # 如果是二元运算符，弹出两个操作数进行运算，并将结果入栈
            operand2 = stack.pop()
            operand1 = stack.pop()
            if token == '&':
                stack.append(operand1 and operand2)
            elif token == '|':
                stack.append(operand1 or operand2)
    # 栈顶元素即为表达式的求值结果
    return 'V' if stack[-1] else 'F'

def to_postfix(expression):
    # 将表达式中的空格去掉
    expression = expression.replace(' ', '')
    # 创建一个栈来存储运算符
    stack = []
    # 创建一个列表来存储逆波兰表达式
    postfix = []
    # 遍历表达式中的每个符号
    i = 0
    while i < len(expression):
        token = expression[i]
        if token in ['V', 'F']:
            # 如果是变量，直接将其加入逆波兰表达式
            postfix.append(token)
        elif token == '(':
            # 如果是左括号，将其入栈
            stack.append(token)
        elif token == ')':
            # 如果是右括号，弹出栈顶运算符并加入逆波兰表达式，直到遇到左括号
            while stack[-1] != '(':
                postfix.append(stack.pop())
            stack.pop()
        else:
            # 如果是运算符，弹出栈顶运算符并加入逆波兰表达式，直到栈为空或栈顶是左括号或优先级低于当前运算符
            while stack and stack[-1] != '(' and precedence(stack[-1]) >= precedence(token):
                postfix.append(stack.pop())
            stack.append(token)
        i += 1
    # 将栈中剩余的运算符加入逆波兰表达式
    while stack:
        postfix.append(stack.pop())
    return postfix

def precedence(operator):
    # 返回运算符的优先级，非运算符最高，或运算符最低
    if operator == '!':
        return 3
    elif operator == '&':
        return 2
    elif operator == '|':
        return 1
    else:
        return 0

# 从文件中读取表达式，并进行求值
with open('input.txt', 'r') as f:
    expressions = [line.strip() for line in f.readlines()]
    for i, expression in enumerate(expressions):
        result = evaluate(expression)
        print('Expression {}: {}: {}'.format(i+1, expression, result))

以上代码中，`evaluate`函数用于求解一个布尔表达式的值，`to_postfix`函数用于将中缀表达式转换为逆波兰表达式，`precedence`函数用于返回运算符的优先级。最后，从文件中读取表达式，并依次进行求值，并输出结果。