在 Tkinter 中切换两帧？

小开

最佳答案

一种方法是将帧叠加在一起，然后您可以简单地按照叠加顺序将一个帧叠加在另一个帧之上。上面那个是可见的。如果所有的框架都是相同的大小，这个工作最好，但只要一点点工作，你可以让它与任何大小的框架工作。

注意 : 要实现这一点，页面的所有小部件必须具有该页面(即: self)或作为父页面(或主页面，取决于您喜欢的术语)的后代。

Here's a bit of a contrived example to show you the general concept:

try:
import tkinter as tk                # python 3
from tkinter import font as tkfont  # python 3
except ImportError:
import Tkinter as tk     # python 2
import tkFont as tkfont  # python 2


class SampleApp(tk.Tk):


def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)


self.title_font = tkfont.Font(family='Helvetica', size=18, weight="bold", slant="italic")


# the container is where we'll stack a bunch of frames
# on top of each other, then the one we want visible
# will be raised above the others
container = tk.Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)


self.frames = {}
for F in (StartPage, PageOne, PageTwo):
page_name = F.__name__
frame = F(parent=container, controller=self)
self.frames[page_name] = frame


# put all of the pages in the same location;
# the one on the top of the stacking order
# will be the one that is visible.
frame.grid(row=0, column=0, sticky="nsew")


self.show_frame("StartPage")


def show_frame(self, page_name):
'''Show a frame for the given page name'''
frame = self.frames[page_name]
frame.tkraise()




class StartPage(tk.Frame):


def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
label = tk.Label(self, text="This is the start page", font=controller.title_font)
label.pack(side="top", fill="x", pady=10)


button1 = tk.Button(self, text="Go to Page One",
command=lambda: controller.show_frame("PageOne"))
button2 = tk.Button(self, text="Go to Page Two",
command=lambda: controller.show_frame("PageTwo"))
button1.pack()
button2.pack()




class PageOne(tk.Frame):


def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
label = tk.Label(self, text="This is page 1", font=controller.title_font)
label.pack(side="top", fill="x", pady=10)
button = tk.Button(self, text="Go to the start page",
command=lambda: controller.show_frame("StartPage"))
button.pack()




class PageTwo(tk.Frame):


def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
label = tk.Label(self, text="This is page 2", font=controller.title_font)
label.pack(side="top", fill="x", pady=10)
button = tk.Button(self, text="Go to the start page",
command=lambda: controller.show_frame("StartPage"))
button.pack()




if __name__ == "__main__":
app = SampleApp()
app.mainloop()

如果您发现在类中创建实例的概念令人困惑，或者如果不同的页在构造过程中需要不同的参数，您可以分别显式地调用每个类。循环主要用来说明每个类是相同的这一点。

例如，要单独创建类，可以删除循环(for F in (StartPage, ...):

self.frames["StartPage"] = StartPage(parent=container, controller=self)
self.frames["PageOne"] = PageOne(parent=container, controller=self)
self.frames["PageTwo"] = PageTwo(parent=container, controller=self)


self.frames["StartPage"].grid(row=0, column=0, sticky="nsew")
self.frames["PageOne"].grid(row=0, column=0, sticky="nsew")
self.frames["PageTwo"].grid(row=0, column=0, sticky="nsew")

随着时间的推移，人们已经使用这段代码(或复制这段代码的在线教程)作为出发点提出了其他问题。你可能想看看下面这些问题的答案:

小开

这里是另一个简单的答案，但不使用类。

from tkinter import *




def raise_frame(frame):
frame.tkraise()


root = Tk()


f1 = Frame(root)
f2 = Frame(root)
f3 = Frame(root)
f4 = Frame(root)


for frame in (f1, f2, f3, f4):
frame.grid(row=0, column=0, sticky='news')


Button(f1, text='Go to frame 2', command=lambda:raise_frame(f2)).pack()
Label(f1, text='FRAME 1').pack()


Label(f2, text='FRAME 2').pack()
Button(f2, text='Go to frame 3', command=lambda:raise_frame(f3)).pack()


Label(f3, text='FRAME 3').pack(side='left')
Button(f3, text='Go to frame 4', command=lambda:raise_frame(f4)).pack(side='left')


Label(f4, text='FRAME 4').pack()
Button(f4, text='Goto to frame 1', command=lambda:raise_frame(f1)).pack()


raise_frame(f1)
root.mainloop()

小开

注意 : 根据 JDN96，下面的答案可能通过反复破坏和重新创建帧而导致内存泄漏。然而，我还没有亲自测试来验证这一点。

在 tkinter中切换帧的一种方法是销毁旧的帧，然后用新的帧替换它。

我已经修改了布莱恩 · 奥克利的的答案，以摧毁旧的框架之前，更换它。作为额外的好处，这消除了对 container对象的需要，并允许您使用任何通用的 Frame类。

# Multi-frame tkinter application v2.3
import tkinter as tk


class SampleApp(tk.Tk):
def __init__(self):
tk.Tk.__init__(self)
self._frame = None
self.switch_frame(StartPage)


def switch_frame(self, frame_class):
"""Destroys current frame and replaces it with a new one."""
new_frame = frame_class(self)
if self._frame is not None:
self._frame.destroy()
self._frame = new_frame
self._frame.pack()


class StartPage(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
tk.Label(self, text="This is the start page").pack(side="top", fill="x", pady=10)
tk.Button(self, text="Open page one",
command=lambda: master.switch_frame(PageOne)).pack()
tk.Button(self, text="Open page two",
command=lambda: master.switch_frame(PageTwo)).pack()


class PageOne(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
tk.Label(self, text="This is page one").pack(side="top", fill="x", pady=10)
tk.Button(self, text="Return to start page",
command=lambda: master.switch_frame(StartPage)).pack()


class PageTwo(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
tk.Label(self, text="This is page two").pack(side="top", fill="x", pady=10)
tk.Button(self, text="Return to start page",
command=lambda: master.switch_frame(StartPage)).pack()


if __name__ == "__main__":
app = SampleApp()
app.mainloop()

< img src = “ https://i.stack.imgur.com/jqkOn.png”alt = “ Page one”/> < img src = “ https://i.stack.imgur.com/jqkOn.png”alt = “ Page one”/>

解释

switch_frame()通过接受任何实现 Frame的 Class 对象来工作。然后，该函数创建一个新框架来替换旧框架。

如果旧的 _frame存在，则删除它，然后用新的帧替换它。
其他添加了 .pack()的帧，如菜单栏，将不受影响。
可以与实现 tkinter.Frame的任何类一起使用。
窗口自动调整大小以适应新内容

版本历史

v2.3


- Pack buttons and labels as they are initialized


v2.2


- Initialize `_frame` as `None`.
- Check if `_frame` is `None` before calling `.destroy()`.


v2.1.1


- Remove type-hinting for backwards compatibility with Python 3.4.


v2.1


- Add type-hinting for `frame_class`.


v2.0


- Remove extraneous `container` frame.
- Application now works with any generic `tkinter.frame` instance.
- Remove `controller` argument from frame classes.
- Frame switching is now done with `master.switch_frame()`.


v1.6


- Check if frame attribute exists before destroying it.
- Use `switch_frame()` to set first frame.


v1.5


- Revert 'Initialize new `_frame` after old `_frame` is destroyed'.
- Initializing the frame before calling `.destroy()` results
in a smoother visual transition.


v1.4


- Pack frames in `switch_frame()`.
- Initialize new `_frame` after old `_frame` is destroyed.
- Remove `new_frame` variable.


v1.3


- Rename `parent` to `master` for consistency with base `Frame` class.


v1.2


- Remove `main()` function.


v1.1


- Rename `frame` to `_frame`.
- Naming implies variable should be private.
- Create new frame before destroying old frame.


v1.0


- Initial version.

小开

Perhaps a more intuitive solution would be to hide/unhide frames using the pack_forget method if you are using the pack geometry manager.

这里有一个简单的例子。

import tkinter as tk




class App:
def __init__(self, root=None):
self.root = root
self.frame = tk.Frame(self.root)
self.frame.pack()
tk.Label(self.frame, text='Main page').pack()
tk.Button(self.frame, text='Go to Page 1',
command=self.make_page_1).pack()
self.page_1 = Page_1(master=self.root, app=self)


def main_page(self):
self.frame.pack()


def make_page_1(self):
self.frame.pack_forget()
self.page_1.start_page()




class Page_1:
def __init__(self, master=None, app=None):
self.master = master
self.app = app
self.frame = tk.Frame(self.master)
tk.Label(self.frame, text='Page 1').pack()
tk.Button(self.frame, text='Go back', command=self.go_back).pack()


def start_page(self):
self.frame.pack()


def go_back(self):
self.frame.pack_forget()
self.app.main_page()




if __name__ == '__main__':
root = tk.Tk()
app = App(root)
root.mainloop()