为了创建一个更复杂的计算器，我们可以增加一些额外的功能，比如支持括号、更复杂的表达式解析（包括运算符的优先级处理），以及可能的用户交互改进。以下是一个使用Python和tkinter库创建的复杂计算器示例，它支持括号、加减乘除运算以及运算符的优先级处理。

import tkinter as tk
import re

class AdvancedCalculator:
    def __init__(self, root):
        self.root = root
        self.root.title("复杂计算器")

        self.expression_var = tk.StringVar()
        self.expression_var.set("")

        self.result_var = tk.StringVar()
        self.result_var.set("0")

        self.create_widgets()

    def create_widgets(self):
        # 创建显示表达式的Entry
        self.expression_entry = tk.Entry(self.root, textvariable=self.expression_var, font=('Arial', 18), bd=8, insertwidth=4, width=26, borderwidth=4)
        self.expression_entry.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

        # 创建显示结果的Entry
        self.result_entry = tk.Entry(self.root, textvariable=self.result_var, font=('Arial', 24), bd=10, insertwidth=2, width=10, state='readonly', borderwidth=4)
        self.result_entry.grid(row=1, column=0, columnspan=4, pady=10)

        # 创建按钮并放置在网格中
        buttons = [
            '7', '8', '9', '/',
            '4', '5', '6', '*',
            '1', '2', '3', '-',
            'C', '0', '=', '+',
            '(', ')'
        ]

        row_val = 2
        col_val = 0

        for button in buttons:
            command = lambda x=button: self.click_event(x)
            tk.Button(self.root, text=button, padx=20, pady=20, font=('Arial', 18), command=command).grid(row=row_val, column=col_val)

            col_val += 1
            if col_val > 3:
                col_val = 0
                row_val += 1

    def click_event(self, key):
        current_expression = self.expression_var.get()

        if key == "=":
            try:
                result = self.evaluate_expression(current_expression)
                self.result_var.set(str(result))
            except Exception as e:
                self.result_var.set("错误")
        elif key == "C":
            self.expression_var.set("")
            self.result_var.set("0")
        else:
            self.expression_var.set(current_expression + key)

    def evaluate_expression(self, expression):
        # 这是一个简单的表达式求值函数，使用栈来处理运算符的优先级
        def precedence(op):
            if op in ('+', '-'):
                return 1
            if op in ('*', '/'):
                return 2
            return 0

        def apply_op(a, b, op):
            if op == '+': return a + b
            if op == '-': return a - b
            if op == '*': return a * b
            if op == '/':
                if b == 0:
                    raise ZeroDivisionError("除数不能为零")
                return a / b

        numbers = []
        operators = []
        i = 0
        while i < len(expression):
            if expression[i] == ' ':
                i += 1
                continue

            if expression[i] == '(':
                operators.append(expression[i])

            elif expression[i].isdigit() or expression[i] == '.':
                val = 0
                decimal_place = -1
                while (i < len(expression) and
                       (expression[i].isdigit() or expression[i] == '.')):
                    if expression[i] == '.':
                        decimal_place = len(val.split('.'))
                    elif decimal_place == -1:
                        val = (val * 10) + int(expression[i])
                    else:
                        decimal_val = int(expression[i]) / (10 ** (len(str(val).split('.'))[1] if '.' in str(val) else 0 + 1))
                        val += decimal_val
                    i += 1
                i -= 1  # Correct the index for the next iteration
                numbers.append(float(str(val)))

            elif expression[i] in '+-*/':
                while (len(operators) != 0 and
                       precedence(operators[-1]) >= precedence(expression[i])):
                    operators.pop()
                    if len(numbers) >= 2:
                        b = numbers.pop()
                        a = numbers.pop()
                        result = apply_op(a, b, operators.pop())
                        numbers.append(result)
                operators.append(expression[i])

            elif expression[i] == ')':
                while (len(operators) != 0 and operators[-1] != '('):
                    if len(numbers) >= 2:
                        b = numbers.pop()
                        a = numbers.pop()
                        result = apply_op(a, b, operators.pop())
                        numbers.append(result)
                operators.pop()  # Remove '(' from the stack

            i += 1

        while len(operators) != 0:
            if len(numbers) >= 2:
                b = numbers.pop()
                a = numbers.pop()
                result = apply_op(a, b, operators.pop())
                numbers.append(result)

        return numbers[0]

if __name__ == "__main__":
    root = tk.Tk()
    app = AdvancedCalculator(root)
    root.mainloop()

代码说明

1. AdvancedCalculator类：

   • 初始化方法__init__：设置窗口标题，创建并初始化用于显示表达式和结果的StringVar变量，然后调用create_widgets方法创建按钮和文本框。
   • create_widgets方法：创建用于显示表达式和结果的Entry以及用于输入操作的按钮，并将它们放置在网格布局中。
   • click_event方法：处理按钮点击事件。根据点击的按钮更新显示表达式或计算结果。
   • evaluate_expression方法：这是一个简单的表达式求值函数，它使用栈来处理运算符的优先级。该函数支持加减乘除运算以及括号。

2. 主程序：

   • 创建Tk根窗口实例。
   • 创建AdvancedCalculator应用实例，传入根窗口。
   • 进入mainloop循环，等待用户交互。

这个计算器支持复杂的数学表达式输入，并能够根据运算符的优先级以及括号进行正确的计算。注意，虽然这个示例已经相对复杂，但在实际应用中，可能需要更多的错误处理和边界情况检查，以确保计算器的健壮性和准确性。