将Python GUI程序拆分为顶层界面与子模块的实现疑问及报错解决请求

首先肯定你的想法：完全可以实现把GUI结构和业务逻辑拆分到不同文件，而且这确实是更易维护的好做法！你现在遇到的问题主要是控件变量的作用域问题和控件对象的错误赋值，我一步步给你讲清楚怎么改：

先解决你当前的两个核心错误 #

1. 控件变量被错误赋值为None

你主文件里写的but_01 = tk.Button(...).grid(row=2, column=0)是个典型坑点！grid()方法的返回值是None，所以but_01根本不是按钮对象，而是None。必须把控件创建和布局操作分开写：

# 错误写法：变量存的是grid()的返回值None
# but_01 = tk.Button(frame_01, text="Press me No 1...").grid(row=2, column=0)

# 正确写法：先创建控件，再布局，变量指向真正的按钮对象
but_01 = tk.Button(frame_01, text="Press me No 1 (Entry t0 text box).")
but_01.grid(row=2, column=0)

所有控件（Entry、Text、Label）都要这么改，不然后面不管怎么传参都是无效的None对象。

2. 子模块不能直接访问主文件的变量

子模块func_01.py里直接写but_01.config(...)会报错，因为子模块的命名空间里没有but_01这个变量——Python的模块是独立的命名空间，不能直接跨模块访问变量，得通过传参的方式把需要的控件对象传给子模块的函数。

给你两种具体的实现方案 #

方案一：简单函数传参（适合入门过渡）

步骤1：修正主文件GUI.py的控件定义

把所有控件的创建和布局拆分，确保变量指向控件对象：

# GUI.py 完整修正后的核心部分
import tkinter as tk
import modules.func_01

root = tk.Tk()
root.geometry("700x500")
root.title("Test GUI only top file.")

frame_01 = tk.Frame(root, relief="ridge", bd=4, padx=5,pady=5)
frame_02 = tk.Frame(root, relief="ridge", bd=4, padx=5,pady=5)
frame_03 = tk.Frame(root, relief="ridge", bd=4, padx=5,pady=5)

frame_01.grid(row=0, column=0)
frame_02.grid(row=1, column=1)
frame_03.grid(row=2, column=0, columnspan=2)

# 控件创建与布局拆分
label_01 = tk.Label(frame_01, text = "Frame_01, Enter text below!")
label_01.grid(row=0, column=0)
label_02 = tk.Label(frame_02, text = "Frame_02, Enter text below!")
label_02.grid(row=0, column=0)

ent_01   = tk.Entry(frame_01, width = 20)
ent_01.grid(row=1, column=0)
ent_02   = tk.Entry(frame_02, width = 30)
ent_02.grid(row=1, column=0)

but_01   = tk.Button(frame_01, text="Press me No 1 (Entry t0 text box).")
but_01.grid(row=2, column=0)
but_02   = tk.Button(frame_02, text="Press me No 2 (Entry t0 text box).")
but_02.grid(row=2, column=0)

text_box = tk.Text(frame_03, height = 15, width = 60, padx=10,pady=10)
text_box.grid(row=0, column=0) 

# 调用子模块的配置函数，传入需要的控件
modules.func_01.setup_frame01_commands(but_01, ent_01, text_box)

root.mainloop()

步骤2：修改子模块func_01.py

把直接访问变量改成接收参数的函数，内部封装按钮的命令逻辑：

# modules/func_01.py
def setup_frame01_commands(button, input_entry, output_textbox):
    def get_and_display_input():
        # 实现你的业务逻辑：获取输入并显示
        input_content = input_entry.get()
        output_textbox.insert(tk.END, f"Frame 01 提交内容：{input_content}\n")
    
    # 给按钮绑定命令
    button.config(command=get_and_display_input)

这样运行后，按钮就能正常触发逻辑了，而且子模块不需要关心主文件的变量名，只需要处理传入的控件对象，耦合度很低。

方案二：类封装（推荐，适合你的多框架项目）

因为你要做6个左右的框架，每个框架有独立的逻辑，用类来封装每个框架的UI和业务逻辑会更清晰，后续维护和扩展也更方便。

示例：Frame01的处理类

# modules/frame01_handler.py
import tkinter as tk

class Frame01Handler:
    def __init__(self, parent, output_textbox):
        # 保存共享的输出文本框
        self.output_textbox = output_textbox
        
        # 创建当前框架的所有控件
        self.frame = tk.Frame(parent, relief="ridge", bd=4, padx=5,pady=5)
        self.label = tk.Label(self.frame, text = "Frame_01, Enter text below!")
        self.label.grid(row=0, column=0)
        
        self.input_ent = tk.Entry(self.frame, width=20)
        self.input_ent.grid(row=1, column=0)
        
        self.add_btn = tk.Button(
            self.frame, 
            text="Press me No 1 (Entry to text box).",
            command=self._handle_add
        )
        self.add_btn.grid(row=2, column=0)
    
    def _handle_add(self):
        # 框架内部的添加逻辑
        content = self.input_ent.get()
        self.output_textbox.insert(tk.END, f"Frame 01 输入内容：{content}\n")
    
    def get_data(self):
        # 提供对外获取当前框架数据的方法，供后续Build按钮使用
        return {"frame01_input": self.input_ent.get()}

主文件GUI.py调用类

# GUI.py
import tkinter as tk
from modules.frame01_handler import Frame01Handler
from modules.frame02_handler import Frame02Handler  # 同理实现Frame02的类

root = tk.Tk()
root.geometry("700x500")
root.title("Test GUI with Class Modules")

# 创建共享的输出区域
frame_output = tk.Frame(root, relief="ridge", bd=4, padx=5,pady=5)
frame_output.grid(row=2, column=0, columnspan=2)
text_box = tk.Text(frame_output, height=15, width=60, padx=10,pady=10)
text_box.grid(row=0, column=0)

# 初始化各个框架
frame01 = Frame01Handler(root, text_box)
frame02 = Frame02Handler(root, text_box)

# 布局各个框架
frame01.frame.grid(row=0, column=0)
frame02.frame.grid(row=1, column=1)

# 实现Build按钮的逻辑
def build_file():
    # 收集所有框架的数据
    all_data = {}
    all_data.update(frame01.get_data())
    all_data.update(frame02.get_data())
    # 其他框架依次调用get_data()
    
    # 处理数据并写入文件
    with open("output_config.txt", "w", encoding="utf-8") as f:
        f.write("===== 汇总数据 =====\n")
        for section, value in all_data.items():
            f.write(f"{section}: {value}\n")
    text_box.insert(tk.END, "===== 数据已生成文件 =====\n")

build_btn = tk.Button(root, text="Build", command=build_file, width=15)
build_btn.grid(row=3, column=0, columnspan=2, pady=10)

root.mainloop()

这种方式的好处是：每个框架的UI、事件逻辑、数据收集都封装在一个类里，修改某个框架的逻辑只需要改对应的类文件，完全不影响其他部分，非常符合你“GUI一个文件，各框架逻辑分开”的需求。

最后给你几个额外的小建议 #

1. 子模块的__init__.py可以空着，它的作用是告诉Python这个文件夹是一个可导入的模块，你的写法没问题。
2. 对于多输入框的框架，可以把输入框的变量（比如tk.StringVar()）也封装在类里，方便后续获取和验证数据。
3. 如果你之前写过单文件版本，迁移的时候可以把每个框架的逻辑逐步拆到对应的类里，不用一次性全部重构，降低风险。

这样拆分后，后续的更新和维护会轻松很多，完全符合你想要的“更好的实现方式”！

备注：内容来源于stack exchange，提问作者KevP