用栈的方法从文件读取表达式，判断表达式是否合理，将表达式转换成后缀形式，按后缀表达式求值；题目涉及加减乘除，带括弧的混合运算；随时可以退出；（2）从键盘输入表达式，利用算符优先原则求中缀表达式，并将表达式及其结果存入指定文件，可重复计算。

这个问题涉及到两个主要的编程任务：首先是使用栈来解析和计算中缀表达式，然后将中缀表达式转换为后缀表达式（也称为逆波兰表示法），并计算其值。第二个任务是处理从键盘输入的中缀表达式，使用算符优先解析，并将结果存储到文件中。以下是完成这些任务的方法和Python代码。

任务1：从文件读取中缀表达式并计算

def is_operator(c):
    return c in "+-*/"

def is_higher_precedence(op1, op2):
    if op1 == '(' or op2 == ')':
        return False
    elif op1 == '(' or op2 == '(':
        return True
    else:
        precedences = {'+': 1, '-': 1, '*': 2, '/': 2}
        return precedences[op1] > precedences[op2]

def infix_to_postfix(expression):
    stack = []  # 操作符栈
    postfix = []  # 后缀表达式列表
    for char in expression:
        if char.isdigit():  # 如果是数字，直接添加到后缀表达式
            postfix.append(char)
        elif char == '(':  # 左括号入栈
            stack.append(char)
        elif char == ')':  # 遇到右括号，将栈中操作符弹出，直到遇到左括号
            while stack and stack[-1] != '(':
                postfix.append(stack.pop())
            stack.pop()  # 弹出左括号
        elif is_operator(char):  # 操作符处理
            while stack and is_operator(stack[-1]) and is_higher_precedence(stack[-1], char):
                postfix.append(stack.pop())
            stack.append(char)
    while stack:  # 将栈中剩余的操作符弹出到后缀表达式
        postfix.append(stack.pop())
    return ''.join(postfix)

def evaluate_postfix(postfix):
    stack = []
    for char in postfix:
        if char.isdigit():  # 如果是数字，压入栈中
            stack.append(int(char))
        elif is_operator(char):  # 如果是操作符，从栈中弹出两个数字进行运算，将结果压栈
            a = stack.pop()
            b = stack.pop()
            if char == '+':
                stack.append(b + a)
            elif char == '-':
                stack.append(b - a)
            elif char == '*':
                stack.append(b * a)
            elif char == '/':
                stack.append(b / a)
    return stack[0]  # 栈顶元素为最终结果

# 从文件读取表达式并计算
def evaluate_expression_from_file(filename):
    try:
        with open(filename, 'r') as file:
            expression = file.readline().strip()
            if expression == 'exit':
                return
            postfix = infix_to_postfix(expression)
            result = evaluate_postfix(postfix)
            print(f"The result of '{expression}' is: {result}")
    except FileNotFoundError:
        print("File not found.")

# 假设有一个名为 'expressions.txt' 的文件包含中缀表达式
evaluate_expression_from_file('expressions.txt')

任务2：从键盘输入表达式并使用算符优先原则求中缀表达式

def precedence(op):
    precedences = {'+': 1, '-': 1, '*': 2, '/': 2}
    return precedences[op] if op in precedences else 0

def apply_operator(operators, values):
    op = operators.pop()
    right = values.pop()
    left = values.pop()
    if op == '+': values.append(left + right)
    elif op == '-': values.append(left - right)
    elif op == '*': values.append(left * right)
    elif op == '/': values.append(left / right)

def operator_precedence(operators, token):
    while operators and precedence(operators[-1]) >= precedence(token):
        apply_operator(operators, values)
    operators.append(token)

def parse_expression(expression):
    operators = []
    values = []
    i = 0
    while i < len(expression):
        if expression[i] == ' ':
            i += 1
        elif expression[i] == '(':
            operator_precedence(operators, expression[i])
        elif expression[i].isdigit():
            j = i
            while j < len(expression) and expression[j].isdigit():
                j += 1
            values.append(int(expression[i:j]))
            i = j
        elif expression[i] in "+-*/":
            operator_precedence(operators, expression[i])
        elif expression[i] == ')':
            while operators[-1] != '(':
                apply_operator(operators, values)
            operators.pop()  # 弹出左括号
        else:
            raise ValueError("Unexpected token: " + expression[i])
        i += 1

    while operators:
        apply_operator(operators, values)
        
    return values[0]

def calculate_and_store_result(expression, filename):
    result = parse_expression(expression)
    with open(filename, 'a') as file:
        file.write(f"{expression} = {result}\n")

# 假设用户输入的表达式和结果存储到 'results.txt' 文件
expression = input("Enter an expression: ")
calculate_and_store_result(expression, 'results.txt')

请注意，上述代码仅作为示例，实际应用中可能需要更多的错误处理和优化。在实际应用中，你可能还需要考虑表达式的合法性检查，以及在文件读写过程中处理可能的异常。