Tkinter多控件输入冲突：笔记区输入数字同步写入计算器标签

全局键盘事件直接绑定在主窗口self.window上，Tkinter事件冒泡机制会让笔记文本框获得焦点时的输入，同时向上传递给主窗口触发计算器输入逻辑，导致两边同步写入。另外原代码中笔记Text组件的height参数缺失，运行会直接抛出语法错误。

• 补全笔记文本框定义，将文本框存为实例属性方便后续事件判断，修正原代码缺失参数的语法问题，同时调整窗口初始高度避免新增笔记组件后界面挤压
• 重写键盘绑定逻辑，增加焦点判断：仅当输入焦点不在笔记文本框时，才触发计算器的按键响应逻辑，笔记区域获得焦点时所有输入只保留在文本框内
• 调整按键绑定代码的执行顺序，必须在笔记组件创建完成后再执行绑定，否则会出现实例属性不存在的报错

import tkinter as tk
#FONTS
LARGE_FONT_STYLE    = ("Arial", 40, "bold")
SMALL_FONT_STYLE    = ("Arial", 16)
DIGITS_FONT_STYLE   = ("Arial", 24, "bold")
DEFAULT_FONT_STYLE  = ("Arial", 20)
#COLOURS
OFF_WHITE   = "#F8FAFF"
WHITE       = "#FFFFFF"
LIGHT_BLUE  = "#CCEDFF"
LIGHT_GRAY  = "#F5F5F5"
LABEL_COLOR = "#25265E"

#MAIN CALCULATOR
class Calculator:
    def __init__(self):
        self.window = tk.Tk()
        self.window.geometry("375x660")
        self.window.resizable(0, 0)
        self.window.title("Calculator")

        self.total_expression = ""
        self.current_expression = ""
        self.display_frame = self.create_display_frame()

        self.total_label, self.label = self.create_display_labels()

        self.digits = {
            7: (1, 1), 8: (1, 2), 9: (1, 3),
            4: (2, 1), 5: (2, 2), 6: (2, 3),
            1: (3, 1), 2: (3, 2), 3: (3, 3),
            0: (4, 2), '.': (4, 1)
        }
        self.operations = {"/": "\u00F7", "*": "\u00D7", "+": "+", "-": "-"}
        self.buttons_frame = self.create_buttons_frame()

        self.buttons_frame.rowconfigure(0, weight=1)
        for x in range(1, 5):
            self.buttons_frame.rowconfigure(x, weight=1)
            self.buttons_frame.columnconfigure(x, weight=1)
        self.create_digit_buttons()
        self.create_operator_buttons()
        self.create_special_buttons()

        #notes window
        self.notes_text = tk.Text(self.window, height=8, width=37)
        self.notes_text.pack()
        quote = """NOTES: 
"""
        self.notes_text.insert(tk.END, quote)

        # 笔记组件创建完成后再绑定键盘事件
        self.bind_keys()

    def bind_keys(self):
        def key_handler(event, value, is_operator=False):
            # 焦点在笔记框时直接返回，不触发计算器逻辑
            if event.widget == self.notes_text:
                return
            if is_operator:
                self.append_operator(value)
            else:
                self.add_to_expression(value)
        
        def enter_handler(event):
            if event.widget == self.notes_text:
                return
            self.evaluate()

        self.window.bind("<Return>", enter_handler)
        for key in self.digits:
            self.window.bind(str(key), lambda event, digit=key: key_handler(event, digit))
        for key in self.operations:
            self.window.bind(key, lambda event, op=key: key_handler(event, op, is_operator=True))

    def create_special_buttons(self):
        self.create_clear_button()
        self.create_equals_button()

    def create_display_labels(self):
        total_label = tk.Label(self.display_frame, text=self.total_expression, anchor=tk.E, bg=LIGHT_GRAY,
                               fg=LABEL_COLOR, padx=24, font=SMALL_FONT_STYLE)
        total_label.pack(expand=True, fill='both')

        label = tk.Label(self.display_frame, text=self.current_expression, anchor=tk.E, bg=LIGHT_GRAY,
                         fg=LABEL_COLOR, padx=24, font=LARGE_FONT_STYLE)
        label.pack(expand=True, fill='both')

        return total_label, label

    def create_display_frame(self):
        frame = tk.Frame(self.window, height=221, bg=LIGHT_GRAY)
        frame.pack(expand=True, fill="both")
        return frame

    def add_to_expression(self, value):
        self.current_expression += str(value)
        self.update_label()

    def create_digit_buttons(self):
        for digit, grid_value in self.digits.items():
            button = tk.Button(self.buttons_frame, text=str(digit), bg=WHITE, fg=LABEL_COLOR, font=DIGITS_FONT_STYLE,
                               borderwidth=0, command=lambda x=digit: self.add_to_expression(x))
            button.grid(row=grid_value[0], column=grid_value[1], sticky=tk.NSEW)

    def append_operator(self, operator):
        self.current_expression += operator
        self.total_expression += self.current_expression
        self.current_expression = ""
        self.update_total_label()
        self.update_label()

    def create_operator_buttons(self):
        i =1
        for operator, symbol in self.operations.items():
            button = tk.Button(self.buttons_frame, text=symbol, bg=OFF_WHITE, fg=LABEL_COLOR, font=DEFAULT_FONT_STYLE,
                               borderwidth=0, command=lambda x=operator: self.append_operator(x))
            button.grid(row=i, column=4, sticky=tk.NSEW)
            i += 1

    def clear(self):
        self.current_expression = ""
        self.total_expression = ""
        self.update_label()
        self.update_total_label()

    def create_clear_button(self):
        button = tk.Button(self.buttons_frame, text="C", bg=OFF_WHITE, fg=LABEL_COLOR, font=DEFAULT_FONT_STYLE,
                           borderwidth=0, command=self.clear)
        button.grid(row=0, column=1, sticky=tk.NSEW)


    def evaluate(self):
        self.total_expression += self.current_expression
        self.update_total_label()
        try:
            self.current_expression = str(eval(self.total_expression))

            self.total_expression = ""
        except Exception as e:
            self.current_expression = "Error"
        finally:
            self.update_label()

    def create_equals_button(self):
        button = tk.Button(self.buttons_frame, text="=", bg=LIGHT_BLUE, fg=LABEL_COLOR, font=DEFAULT_FONT_STYLE,
                           borderwidth=0, command=self.evaluate)
        button.grid(row=4, column=3, columnspan=1, sticky=tk.NSEW)

    def create_buttons_frame(self):
        frame = tk.Frame(self.window)
        frame.pack(expand=True, fill="both")
        return frame

    def update_total_label(self):
        expression = self.total_expression
        for operator, symbol in self.operations.items():
            expression = expression.replace(operator, f' {symbol} ')
        self.total_label.config(text=expression)

    def update_label(self):
        self.label.config(text=self.current_expression[:11])


    def run(self):
        self.window.mainloop()


if __name__ == "__main__":
    calc = Calculator()
    calc.run()

可根据实际显示需求自行调整窗口初始高度、笔记框height参数，上述逻辑已经实现笔记区域独立输入，焦点在笔记框时按回车可正常换行，不会触发计算器计算。

内容的提问来源于stack exchange，提问作者Max AMS