Tkinter 如何在TkInter中创建子窗口并与父窗口通信

在本文中，我们将介绍如何在Tkinter中创建子窗口，并通过不同的方法与父窗口进行通信。我们将使用Python的Tkinter库来构建图形用户界面。通过创建子窗口，我们可以在应用程序中实现一些特定功能，如显示额外的信息、执行特定的任务或进行用户交互。同时，我们还将探讨不同的通信方式，包括使用返回值、回调函数和全局变量等技术。

阅读更多：Tkinter 教程

创建子窗口

在Tkinter中，我们可以使用Toplevel类来创建子窗口。下面是一个简单的示例，展示了如何创建一个名为”Child Window”的子窗口：

import tkinter as tk

def create_child_window():
    child_window = tk.Toplevel()
    child_window.title("Child Window")
    child_window.mainloop()

# 创建主窗口
root = tk.Tk()
root.title("Main Window")

# 创建按钮，点击按钮时创建子窗口
btn_create_child = tk.Button(root, text="Create Child Window", command=create_child_window)
btn_create_child.pack()

root.mainloop()

在这个示例中，我们创建了一个名为”Main Window”的主窗口，并在主窗口中创建了一个按钮。当用户点击按钮时，create_child_window函数被调用，从而创建了一个名为”Child Window”的子窗口。

与父窗口通信

返回值

一种常见的与子窗口进行通信的方式是通过返回值。我们可以在子窗口中执行一些操作，在完成后将结果返回给父窗口。下面是一个示例：

import tkinter as tk

def open_child_window():
    child_window = tk.Toplevel()
    child_window.title("Child Window")

    # 在子窗口中添加一个标签和一个按钮
    lbl_message = tk.Label(child_window, text="Hello from Child Window!")
    lbl_message.pack()

    btn_close_child = tk.Button(child_window, text="Close", command=lambda: close_child_window(child_window))
    btn_close_child.pack()

def close_child_window(child_window):
    child_window.destroy()
    # 返回子窗口中的消息给父窗口
    return "Message from Child Window"

def handle_return_value(value):
    print("Received value from Child Window:", value)

def create_parent_window():
    parent_window = tk.Tk()
    parent_window.title("Parent Window")

    btn_open_child = tk.Button(parent_window, text="Open Child Window", command=open_child_window)
    btn_open_child.pack()

    # 子窗口关闭后处理返回值
    parent_window.wait_variable(child_window)
    handle_return_value(child_window.get())

    parent_window.mainloop()

create_parent_window()

在这个示例中，我们定义了一个open_child_window函数，它创建了一个子窗口，并在子窗口中添加了一个标签和一个按钮。在按钮的回调函数中，我们调用了close_child_window函数来关闭子窗口，并返回了一个消息给父窗口。

在父窗口中，我们使用wait_variable函数等待子窗口关闭，并在关闭后调用handle_return_value函数来处理返回的消息。

回调函数

另一种与子窗口进行通信的方式是使用回调函数。我们可以定义一个回调函数，将其作为参数传递给子窗口，并在子窗口中执行特定的操作后调用该回调函数。下面是一个示例：

import tkinter as tk

def open_child_window(callback):
    child_window = tk.Toplevel()
    child_window.title("Child Window")

    # 在子窗口中添加一个按钮
    btn_child = tk.Button(child_window, text="Child Button", command=callback)
    btn_child.pack()

def handle_callback():
    print("Callback function called from Child Window!")

def create_parent_window():
    parent_window = tk.Tk()
    parent_window.title("Parent Window")

    # 创建按钮，点击按钮时打开子窗口，并传递回调函数
    btn_open_child = tk.Button(parent_window, text="Open Child Window", command=lambda: open_child_window(handle_callback))
    btn_open_child.pack()

    parent_window.mainloop()

create_parent_window()

在这个示例中，我们定义了一个open_child_window函数，它创建了一个子窗口，并在子窗口中添加了一个按钮。在按钮的回调函数中，我们调用了传递的回调函数。

在父窗口中，我们定义了一个handle_callback函数作为回调函数，在子窗口中执行特定的操作后，调用了这个回调函数。

全局变量

最后一种与父窗口通信的方式是使用全局变量。通过在父窗口和子窗口中共享全局变量，我们可以在它们之间传递信息。下面是一个示例：

import tkinter as tk

def open_child_window():
    child_window = tk.Toplevel()
    child_window.title("Child Window")

    # 在子窗口中添加一个按钮，点击按钮时修改全局变量的值
    btn_child = tk.Button(child_window, text="Child Button", command=update_global_variable)
    btn_child.pack()

def update_global_variable():
    global message
    message = "Updated message"

def handle_global_variable():
    print("Received value from Child Window:", message)

def create_parent_window():
    parent_window = tk.Tk()
    parent_window.title("Parent Window")

    btn_open_child = tk.Button(parent_window, text="Open Child Window", command=open_child_window)
    btn_open_child.pack()

    # 在父窗口中定义一个初始消息
    global message
    message = "Initial message"

    # 子窗口关闭后处理全局变量的值
    parent_window.wait_variable(child_window)
    handle_global_variable()

    parent_window.mainloop()

create_parent_window()

在这个示例中，我们定义了一个open_child_window函数，它创建了一个子窗口，并在子窗口中添加了一个按钮。在按钮的回调函数中，我们修改了全局变量message的值。

在父窗口中，我们定义了一个handle_global_variable函数，在子窗口关闭后处理全局变量的值。我们还在父窗口中定义了一个初始消息，并将其作为全局变量。