如何在按钮已关联命令且多Toplevel时关闭tkinter Toplevel窗口？

Got it, let's tackle this problem step by step. You've got multiple Toplevel windows in your class, and each has a button that's already tied to another command—you can't just replace the command with destroy(), but you need that button to close its parent Toplevel after running the original logic. Here's how to do it:

The core idea is to create a wrapper function that runs your existing command first, then calls destroy() on the specific Toplevel window the button belongs to. This way you don't break existing functionality, and each button targets its own window instead of accidentally closing others.

1. Basic Case: No Arguments in Original Command #

If your original command doesn't need parameters, a lambda function is perfect for combining the two actions. Here's a concrete example with a class that manages multiple Toplevels:

import tkinter as tk

class MultiToplevelManager:
    def __init__(self, root):
        self.root = root
        self.root.title("Main Window")
        
        # Buttons to spawn different Toplevels
        tk.Button(root, text="Open Window 1", command=self.create_window_1).pack(pady=5)
        tk.Button(root, text="Open Window 2", command=self.create_window_2).pack(pady=5)
    
    # Original command for Window 1
    def process_window1_task(self):
        print("Running Window 1's core task...")
    
    # Original command for Window 2
    def process_window2_task(self):
        print("Running Window 2's core task...")
    
    def create_window_1(self):
        self.window1 = tk.Toplevel(self.root)
        self.window1.title("Toplevel 1")
        
        # Wrap original task + close window in one lambda
        action_btn = tk.Button(
            self.window1, 
            text="Run Task & Close",
            command=lambda: (self.process_window1_task(), self.window1.destroy())
        )
        action_btn.pack(padx=30, pady=30)
    
    def create_window_2(self):
        self.window2 = tk.Toplevel(self.root)
        self.window2.title("Toplevel 2")
        
        action_btn = tk.Button(
            self.window2, 
            text="Run Task & Close",
            command=lambda: (self.process_window2_task(), self.window2.destroy())
        )
        action_btn.pack(padx=30, pady=30)

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

2. Handle Commands with Arguments #

If your original command requires parameters, use functools.partial to avoid lambda scope issues (this prevents bugs where the wrong argument gets passed to dynamic functions). Here's how to adapt it:

import tkinter as tk
from functools import partial

class ParamToplevelManager:
    def __init__(self, root):
        self.root = root
        self.root.title("Main Window")
        
        tk.Button(root, text="Open Param Window", command=self.create_param_window).pack(pady=5)
    
    # Original command with arguments
    def process_with_params(self, item_name, quantity):
        print(f"Processing {quantity} units of {item_name}...")
    
    def create_param_window(self):
        self.param_window = tk.Toplevel(self.root)
        self.param_window.title("Parameterized Toplevel")
        
        # Create a partial for the parameterized command
        wrapped_task = partial(self.process_with_params, "Widget", 10)
        # Wrap partial task + window close
        action_btn = tk.Button(
            self.param_window,
            text="Run Task & Close",
            command=lambda: (wrapped_task(), self.param_window.destroy())
        )
        action_btn.pack(padx=30, pady=30)

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

3. Reusable Wrapper Method (For Scalability) #

If you have many Toplevels, create a helper method to wrap commands consistently—this keeps your code clean and avoids repeating lambda logic:

import tkinter as tk

class ScalableToplevelManager:
    def __init__(self, root):
        self.root = root
        self.root.title("Main Window")
        
        tk.Button(root, text="Open Window A", command=self.create_window_a).pack(pady=5)
        tk.Button(root, text="Open Window B", command=self.create_window_b).pack(pady=5)
    
    def task_a(self):
        print("Executing Task A...")
    
    def task_b(self):
        print("Executing Task B...")
    
    # Helper wrapper method
    def wrap_task_and_close(self, original_task, target_window):
        def combined_action():
            original_task()
            target_window.destroy()
        return combined_action
    
    def create_window_a(self):
        self.window_a = tk.Toplevel(self.root)
        self.window_a.title("Window A")
        
        action_btn = tk.Button(
            self.window_a,
            text="Run & Close",
            command=self.wrap_task_and_close(self.task_a, self.window_a)
        )
        action_btn.pack(padx=30, pady=30)
    
    def create_window_b(self):
        self.window_b = tk.Toplevel(self.root)
        self.window_b.title("Window B")
        
        action_btn = tk.Button(
            self.window_b,
            text="Run & Close",
            command=self.wrap_task_and_close(self.task_b, self.window_b)
        )
        action_btn.pack(padx=30, pady=30)

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

Key Takeaways #

• Always reference the specific Toplevel instance (like self.window1) in your wrapper—this ensures you close the correct window when multiple are open.
• Lambdas work for simple, argument-free commands, while functools.partial is safer for parameterized logic.
• The wrapper preserves your original command's functionality, so you don't have to rewrite existing code.

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