前言

本章节主要讲解了Tkinter中的Frame容器控件的参数使用。
本系列的所有文章会进行文章内容的纠错、补充和文章结构的改变，并不是一成不变的，但文章的大体会保持一致，如何您在阅读本系列文章中发现了错误或者对文章内容和结构有好的建议，欢迎留言。

学习资源

Tkinter基础知识

名称 说明 链接
GeeksforGeeks 一个类似于菜鸟教程的资源网站，但内容与菜鸟教程还是有些区别，右侧链接直达tkiner教程 Python Tkinter - GeeksforGeeks
菜鸟教程 菜鸟教程有tkinter教程，但只是简单介绍了一下并不全面，推荐使用GeeksforGeeks网站中的教程 菜鸟教程-tkinter
菜鸟鸭 对于tkiner中的控件介绍比较全面，也有示例代码 Python 3 - Tkinter
Python官网 简单介绍了tkiner及其控件，也有案例代码，但介绍的并不全面, 可以结合GeeksforGeeks和菜鸟鸭里的教程学习 Tk图形用户界面(GUI) — Python 3.13.5 文档
C语言程序网 这个网站中有tkinter的常用控件教程，也比较详细，也有案例，但没有ttk的控件教程 Tkinter教程（非常详细） - C语言中文网
Tcl/Tk Python的Tkinter是基于Tcl/Tk开发的， Python的Tkinter控件的参数及也可以参考Tcl/Tk 的官方文档 https://www.tcl-lang.org/man/tcl8.6/TkCmd/contents.htm
Tkinter教程 来自微信公众我的Python教程，简单介绍了Tkinter的使用，主要是使用Tkinter结合其他Python模块开发的GUI程序，适合有一定Tkinter基础的用户。 https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzI5OTc0NDQwNQ==&action=getalbum&album_id=3031632336204857351&scene=21#wechat_redirect

Tkinter可视化工具

名称 说明 链接
Tkinter布局助手 一款为tkinter开发的可视化网页端工具，可以拖拽组件进行布局，然后导出相应的py代码，而且最重要的是它在B站有相应的教学视频 Tkinter布局助手 或者直接通过这个链接打开https://www.pytk.net/
PyMe PyMe是一个桌面端的tkinter可视化拖曳工具，在B站也有相应的教学视频，教的不是最新版本的PyMe，但功能都差不多一样 https://www.py-me.com
Pygubu Designer Pygubu Designer也是一个为tkinter设计的可视化工具，是一个Python的第三方库，安装很方便，但同时要安装pygubu，因为导出的ui需要通过pygubu加载，它安装命令为pip install pygubu pygubu-designer，Pygubu Designer不是拖曳式的，没有Tkinter布局助手方面，而且文档也不多，需要花时间去实践。 https://github.com/alejandroautalan/pygubu-designer 或者pygubu-designer · PyPI

Tkinter第三方扩展库

名称 说明 链接
maliang 一个基于 tkinter 且控件都由 Canvas 绘制的轻量级 UI 框架 项目主页 - maliang
ttkbootstrap tkinter的超强主题扩展，可实现受Bootstrap启发的按需现代平面风格主题。 ttkbootstrap - ttkbootstrap
CustomTkinter 一个基于tkinter的现代化和可自定义化的Ui扩展库 https://customtkinter.tomschimansky.com/

Tkinter组件关系图

在这里插入图片描述

第九章 Frame-框架控件-容器控件

9-1 控件说明

1.作用

Frame（框架）是 Tkinter 中最基础的容器控件，主要作用包括：

  • 布局管理：作为其他控件的 “容器”，将界面划分为逻辑区域，便于通过 pack()/grid()/place() 等方法统一管理内部控件的布局，避免界面结构混乱。
  • 功能分组：将功能相关的控件（如按钮组、输入框组）归类到同一个 Frame 中，使界面层次清晰，增强可读性和可维护性。
  • 样式隔离：可单独设置 Frame 的背景色、边框、内边距等样式，实现不同区域的视觉区分（如用边框分隔不同功能模块）。
  • 动态控制：通过控制 Frame 的显示 / 隐藏（pack_forget()/grid_remove()）或销毁，实现界面模块的动态切换（如多标签页内容切换）。

2.应用场景

  • 复杂界面分区划分：在大型界面中，用多个 Frame 将界面划分为导航区、内容区、操作区等，例如：

    • 软件主界面中，顶部 Frame 放标题和菜单，左侧 Frame 放功能导航，右侧 Frame 放主要内容。

  • 功能模块封装：将一组相关控件（如 “用户信息” 模块的姓名、年龄输入框 + 提交按钮）放在同一个 Frame 中，便于整体移动或隐藏，例如：

    • 表单界面中，用 Frame 封装 “个人基本信息”“联系方式” 等独立模块。

  • 样式区分区域：通过 Frame 的边框（relief）和背景色（bg）突出重要区域，例如：

    • 数据展示界面中，用带边框的 Frame 包裹图表和统计数据，与其他区域形成视觉区分。

  • 动态界面切换：在同一个位置通过切换不同 Frame 的显示状态，实现类似 “标签页” 的效果，例如：

    • 设置界面中，点击不同选项卡，显示对应的 Frame（包含该选项的具体设置控件）。

  • 嵌套布局支持：Frame 可嵌套其他 Frame，实现多层级布局，适应复杂界面结构，例如：

    • 多层级表单中，外层 Frame 按 “模块” 划分，内层 Frame 按 “行 / 列” 管理具体输入控件。

  • 示例

    案例来源：https://mp.weixin.qq.com/s/Q_oI1hENPuIz4rj-LE40Ng

    运行环境：Python3.9+

    在这里插入图片描述

    import tkinter as tk
from tkinter import ttk

class ResponsiveFrame:
    def __init__(self):
        self.__root = tk.Tk()
        self.__root.title("Frame控件示例")
        self.__root.geometry("1000x800")
        self.__root.minsize(600, 400)
        
        self.create_responsive_layout()
        self.bind_events()
        
    def create_responsive_layout(self):
        """创建布局"""
        # 主容器
        main_container = tk.Frame(self.__root)
        main_container.pack(fill="both", expand=True, padx=10, pady=10)
        
        # 头部区域
        self.header_frame = tk.Frame(main_container, bg="#34495E", height=100)
        self.header_frame.pack(fill="x", pady=(0, 10))
        self.header_frame.pack_propagate(False)
        
        tk.Label(self.header_frame, text="系统控制面板",
                 fg="white", bg="#34495E",
                 font=("微软雅黑", 18, "bold")).pack(expand=True)
        
        # 中间可分割区域
        self.paned_window = tk.PanedWindow(main_container, orient="horizontal",
                                           sashwidth=10)
        self.paned_window.pack(fill="both", expand=True)
        
        # 左侧导航区
        self.nav_frame = tk.Frame(self.paned_window, bg="#ECF0F1", width=200)
        self.create_navigation()
        self.paned_window.add(self.nav_frame, minsize=150)
        
        # 右侧内容区
        self.content_frame = tk.Frame(self.paned_window, bg="white")
        self.create_content_area()
        self.paned_window.add(self.content_frame, minsize=400)
        
    def create_navigation(self):
        """创建导航区域"""
        nav_items = [
            "数据管理",
            "系统设置",
            "表分析",
            "工具箱",
            "关于系统",
            ]
        
        tk.Label(self.nav_frame, text="导航菜单",
                 bg="#ECF0F1",
                 font=("微软雅黑", 14, "bold")).pack(pady=20)
        
        for item in nav_items:
            btn = tk.Button(self.nav_frame, text=item,
                            font=("微软雅黑", 11),
                            bg="#3498DB",
                            fg="white",
                            relief="flat",
                            cursor="hand2")
            btn.pack(fill="x", padx=20, pady=5)
        
            # 鼠标悬停效果
            def on_enter(e, button=btn):
                button.config(bg="#2980B9")
            
            def on_leave(e, button=btn):
                button.config(bg="#3498DB")
            
            btn.bind("<Enter>", on_enter)
            btn.bind("<Leave>", on_leave)
        
    def create_content_area(self):
        """创建内容显示区域"""
        # 内容标题
        title_frame = tk.Frame(self.content_frame,
                               bg="#2C3E50",
                               height=50)
        title_frame.pack(fill="x")
        title_frame.pack_propagate(False)
        
        tk.Label(title_frame, text="主要工作区域",
                 fg="white",
                 bg="#2C3E50",
                 font=("微软雅黑", 14)).pack(side="left",
                                         padx=20, pady=10)
        # 动态内容容器
        self.dynamic_content = tk.Frame(self.content_frame, bg="white")
        self.dynamic_content.pack(fill="both", expand=True, padx=20, pady=20)
        
        # 示例内容：可滚动的表格
        self.create_scrollabel_table()
    
    def create_scrollabel_table(self):
        table_frame = tk.Frame(self.dynamic_content)
        table_frame.pack(fill="both", expand=True)
        
        columns = ("ID","名称","类型","状态","创建时间","操作")
        self.tree=ttk.Treeview(table_frame,columns=columns,show="headings")
        column_widths = {"ID":80,"名称":150,"类型":100,"状态":80,"创建时间":180,"操作":100}
        
        for col in columns:
            self.tree.heading(col, text=col)
            self.tree.column(col, width=column_widths.get(col, 100))
        
        v_scrollbar = ttk.Scrollbar(table_frame, orient="vertical",
                                    command=self.tree.yview)
        h_scrollbar = ttk.Scrollbar(table_frame, orient="horizontal",
                                    command=self.tree.xview)
        
        self.tree.configure(yscrollcommand=v_scrollbar.set,
                            xscrollcommand=h_scrollbar.set)
        
        self.tree.grid(row=0, column=0, sticky="nsew")
        v_scrollbar.grid(row=0, column=1, sticky="ns")
        h_scrollbar.grid(row=1, column=0, sticky="ew")
        
        table_frame.grid_rowconfigure(0, weight=1)
        table_frame.grid_columnconfigure(0, weight=1)
        
    
        sample_data = [
            (f"00{i}", f"设备{i}", "传感器", "运行中", "2024-01-25 10:30", "编辑")
            for i in range(1, 21)
            ]
        for data in sample_data:
            self.tree.insert("", "end", values=data)
            
    def bind_events(self):
        """绑定窗口事件"""
        self.__root.bind("<Configure>", self.on_window_resize)
    
    def on_window_resize(self, event):
        """窗口大小改变时的处理"""
        if event.widget == self.__root:
            width = self.__root.winfo_width()
            if width < 800:
                if self.nav_frame in self.paned_window.panes():
                    self.paned_window.forget(self.nav_frame)
            else:
                if self.nav_frame not in self.paned_window.panes():
                    self.paned_window.add(self.nav_frame, before=self.content_frame)
        
    def run(self):
        self.__root.mainloop()
        
if __name__ == "__main__":
    app = ResponsiveFrame()
    app.run()

9-2 Frame的使用

1.Frame的创建语法格式

(1)使用tkinter创建Frame控件的语法格式

注:master是父窗口, options是其他参数

tkFrame = tkinter.Frame(master=None, options, ...)

(2)使用tkinter.ttk创建Frame控件的语法格式

注:master是父窗口, options是其他参数

ttkFrame = ttk.Frame(master=None, options, ...)

2.Frame构造方法内的参数说明

(1)tkinter.Frame的参数详解

参数名称 参数作用 参数数据类型 传参示例
master 指定当前 Frame 的父容器（必须参数，决定 Frame 显示在哪个控件内）。 tkinter.Tk 或其他控件 master=root（root 是 Tk () 实例）
cnf 以字典形式传入其他参数（较少用，通常直接传关键字参数）。 dict cnf={'bg': 'white', 'width': 200}
bg / background 设置 Frame 的背景颜色（支持颜色名称如 'red' 或十六进制如 '#ff0000'）。 str bg='lightblue' 或 background='#f0f0f0'
bd /border/ borderwidth 设置 Frame 的边框宽度（单位：像素，默认 0 即无边框）。 int bd=2 或 borderwidth=3
class_ 指定 Frame 的类名（用于 Tk 样式管理，一般无需修改）。 str class_='CustomFrame'
colormap 指定颜色映射（仅在某些平台有效，通常用默认值）。 str colormap=''
container 若为 True，表示 Frame 作为其他顶级窗口的容器（用于 tkinter.Toplevel）。 bool container=True
cursor 设置鼠标悬停在 Frame 上时的光标样式（如 'arrow'、'hand2' 等）。 str cursor='hand2'
height 设置 Frame 的高度（单位：像素，默认根据内容自适应）。 int height=300
width 设置 Frame 的宽度（单位：像素，默认根据内容自适应）。 int width=400
highlightbackground 设置 Frame 未获得焦点时的高亮边框颜色。 str highlightbackground='gray'
highlightcolor 设置 Frame 获得焦点时的高亮边框颜色。 str highlightcolor='blue'
highlightthickness 设置高亮边框的宽度（单位：像素，0 表示不显示高亮边框）。 int highlightthickness=1
padx 设置 Frame 水平方向的内边距（控件与边框的间距，单位：像素）。 str padx=10
pady 设置 Frame 垂直方向的内边距（控件与边框的间距，单位：像素）。 str pady=5
relief 设置 Frame 的边框样式（如 'flat' 平边、'ridge' 脊状、'sunken' 凹陷等）。 str relief='ridge'
takefocus 若为 True，表示 Frame 可通过 Tab 键获得焦点（默认 False）。 bool takefocus=True

(2)ttk.Frame的参数详解

参数名称 参数作用 参数数据类型 传参示例
master 指定 ttk.Frame 的父容器（决定其显示位置，如主窗口或其他控件） Misc/None(Misc指 Tkinter 控件对象，如Tk()、Frame 等；None 表示无父容器，极少使用） master=root（root 为 Tk() 实例）
bd/border 设置边框宽度（与 borderwidth 功能相同，单位：像素） str/float border=2
borderwidth 设置边框宽度（完整参数名，与 border 功能相同，控制边框粗细） str/float borderwidth=3
class_ 控件的类名（用于样式管理，默认继承 TFrame 类，自定义样式时可能需要修改） str class_=‘CustomFrame’
cursor 设置鼠标悬停在 Frame 上时的光标样式 str cursor=‘hand2’
height 设置 Frame 的高度（单位：像素，默认 0 表示自适应内容高度） str/float height=300，
width 设置 Frame 的宽度（单位：像素，默认 0 表示自适应内容宽度） str/float width=400
name 控件的内部名称（用于 Tk 内部管理和样式关联，一般无需手动设置） str name=‘frame_1’
padding 设置内边距（控件内容与边框的间距，支持多方向灵活设置） str/float/元组 padding=10、padding=(5, 10)、padding=(2,4,6,8)
relief 设置边框样式（控制边框的视觉效果） Literal["raised", "sunken", "flat", "ridge", "solid", "groove"]（raised 凸起、sunken 凹陷、flat 扁平、ridge 脊状、solid 实线、groove 凹槽） relief=‘ridge’
style 应用自定义样式（需通过 ttk.Style 预先定义样式规则） str style=‘MyFrame.TFrame’
takefocus 控制 Frame 是否可通过 Tab 键获得焦点（影响键盘导航） Literal[0, 1, “”]/bool takefocus=True，True 可获得焦点，False不可，""自动判断

补充说明：

  1. 参数关联性：border 与 borderwidth 是等效参数，仅名称不同，功能完全一致；
  2. padding 灵活性：
    • 单值（如 padding=10）：四边内边距均为 10 像素；
    • 双值（如 padding=(5, 10)）：上下内边距 5 像素，左右内边距 10 像素；
    • 四值（如 padding=(2,4,6,8)）：上、右、下、左内边距分别为 2、4、6、8 像素；
  3. 样式管理：style 参数需配合 ttk.Style 使用，例如先定义 style.configure("MyFrame.TFrame", ...)，再通过 style="MyFrame.TFrame" 应用到 Frame 上，实现主题统一。

3.Frame控件类的方法

注：下面的方法本文档并没有在案例中全部使用，目前可以参考一下，具体效果以实际的代码执行效果为准(毕竟实践出真知嘛😃😃，后续会加入使用控件方法的案例加油表情包 ，敬请期待)

方法名 方法的作用说明 方法参数和参数类型
after 给定时间后调用一次函数 ms（整数）、func（函数，可选）、*args（可变参数）
after_cancel 取消由 ID 标识的函数调度 id（调度标识）
after_idle 当 Tcl 主循环无事件处理时，调用一次函数 func（函数）、*args（可变参数）
anchor 当没有行 / 列有权重时，控制网格在主窗口中的放置方式 anchor（可选参数，指定锚点位置）
bbox 返回由网格几何管理器控制的此控件边界框的整数坐标元组 column（可选，列索引）、row（可选，行索引）、col2（可选，结束列索引）、row2（可选，结束行索引）
bell 触发显示器的提示音 displayof（整数，默认 0）
bind 为控件绑定事件序列，触发时调用指定函数 sequence（事件序列，可选）、func（函数，可选）、add（布尔值，可选）
bind_all 为所有控件绑定事件序列，触发时调用指定函数 sequence（事件序列，可选）、func（函数，可选）、add（布尔值，可选）
bind_class 为具有指定绑定标签的控件绑定事件序列，触发时调用指定函数 className（类名）、sequence（事件序列，可选）、func（函数，可选）、add（布尔值，可选）
bindtags 设置或获取此控件的绑定标签列表 tagList（标签列表，可选）
cget 返回指定键对应的资源值 key（字符串，资源键名）
clipboard_append 将字符串追加到 Tk 剪贴板 string（字符串）、**kw（关键字参数）
clipboard_clear 清空 Tk 剪贴板中的数据 **kw（关键字参数）
clipboard_get 从窗口显示器的剪贴板中检索数据 **kw（关键字参数）
columnconfigure 配置网格的指定列 index（列索引）、cnf（字典，配置选项）、**kw（关键字参数）
config 配置控件的资源 cnf（字典，可选）、**kw（关键字参数）
configure 配置控件的资源 cnf（字典，可选）、**kw（关键字参数）
deletecommand 内部函数 name（参数，具体用途未明确）
destroy 销毁此控件及其所有子控件 无参数
event_add 将虚拟事件绑定到事件序列，当序列触发时虚拟事件也触发 virtual（虚拟事件名，格式 <>）、*sequences（事件序列，多个）
event_delete 取消虚拟事件与指定事件序列的绑定 virtual（虚拟事件名）、*sequences（事件序列，多个）
event_generate 生成指定的事件序列，可指定事件参数 sequence（事件序列）、**kw（关键字参数，如 x、y 等事件参数）
event_info 返回所有虚拟事件列表，或指定虚拟事件绑定的序列信息 virtual（虚拟事件名，可选）
focus 将输入焦点定向到此控件 无参数
focus_displayof 返回此控件所在显示器上当前拥有焦点的控件 无参数
focus_force 即使应用程序没有焦点，也将输入焦点定向到此控件（谨慎使用） 无参数
focus_get 返回应用程序中当前拥有焦点的控件 无参数
focus_lastfor 返回如果此控件的顶级窗口从窗口管理器获得焦点，将拥有焦点的控件 无参数
focus_set 将输入焦点定向到此控件 无参数
forget 取消控件的映射，不再用于打包顺序 无参数
getboolean 将 Tcl 的布尔值（true/false）转换为 Python 布尔值 s（字符串，Tcl 布尔值）
getdouble 将输入转换为双精度浮点数 s（字符串或数值，待转换值）
getint 将输入转换为整数 s（字符串或数值，待转换值）
getvar 返回指定 Tcl 变量的值 name（字符串，变量名，默认 ‘PY_VAR’）
grab_current 返回此应用程序中当前拥有抓取权的控件，无则返回 None 无参数
grab_release 如果当前已设置，释放此控件的抓取权 无参数
grab_set 为此控件设置抓取权 无参数
grab_set_global 为此控件设置全局抓取权 无参数
grab_status 返回此控件的抓取状态：None（无）、“local”（本地）或 “global”（全局） 无参数
grid 以网格布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 column、row、sticky 等）
grid_anchor 当没有行 / 列有权重时，控制网格在主窗口中的放置方式 anchor（可选参数，指定锚点位置）
grid_bbox 返回由网格几何管理器控制的此控件边界框的整数坐标元组 column（可选，列索引）、row（可选，行索引）、col2（可选，结束列索引）、row2（可选，结束行索引）
grid_columnconfigure 配置网格的指定列 index（列索引）、cnf（字典，配置选项）、**kw（关键字参数）
grid_configure 以网格布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 column、row、sticky 等）
grid_forget 取消控件的映射 无参数
grid_info 返回此控件网格布局的选项信息 无参数
grid_location 返回父控件中指定像素位置（x,y）对应的列和行索引元组 x（整数，像素 x 坐标）、y（整数，像素 y 坐标）
grid_propagate 设置或获取几何信息传播的状态 flag（可选参数，布尔值或 [‘noarg’]）
grid_remove 取消控件的映射，但保留网格布局选项 无参数
grid_rowconfigure 配置网格的指定行 index（行索引）、cnf（字典，配置选项）、**kw（关键字参数）
grid_size 返回网格中的列数和行数元组 无参数
grid_slaves 返回此控件的所有子控件列表（按打包顺序） row（可选，行索引）、column（可选，列索引）
image_names 返回所有现有图像的名称列表 无参数
image_types 返回所有可用的图像类型列表（如 photo、bitmap） 无参数
info 返回此控件打包布局的选项信息 无参数
keys 返回此控件的所有资源名称列表 无参数
lift 提升此控件在堆叠顺序中的层级 aboveThis（可选，指定在某个控件之上）
location 返回父控件中指定像素位置（x,y）对应的列和行索引元组 x（整数，像素 x 坐标）、y（整数，像素 y 坐标）
lower 降低此控件在堆叠顺序中的层级 belowThis（可选，指定在某个控件之下）
mainloop 调用 Tk 的主循环 n（整数，默认 0）
nametowidget 通过 Tcl 名称返回对应的 Tkinter 控件实例 name（字符串，Tcl 控件名称）
option_add 为指定选项模式设置值 pattern（字符串，选项模式）、value（值）、priority（可选，优先级）
option_clear 清空选项数据库 无参数
option_get 返回此控件指定类的指定选项的值 name（字符串，选项名）、className（字符串，类名）
option_readfile 将文件读取到选项数据库 fileName（字符串，文件路径）、priority（可选，优先级）
pack 以打包布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 side、fill、padx 等）
pack_configure 以打包布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 side、fill、padx 等）
pack_forget 取消控件的映射，不再用于打包顺序 无参数
pack_info 返回此控件打包布局的选项信息 无参数
pack_propagate 设置或获取几何信息传播的状态 flag（可选参数，布尔值或 [‘noarg’]）
pack_slaves 返回此控件的所有子控件列表（按打包顺序） 无参数
place 以绝对定位布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 x、y、width、relx 等）
place_configure 以绝对定位布局在父控件中放置控件 cnf（字典，配置选项）、**kw（关键字参数，如 x、y、width、relx 等）
place_forget 取消控件的映射 无参数
place_info 返回此控件绝对定位布局的选项信息 无参数
place_slaves 返回此控件的所有子控件列表（按放置顺序） 无参数
propagate 设置或获取几何信息传播的状态 flag（可选参数，布尔值或 [‘noarg’]）
quit 退出 Tcl 解释器，所有控件将被销毁 无参数
register 创建新的 Tcl 函数，调用该函数时将执行指定的 Python 函数 func（Python 函数）、subst（可选，执行 func 前的替换函数）、needcleanup（整数，默认 1）
rowconfigure 配置网格的指定行 index（行索引）、cnf（字典，配置选项）、**kw（关键字参数）
selection_clear 清空当前的 X 选择内容 **kw（关键字参数）
selection_get 返回当前 X 选择的内容 **kw（关键字参数）
selection_handle 指定当此控件拥有的 X 选择被其他应用程序查询时调用的函数 command（函数）、**kw（关键字参数）
selection_own 成为 X 选择的所有者 **kw（关键字参数）
selection_own_get 返回 X 选择的所有者 无参数
send 向不同的解释器发送 Tcl 命令执行 interp（解释器名）、cmd（Tcl 命令）、*args（可变参数）
setvar 将指定 Tcl 变量设置为指定值 name（字符串，变量名，默认 ‘PY_VAR’）、value（值，默认 ‘1’）
size 返回网格中的列数和行数元组 无参数
slaves 返回此控件的所有子控件列表（按打包顺序） 无参数
tk_bisque 将配色方案更改为 Tk 3.6 及之前版本使用的浅棕色 无参数
tk_focusFollowsMouse 鼠标悬停的控件将自动获得焦点（难以禁用） 无参数
tk_focusNext 返回焦点顺序中当前拥有焦点控件的下一个控件 无参数
tk_focusPrev 返回焦点顺序中当前拥有焦点控件的上一个控件 无参数
tk_setPalette 为所有控件元素设置新的配色方案 *args（可变参数）、**kw（关键字参数）
tk_strictMotif 设置 Tcl 内部变量，控制外观是否遵循 Motif 风格 boolean（布尔值，可选）
tkraise 提升此控件在堆叠顺序中的层级 aboveThis（可选，指定在某个控件之上）
unbind 取消此控件指定事件序列的绑定函数 sequence（事件序列）、funcid（可选，函数标识）
unbind_all 取消所有控件指定事件序列的所有绑定函数 sequence（事件序列）
unbind_class 取消所有具有指定绑定标签的控件指定事件序列的所有绑定函数 className（类名）、sequence（事件序列）
update 进入事件循环，直到所有挂起的事件被 Tcl 处理完毕 无参数
update_idletasks 进入事件循环，直到所有空闲回调被调用（仅更新窗口显示，不处理用户触发事件） 无参数
wait_variable 等待指定变量被修改 name（字符串，变量名，默认 ‘PY_VAR’）
wait_visibility 等待控件的可见性发生变化（如显示） window（可选，指定控件）
wait_window 等待指定控件被销毁 window（可选，指定控件）
waitvar 等待指定变量被修改 name（字符串，变量名，默认 ‘PY_VAR’）
winfo_atom 返回指定原子名称对应的整数值 name（字符串，原子名称）、displayof（整数，默认 0）
winfo_atomname 返回指定标识符对应的原子名称 id（整数，原子标识符）、displayof（整数，默认 0）
winfo_cells 返回此控件的颜色映射中的单元数 无参数
winfo_children 返回此控件的所有子控件列表 无参数
winfo_class 返回此控件的窗口类名 无参数
winfo_colormapfull 如果上次颜色请求时颜色映射已满，返回 True 无参数
winfo_containing 返回根坐标（ROOTX, ROOTY）处的控件 rootX（整数，根窗口 x 坐标）、rootY（整数，根窗口 y 坐标）、displayof（整数，默认 0）
winfo_depth 返回每个像素的位数 无参数
winfo_exists 如果此控件存在，返回 True 无参数
winfo_fpixels 返回指定距离（如 “3c”）对应的像素数（浮点数） number（字符串或数值，距离值）
winfo_geometry 返回此控件的几何信息字符串，格式为 “widthxheight+X+Y” 无参数
winfo_height 返回此控件的高度 无参数
winfo_id 返回此控件的标识符 ID 无参数
winfo_interps 返回此显示器的所有 Tcl 解释器名称 displayof（整数，默认 0）
winfo_ismapped 如果此控件已映射（显示），返回 True 无参数
winfo_manager 返回此控件的窗口管理器名称 无参数
winfo_name 返回此控件的名称 无参数
winfo_parent 返回此控件的父控件名称 无参数
winfo_pathname 返回指定标识符对应的控件路径名 id（整数，控件标识符）、displayof（整数，默认 0）
winfo_pixels 返回 winfo_fpixels 的四舍五入整数结果 number（字符串或数值，距离值）
winfo_pointerx 返回鼠标指针在根窗口中的 x 坐标 无参数
winfo_pointerxy 返回鼠标指针在根窗口中的 x 和 y 坐标元组 无参数
winfo_pointery 返回鼠标指针在根窗口中的 y 坐标 无

9-3 案例

1.tkinter.Frame的参数使用

  • master参数：指定当前 Frame 的父容器（必须参数，决定 Frame 显示在哪个控件内）

    bg/background参数：设置 Frame 的背景颜色（支持颜色名称如 'red' 或十六进制如 '#ff0000'）。

    import tkinter as tk
from tkinter import colorchooser
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
        
def choose_color():
    """
    设置Frame背景的函数
    在第一章的时候讲过colorchooser(颜色选择器),
    colorchooser模块的askcolor()可以用来选择颜色,
    askcolor方法返回一个元组,
    它可能的返回值有:(None,None)表示没有选择颜色,
    ((r, g, b), ('hex')),
    (r, g, b)表示rgb值
    ('hex')表示16进行的颜色表示
    示例:((255, 255, 255), '#ffffff')
    """
    color_rgb, color_hex = color = colorchooser.askcolor()
    print(color)
    # 选择了颜色，设置Frmae控件背景颜色
    if color_hex:
        frame.config(background=color_hex)
    
if __name__ == "__main__":
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    # 创建Frame控件
    frame = tk.Frame(root, background="#010201")
    frame.pack(fill="both", expand=True)
    
    btn = tk.Button(frame, text="请选择颜色", command=choose_color)
    btn.pack(side="bottom")
    
    root.mainloop()

    在这里插入图片描述

  • cnf参数：以字典形式传入其他参数（较少用，通常直接传关键字参数）。

    cursor参数：设置鼠标悬停在 Frame 上时的光标样式（如 'arrow'、'hand2' 等）

    import tkinter as tk
from tkinter import colorchooser
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "#010201"    
        
def choose_color():
    """
    设置Frame背景的函数
    在第一章的时候讲过colorchooser(颜色选择器),
    colorchooser模块的askcolor()可以用来选择颜色,
    askcolor方法返回一个元组,
    它可能的返回值有:(None,None)表示没有选择颜色,
    ((r, g, b), ('hex')),
    (r, g, b)表示rgb值
    ('hex')表示16进行的颜色表示
    示例:((255, 255, 255), '#ffffff')
    """
    color_rgb, color_hex = color = colorchooser.askcolor()
    print(color)
    # 选择了颜色，设置Frmae控件背景颜色
    if color_hex:
        frame.config(background=color_hex)
    
if __name__ == "__main__":
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    # 创建Frame控件
    frame = tk.Frame(root, cnf={
        # 设置Frame控件的背景颜色
        'background': Settings.background,
        # 设置当鼠标移动到Frame控件的鼠标样式
        'cursor': 'hand2'
        })
    frame.pack(fill="both", expand=True)
    
    btn = tk.Button(frame, text="请选择颜色", command=choose_color)
    btn.pack(side="bottom")
    
    root.mainloop()

    在这里插入图片描述

  • bd/border/borderwidth:设置 Frame 的边框宽度（单位：像素，默认 0 即无边框）

    width参数：设置 Frame 的宽度（单位：像素，默认 0 表示自适应内容宽度）

    height参数：设置 Frame 的高度（单位：像素，默认根据内容自适应）。

    relief参数: 设置 Frame 的边框样式（如 'flat' 平边、'ridge' 脊状、'sunken' 凹陷等）。

    注：这里你可能会困惑为啥我要把这四个参数放在一起，那是因为本来只讲解bd/border/borderwidth,但当我只设置了边框这个参数时(frame = tk.Frame(bd=10))，并没出现我预期的效果，经过不断地实践，我发现想要显示出边框地效果，就还需要设置width、height、relief这三个参数。下面是我对bd使用地总结：

    1.注意Frame控件地默认宽高为0，背景颜色为系统颜色

    2…要想看到设置的边框宽度效果，就不能设置relief为flat,要设置成groove, raised, ridge, solid, or sunken(任选其一)

    3.注意Frame布局的参数使用

    ​ 以pack布局为例：

    • 如果是Frame.pack()，并且里面没有子控件,这时想要看见Frame,就要设置Frame的width、height和background参数
    • 如果是Frame.pack(fill=“both”, expand=True), 并且里面没有子控件, 这时想要看见Frame,就要设置background参数
    • 如果是Frame.pack(fill=“x”), 并且设置了背景颜色，这时可以看见Frame是一条水平的细线,
    • 如果是Frame.pack(fill=“y”, expand=True), 并且设置了背景颜色，这时可以看见Frame是一条垂直的细线
    import tkinter as tk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        
    
if __name__ == "__main__":
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    # 创建Frame控件
    frame1 = tk.Frame(root,
                      width=100,
                      height=100,
                      background=Settings.background,
                      border=10)
    frame1.pack(pady=20)
    
    # 创建Frame控件
    frame2 = tk.Frame(root,
                      width=100,
                      height=100,
                      background=Settings.background,
                      borderwidth=10,
                      relief="raised")
    frame2.pack(pady=20)

    root.mainloop()

    在这里插入图片描述

  • highlightbackground参数：设置 Frame 未获得焦点时的高亮边框颜色。
    highlightcolor参数：设置 Frame 获得焦点时的高亮边框颜色。
    highlightthickness参数：设置高亮边框的宽度（单位：像素，0 表示不显示高亮边框）。
    takefocus参数：若为 True，表示 Frame 可通过 Tab 键获得焦点（默认 False）。

    注：想要看见高亮边框，第一步先设置highlightthickness参数，然后再设置highlightbackground和highlightcolor参数，最后我们设置takckfocus参数为True,这样就可以获得焦点，看见Frame 获得焦点时的高亮边框颜色。

    import tkinter as tk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        
    
if __name__ == "__main__":
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    # 创建Frame控件
    frame = tk.Frame(root,
                  width=100,
                  height=100,
                  highlightcolor="yellow",
                  highlightthickness=5,
                  highlightbackground="purple",
                  takefocus=True)
    frame.pack(pady=20)

    root.mainloop()

    在这里插入图片描述

在这里插入图片描述

  • padx参数：设置 Frame 水平方向的内边距（控件与边框的间距，单位：像素）。

    pady参数：设置 Frame 垂直方向的内边距（控件与边框的间距，单位：像素）。

    在下面的示例代码中，我们设置padx参数(水平内边距); pady同理，只不过时设置的垂直方向上的内边距。

    import tkinter as tk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def run():
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    # 创建Frame控件,这个Frame控件不放入任何控件
    frame = tk.Frame(root,
                     width=50,
                     height=50,
                     background=Settings.background,
                      )
    frame.pack(pady=(10, 0))
    
    # 创建Frame控件
    frame1 = tk.Frame(root,
                      width=50,
                      height=50,
                      background=Settings.background,
                      )
    # 创建一个按钮放入到frame1中
    btn1 = tk.Button(frame1, text="button1")
    btn1.pack()
    frame1.pack(pady=(10, 0))
        
    
    frame2 = tk.Frame(root,
                      width=50,
                      height=50,
                      background=Settings.background,
                      # 设置 Frame 水平方向的内边距（控件与边框的间距，单位：像素）
                      padx=10
                      )
    # 创建一个按钮放入到frame2中
    btn2 = tk.Button(frame2, text="button2")
    btn2.pack()
    frame2.pack(pady=(10, 0))
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

    图片上面的话，可能还是有点迷惑，可能大家知道了Frame的宽高会受它里面的子控件影响，但还是不太清楚，所以我又总结了一下。

    Frame使用的注意点：

    当Frame不设置width值并且Frame在布局时没有设置可拉伸的参数时，
Frame容器的宽高就由它里面的控件宽高决定,而且当Frame和它里面的
控件同时设置了背景色,控件的背景色会覆盖Frame的背景色,这是因为
在Tkinter中,Frame默认会缩小以适应其子控件的大小，这是由 
pack_propagate(True) 控制的默认行为.

当你希望可以显示出Frame的背景色,又可以显示出Frame控件中的背景色时,
一种方法是设置Frame的布局参数fill和expand,另一种方式是设置Frame控件对象
的pack_propagate方法为False


1.pack_propagate(True) 的默认行为
    作用：
        当pack_propagate(True)（默认值）时，
        Frame会自动调整自己的尺寸（width 和 height）以刚好容纳所有子控件。
    后果：
        即使你显式设置了Frame的width和height（如 width=300, height=300），
        这些值也会被子控件的实际大小覆盖。如果子控件很小（如一个 Label 只显示短文本），
        Frame会缩小到比预期更小的尺寸。
    
2.pack_propagate关键注意事项
    子控件的布局影响：
        即使设置了pack_propagate(False)，如果子控件使用pack(fill="both", expand=True)，
        它仍会填满Frame的全部空间（但Frame本身大小不变）。
        若希望子控件不填满，需明确指定fill="none"或使用place()/grid()。
    其他布局管理器：
        grid()也有类似行为，通过frame.grid_propagate(False)禁止自动调整。
        place()不受影响，因为它直接指定绝对位置。
    动态调整：
        如果后续动态添加/删除子控件，pack_propagate(False)会固定Frame的初始尺寸，
        可能导致内容显示不全。
        
3.何时使用pack_propagate(False)？
    需要固定容器尺寸：如设计一个固定大小的面板或背景区域。
    子控件需要绝对定位：配合place()精确控制子控件位置。
    防止布局“抖动”：避免因子控件变化导致父容器频繁调整大小。

    以下是设置了frmae1.pack_propagate(False)时的代码和效果图

    import tkinter as tk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def run():
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    # 创建frame控件,这个Frame控件不放入任何控件
    frame = tk.Frame(root,
                     width=50,
                     height=50,
                     background=Settings.background,
                      )
    frame.pack(pady=(10, 0))

    # -----------------------------------------------------------
    # 创建frame1控件
    frame1 = tk.Frame(root,
                      width=50,
                      height=50,
                      background=Settings.background,
                      )
    # 创建一个按钮放入到frame1中
    btn1 = tk.Button(frame1, text="button1")
    btn1.pack()
    frame1.pack(pady=(10, 0))
    # 设置pack_propagate方法的flag参数值为False
    frame1.pack_propagate(flag=False)    
    # ---------------------------------------------------------
	
    # 创建frame2控件
    frame2 = tk.Frame(root,
                      width=50,
                      height=50,
                      background=Settings.background,
                      # 设置 Frame 水平方向的内边距（控件与边框的间距，单位：像素）
                      padx=10
                      )
    # 创建一个按钮放入到frame2中
    btn2 = tk.Button(frame2, text="button2")
    btn2.pack()
    frame2.pack(pady=(10, 0))

    root.mainloop()

if __name__ == "__main__":
    run()

    在这里插入图片描述

2.ttk.Frame的参数使用

  • master:指定 ttk.Frame 的父容器（决定其显示位置，如主窗口或其他控件）

    width:设置 Frame 的宽度（单位：像素，默认 0 表示自适应内容宽度）

    height:设置 Frame 的高度（单位：像素，默认 0 表示自适应内容高度）

    relief:设置边框样式（控制边框的视觉效果）,relief值有：“raised”, “sunken”, “flat”, “ridge”, “solid”, “groove”（raised:凸起、sunken:凹陷、flat:扁平、ridge:脊状、solid:实线、groove:凹槽）

    **bd/border:**设置边框宽度（与 borderwidth 功能相同，单位：像素，默认值为0）

    **borderwidth:**设置边框宽度（完整参数名，与 bd/border 功能相同，控制边框粗细，默认值为0）

    由于Frame控件默认的宽高是0，且啥样式都没有，如果你想像tkinter中Frame的一样通过设置背景颜色来看见ttk.Frame控件的效果，那么很遗憾，ttk.Frame没有background的参数，我们无法通过设备背景颜色来看见效果，要想设置背景颜色只有通过style参数才能设置(后面会讲)，所以我们退而求其次，通过设置ttk.Frame的width、height、bd、relief参数来看见ttk.Frame的控件效果，这也是为什么我要将他们放在一起进行使用。

    import tkinter as tk
# 导入ttk模块
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 创建一个ttk的Frame控件
    frame = ttk.Frame(master=root, # 设置控件的父容器
                      width=100, # 设置控件的宽
                      height=100, # 设置控件的高
                      borderwidth=5, # 设置控件的边框宽度
                      relief="groove", # 设置控件的边框样式
                      )
    frame.pack()


def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

  • class_:控件的类名（用于样式管理，默认继承 TFrame 类，自定义样式时可能需要修改）

    在这里我们不修改class_参数，只是看看它的默认值是啥。

    如果我们想要获得一个控件的某个参数当前的值，我们可以是控件的cget(“参数名”)来获取值。

    如果我们想要获取控件可显示的所有参数的当前值，可以使用控件的configure()和config()方法

    控件对象.cget(“控件的某个参数名”)：获取控件的某一个参数的当前设置的值

    控件对象.config()/控件对象.configure(): 获取可以获取到的所有参数的当前值

    注：使用cget方法获取class_的当前值时，应使用cget(“class”),而不是cget(“class_”),这是因为在Python中class以经是关键字，不能作为变量或者参数等使用，所有参数才使用class_,但在底层还是使用的class。

    总结：参数使用class_,cget获取class_的值传入"class"。

    import tkinter as tk
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def get_info():
    print(frame.config())

def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 创建一个ttk的Frame控件
    global frame
    frame = ttk.Frame(master=root, # 设置控件的父容器
                      width=100, # 设置控件的宽
                      height=100, # 设置控件的高
                      borderwidth=5, # 设置控件的边框宽度
                      relief="groove", # 设置控件的边框样式
                      )
    frame.pack()
    
    btn = ttk.Button(root, text="点击获取ttk.Frame中的class_参数的相关信息")
    btn.config(command=get_info)
    btn.pack(pady=10)

def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()

    在这里插入图片描述

    我们再来讲解一下我们通过config/configure方法获取的数据是啥意思：

    在 Tkinter 中，当你调用 btn.configure()（不带参数时），会返回一个字典，其中键是控件的配置选项名称（如 'relief'），值是一个包含该选项详细信息的元组。这个元组的结构是 Tkinter 内部对控件配置参数的标准化描述，包含 5 个元素，分别代表该选项的不同属性。

    以 'relief' 为例，元组含义拆解：

    ('relief',  # 第1个元素
 'relief',  # 第2个元素
 'Relief',  # 第3个元素
 '', # 第4个元素
 <string object: 'groove'> # 第5个元素
)

    这 5 个元素的通用含义是：

    1. Python 中使用的选项名（字符串）：
      即你在 Python 代码中设置该选项时用的名称（如 relief），也是字典的键。
    2. Tcl 数据库中的名称（字符串）：
      Tkinter 底层依赖 Tcl 解释器，这个名称是该选项在 Tcl 内部数据库中的标识（骆驼拼写法，如 borderWidth），用于 Tcl 层面的配置管理。
    3. Tcl 数据库中的类名（字符串）：
      用于 Tcl 内部对选项进行分类的标识（首字母大写，如 Relief），主要用于主题和样式管理。
    4. 默认值：
      该选项的默认值。
    5. 当前值（Python 或 Tcl 类型）：
      该选项当前的实际值。如果未手动修改，通常与默认值相同（如 ''）；如果手动设置过（如 btn.configure(relief="groove")），则显示修改后的值。

  • cursor:设置鼠标悬停在 Frame 上时的光标样式

    ttk.Frame的cursor的使用和tkinter.Frame的cursor一样，这里就不在写示例代码了

    鼠标样式图及其取值

    在这里插入图片描述

在这里插入图片描述

  • name:控件的内部名称（用于 Tk 内部管理和样式关联，如：name=‘frame_1’, 一般无需手动设置, ）

    这个name参数我还没有想好这样解释，如果你有好的解释术语，可以在评论区下面留言。

    虽然还没想好咋解释，但我们可以通过示例代码可以看出端倪。

    未设置name时，打印出的frame控件对象

    import tkinter as tk
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def get_info():
    print(frame)

def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 创建一个ttk的Frame控件
    global frame
    frame = ttk.Frame(master=root, # 设置控件的父容器
                      width=100, # 设置控件的宽
                      height=100, # 设置控件的高
                      borderwidth=5, # 设置控件的边框宽度
                      relief="groove", # 设置控件的边框样式
                      )
    frame.pack()
    
    btn = ttk.Button(root, text="打印frame对象")
    btn.config(command=get_info)
    btn.pack(pady=10)

def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

    设置了name时，打印出的frame控件对象

    import tkinter as tk
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        

def get_info():
    print(frame)

def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 创建一个ttk的Frame控件
    global frame
    frame = ttk.Frame(master=root, # 设置控件的父容器
                      width=100, # 设置控件的宽
                      height=100, # 设置控件的高
                      borderwidth=5, # 设置控件的边框宽度
                      relief="groove", # 设置控件的边框样式
                      name="frame1"
                      )
    frame.pack()
    
    btn = ttk.Button(root, text="打印frame对象")
    btn.config(command=get_info)
    btn.pack(pady=10)

def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

  • padding:设置内边距（控件内容与边框的间距，支持多方向灵活设置），支持统一或单独设置上下左右间距

    例如：padding=5: 上下左右的内边距都是5

    ​ padding=(5, 4)：上下内边距为5，左右内边距为4

    ​ padding=(2, 3, 4, 5): 左内边距为2，上内边距为3，右内边距为4，下内边距为5

    import tkinter as tk
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"    
        


def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 创建一个ttk的Frame控件
    frame = ttk.Frame(master=root, # 设置控件的父容器
                      width=100, # 设置控件的宽
                      height=100, # 设置控件的高
                      relief="groove", # 设置控件的边框样式
                      )
    frame.pack()
    
    btn = ttk.Button(frame, text="未设置内边距的按钮")
    btn.pack()


    frame2 = ttk.Frame(master=root, # 设置控件的父容器
                       width=100, # 设置控件的宽
                       height=100, # 设置控件的高
                       relief="groove", # 设置控件的边框样式
                       # 设置内边距padding=(左内边距为2, 上内边距为4, 右内边距为6, 下内边距为8)
                       padding=(2, 4, 6, 8)
                       )
    frame2.pack(pady=5)
    
    btn2 = ttk.Button(frame2, text="设置了内边距的按钮")
    btn2.pack()
    
def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

  • style:应用自定义样式（需通过 ttk.Style 预先定义样式规则),比如：style=‘MyFrame.TFrame’

    使用步骤

    步骤一：初始化Style实例

    步骤二：使用Style实例的configure方法设置样式

    步骤三: 设置Frame控件的style样式，使其关联上自定义的标签样式

    configure方法语法：style.configure(样式名, **属性)

    ttk 控件的样式有固定命名规则，比如配置Frame的写法是style.configure(“TFrame”, **属性)

    如果需要使用自定义的样式可以这样写style.configure(“自定义样式名称.TFrame”, **属性)

    import tkinter as tk
from tkinter import ttk
from dataclasses import dataclass

@dataclass
class Settings:
    """用于设置窗口大小和位置的数据类"""
    width: int = 400
    height: int = 400
    x: int = 300
    y: int = 200
    background: str = "blue"   


def create_widgets(root):
    """
    创建窗口控件
    :param root: 根窗口
    """
    # 初始化Style实例
    style = ttk.Style()
    # 使用Style示例的configure方法设置Frame的背景样式为蓝色
    style.configure("TFrame",
                    background=Settings.background)

    frame = ttk.Frame(master=root, # 设置控件的父容器
                       width=100, # 设置控件的宽
                       height=100, # 设置控件的高
                       # 设置Frame控件的style样式，使其关联上自定义的标签样式
                       style="TFrame"
                       )
    frame.pack(pady=5)
    
    
def run():
    """设置根窗口和启动应用"""
    root = tk.Tk()
    root.title("Frame控件")
    root.geometry(f"{Settings.width}x{Settings.height}" \
                  f"+{Settings.x}+{Settings.y}")
    
    
    create_widgets(root)
    
    root.mainloop()
    
    
if __name__ == "__main__":
    run()

    在这里插入图片描述

  • takefocus:控制 Frame 是否可通过 Tab 键获得焦点,影响键盘导航,True:可获得焦点，False不可获得焦点，“”:自动判断

    ttk.Frame的takefocus的使用方法和tkinter.Frame的takefocus的使用方式一样，这里不在过多赘述，如需使用请参考tkinter.Frame的参数使用中的takefocus.

# python
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

cover

替你试过了，消费级显卡可以跑的开源文生图SOTA模型，顶级渲染、高密度文本绘图

avatar 魔乐社区
cover

量化挑战赛冠军专访：4小时啃下W4A8量化，我靠的是这些经验

avatar 魔乐社区

小参数・大码力・易部署 | Qwen3.6-27B上线魔乐社区，基于昇腾的部署教程来了

继一周前模型开源发布后，千问再度开源Qwen3.6-27B —— 一个拥有270亿参数的稠密多模态模型，也是社区呼声最高的模型规格。Qwen3.6-27B 依然支持多模态思考与非思考模式，在智能体编程方面达到了旗舰级表现，全面超越前代开源旗舰 Qwen3.5-397B-A17B（总参数397B / 激活参数17B的MoE模型）。作为稠密架构，它无需MoE路由即可部署，是开发者在实用、可广泛部署规模

avatar 魔乐社区