Python 图形用户界面GUI 之 Tkinter

本文主要是介绍Python 图形用户界面GUI 之 Tkinter，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

什么是Tkinter

Tkinter 是 Python 的标准 GUI（图形用户界面）库。它是 Python 内置的一个模块，用于创建桌面应用程序的用户界面。Tkinter 基于 Tcl(脚本语言)/Tk(GUI工具包) 库，是 Python 提供的默认图形界面开发工具。因为它与 Python 一起分发，所以不需要单独安装，使用时只需要导入相应的模块即可。

Tkinter的跨平台性

Tkinter 可以在多个操作系统上运行，包括 Windows、macOS 和 Linux。

Python的图形用户界面

在 Python 中，有许多库可以用来创建客户端 GUI（图形用户界面）。以下是一些常见的 Python GUI 库和框架：

Tkinter:

描述: Tkinter 是 Python 的标准 GUI 库，基于 Tk GUI 工具包。
特点: 内置于 Python 标准库中，易于上手，适合快速开发简单的 GUI 应用。

PyQt:

描述: PyQt 是 Qt 库的 Python 绑定，提供了强大的跨平台 GUI 开发能力。
特点: 功能丰富，支持多种平台，适合开发复杂的应用。

PySide:

描述: PySide 是 Qt 库的另一种 Python 绑定，和 PyQt 类似，但采用了不同的许可证（LGPL）。
特点: 与 PyQt 类似，支持多平台，适合开发专业级应用。

Kivy:

描述: Kivy 是一个用于开发跨平台应用的开源 Python 库，支持触控界面。
特点: 适用于移动设备和桌面应用，支持多种输入方式。

wxPython:

描述: wxPython 是 wxWidgets C++ 库的 Python 绑定，提供了原生的 GUI 组件。
特点: 提供原生界面外观，支持多平台。

FLTK (Fast, Light Toolkit):

描述: FLTK 是一个轻量级的 C++ GUI 工具包，Python 有 FLTK 的绑定库 pyFLTK。
特点: 轻量且高效，适合对资源要求高的应用。

Dear PyGui:

描述: Dear PyGui 是一个用于创建简单而高性能 GUI 的库，特别适用于游戏和图形应用。
特点: 直观的 API 和高性能渲染。

PyGTK:

描述: PyGTK 是 GTK+ 的 Python 绑定，适用于 Linux 系统上的图形用户界面。
特点: 主要用于 Linux 系统，支持 GNOME 桌面环境。

在众多 Python GUI 库中，PyQt 和 Tkinter 是两个最为常用且功能强大的库。

Tkinter的组件

1. 顶层窗口 (Toplevel Window)

Tk: 主窗口，一个顶级窗口。
Toplevel: 创建一个子窗口，类似于 Tk 同样是个顶级窗口，但作为主窗口的子窗口存在。

2. 基本控件 (Basic Widgets)

Label: 标签，用于显示文本或图像。
Button: 按钮，用户可以点击以触发事件。
Canvas: 画布，允许绘制图形、显示图像、创建图形界面或其他小部件。
Entry: 单行文本输入框，用户可以输入文本。
Text: 多行文本框，用于显示和编辑多行文本。
Frame: 框架，用于包含其他小部件的容器。
LabelFrame: 带标题的框架，作为 Frame 的扩展。
PhotoImage: 用于显示图片（仅限 GIF 和 PGM/PPM 格式）。

3. 容器控件 (Container Widgets)

Frame: 用作其他控件的容器。
LabelFrame: 类似于 Frame，但带有标签。
PanedWindow: 可调节大小的窗口容器，包含多个子窗口。
Notebook: 选项卡式窗口容器。

4. 选择控件 (Selection Widgets)

Checkbutton: 复选按钮，用于多选。
Radiobutton: 单选按钮，用于单选。
Scale: 滑块，用于选择数值。
Spinbox: 数值选择框，允许用户选择或输入数值。

5. 菜单控件 (Menu Widgets)

Menu: 菜单栏，包含多个菜单项。
MenuButton: 菜单按钮，点击后显示下拉菜单。

6. 列表控件 (List Widgets)

Listbox: 列表框，显示一个或多个项目的列表。
Scrollbar: 滚动条，与其他控件一起使用来提供滚动功能。

7. 对话框控件 (Dialog Widgets)

Message: 信息对话框，显示多行不可编辑文本。
MessageBox: 用于显示消息对话框，如信息、警告、错误等。
FileDialog: 文件对话框，用于打开或保存文件。
ColorChooser: 颜色选择对话框，用户可以选择颜色。
SimpleDialog: 简单对话框，用于用户输入。

8. 高级控件 (Advanced Widgets)

Treeview: 树视图，用于显示分层数据。
Progressbar: 进度条，显示任务的进度。
Combobox: 组合框，类似于下拉列表。

9. 定制与布局控件 (Customization and Layout Widgets)

Place: 绝对定位管理器，允许精确控制组件位置。
Pack: 包装定位管理器，按顺序排列组件。
Grid: 网格定位管理器，在表格中排列组件。

颜色选项

标准颜色名称：如 "red"、"blue"、"green"、"yellow" 等。
十六进制颜色代码：如 "#FF5733"（橙红色）、"#4CAF50"（绿色）。
RGB 颜色代码：格式为 "#RRGGBB"，其中 RR、GG 和 BB 是红色、绿色、蓝色的分量（例如 "#0000FF" 表示蓝色）。

事件绑定选项

"<Button-1>" 鼠标左键点击
"<Button-2>": 鼠标中键点击
"<Button-3>": 鼠标右键点击
"<Double-1>": 鼠标左键双击
"<Enter>": 鼠标光标进入组件
"<Leave>": 鼠标光标离开组件
"<Configure>": 窗口或组件大小发生变法时触发

布局管理器

`pack()` 布局管理器

pack 布局管理器按顺序将小部件放入父容器中，通常是垂直或水平的。

参数详细说明：

side: 指定小部件在父容器中的哪一侧放置。可以是以下值：

TOP: 放置在顶部（默认值）
BOTTOM: 放置在底部
LEFT: 放置在左侧
RIGHT: 放置在右侧

fill: 指定小部件如何填充其父容器的空间。可以是以下值：

NONE: 不填充（默认值）
X: 仅在水平方向填充
Y: 仅在垂直方向填充
BOTH: 在水平方向和垂直方向都填充

expand: 一个布尔值，指定小部件是否应在父容器中扩展以填补额外的空间。True 使小部件扩展，False 不扩展（默认值）。

padx 和 pady: 控制小部件与父容器边界之间的水平和垂直间距。可以是单个值或两个值（分别用于 x 和 y 方向）。

`grid()` 布局管理器

grid 布局管理器通过网格系统在父容器中定位小部件。

参数详细说明：

row: 指定小部件所在的行（从 0 开始）。

column: 指定小部件所在的列（从 0 开始）。

rowspan: 指定小部件跨越的行数。

columnspan: 指定小部件跨越的列数。

sticky: 指定小部件在单元格中的对齐方式。可以是以下值：

N: 顶部对齐
S: 底部对齐
E: 右侧对齐
W: 左侧对齐
NS: 垂直方向对齐
EW: 水平方向对齐
NEWS: 四个方向都对齐

padx 和 pady: 控制小部件与单元格边界之间的水平和垂直间距。

ipadx 和 ipady: 控制小部件的内部填充，即小部件内部内容与小部件边界之间的水平和垂直间距。

`place()` 布局管理器

place 布局管理器使用绝对定位或相对定位将小部件放置在其父容器中。

参数详细说明：

x 和 y: 指定小部件的绝对坐标位置（相对于父容器的左上角）。

relx 和 rely: 指定小部件的相对坐标位置（0 到 1 之间的值，表示父容器的相对位置）。

anchor: 指定小部件在位置坐标处的对齐方式。可以是以下值之一：

N, E, S, W 等，表示方位的缩写（北、东、南、西）

bordermode: 指定小部件的边界模式，控制小部件位置计算是否考虑边框。可以是以下值：

INSIDE: 位置计算不包括边框
OUTSIDE: 位置计算包括边框

width 和 height: 指定小部件的宽度和高度。

relwidth 和 relheight: 指定小部件的相对宽度和高度（0 到 1 之间的值，表示父容器的相对大小）。

组件的使用

Tk主窗口组件

Tk 是创建应用程序主窗口的顶层容器。

Tk组件常用方法

1. 窗口管理方法

withdraw(): 隐藏窗口，但不销毁它。
deiconify(): 显示一个已被withdraw()方法隐藏的窗口。
iconify(): 最小化窗口。
state(): 返回窗口的状态（如'normal'、'iconic'、'withdrawn'等）。
wm_state(state=None): state()方法的别名，也可以用来设置窗口状态。

2. 尺寸和位置方法

geometry(newGeometry=None): 获取或设置窗口的大小和位置（例如"200x100+10+20"）。
maxsize(width=None, height=None): 获取或设置窗口的最大尺寸。
minsize(width=None, height=None): 获取或设置窗口的最小尺寸。
resizable(width=None, height=None): 获取或设置窗口的大小是否可变（水平和垂直方向）。
positionfrom(who=None): 设置窗口位置的参考点。
sizefrom(who=None): 设置窗口大小的参考来源。

3. 标题和图标方法

title(string=None): 获取或设置窗口的标题。
iconbitmap(bitmap=None): 设置窗口的图标。
iconphoto(default=False, *args): 设置窗口的图标照片。

4. 透明度和样式方法

attributes(*args): 获取或设置窗口的多种属性（如透明度、是否置顶等）。
wm_attributes(*args): 与attributes()方法相同，用于管理窗口属性。
transient(master=None): 将窗口设置为临时窗口，使其在另一个窗口的上方。

5. 事件处理方法

bind(sequence=None, func=None, add=None): 绑定事件处理程序。
unbind(sequence, funcid=None): 解除事件处理程序的绑定。
bind_all(sequence=None, func=None, add=None): 对所有窗口控件绑定事件处理程序。
bind_class(className, sequence=None, func=None, add=None): 对特定控件类绑定事件处理程序。
event_add(virtual, *sequences): 添加虚拟事件。
event_delete(virtual, *sequences): 删除虚拟事件。
event_generate(sequence, **kw): 生成事件。
event_info(virtual=None): 获取有关事件的信息。

6. 退出和销毁方法

destroy(): 销毁当前窗口及其当前窗口的所有子窗口。
quit(): 退出主事件循环。

7. 其他常用方法

tkraise(aboveThis=None): 提升窗口的堆叠顺序。
lift(aboveThis=None): 提升窗口的堆叠顺序，tkraise()的别名。
lower(belowThis=None): 降低窗口的堆叠顺序。

Tk示例

1. 有图标有标题的的Tk主窗口

import tkinter as tkroot = tk.Tk()
root.title("主窗口")  # 设置窗口标题
root.geometry("300x200")  # 设置窗口大小# 设置图标。图片格式
icon = tk.PhotoImage(file="static/icon/a.png")
root.iconphoto(False, icon)root.mainloop()  # 进入事件循环

2. 设置主窗口在桌面居中打开

import tkinter as tk# 窗口居中方法
def center_window(window, width, height):# 获取屏幕宽度和高度screen_width = window.winfo_screenwidth()screen_height = window.winfo_screenheight()# 计算窗口的x和y坐标，使窗口居中x = (screen_width - width) // 2y = (screen_height - height) // 2# 设置窗口的大小和位置window.geometry(f'{width}x{height}+{x}+{y}')root = tk.Tk()
root.title("主窗口")  # 设置窗口标题# 设置窗口大小并居中显示
window_width = 300
window_height = 200
center_window(root, window_width, window_height)root.mainloop()  # 进入事件循环

3. 设置窗口透明度

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("透明度的窗口")# 设置窗口大小
root.geometry("300x200")# 设置窗口透明度（范围从 0.0 到 1.0，1.0 表示完全不透明）
root.wm_attributes('-alpha', 0.5)# 进入主事件循环
root.mainloop()

4. 主窗口设置背景图片，图片随着窗口大小的变化动态变化

import tkinter as tk
from PIL import Image, ImageTkdef resize_image(image, size):"""调整图片大小以适应指定的尺寸"""return image.resize(size, Image.LANCZOS)def update_background(event):"""在窗口调整大小时更新背景图片"""global background_photonew_width = root.winfo_width()new_height = root.winfo_height()# 调整图片大小以填充窗口resized_image = resize_image(background_image, (new_width, new_height))background_photo = ImageTk.PhotoImage(resized_image)# 更新标签显示的图片background_label.config(image=background_photo)# 创建主窗口
root = tk.Tk()
root.title("动态背景图片窗口")# 设置窗口初始大小
window_width = 500
window_height = 350
root.geometry(f'{window_width}x{window_height}')# 使用 Pillow 加载背景图片
background_image = Image.open("static/background/a.png")# 创建初始背景图片
initial_resized_image = resize_image(background_image, (window_width, window_height))
background_photo = ImageTk.PhotoImage(initial_resized_image)# 创建标签以显示背景图片
background_label = tk.Label(root, image=background_photo)
background_label.place(x=0, y=0, relwidth=1, relheight=1)# 绑定窗口大小变化事件
root.bind('<Configure>', update_background)# 进入主事件循环
root.mainloop()

5. 主窗口设置背景颜色

import tkinter as tkroot = tk.Tk()
root.title("设置主窗口背景颜色")
root.geometry("300x200")# 设置主窗口的背景颜色
root.configure(bg="lightblue")
# root.configure(bg="#0000AF")root.mainloop()

Button按钮组件

Button组件常用方法

创建 Button 按钮

button = tk.Button(root, text="点击我", command=on_button_click)

root 是按钮的父容器。
text 设置按钮上显示的文本。
command 设置按钮被点击时调用的函数，这里是 on_button_click。

设置按钮的颜色

button = tk.Button(root, text="点击我", command=on_button_click, bg="blue", fg="white")

bg 是按钮的背景颜色。也可以使用十六进制#0000FF这样的
fg 是按钮的文本颜色。

设置按钮的字体

button = tk.Button(root, text="点击我", command=on_button_click, font=("Arial", 14, "bold"))

font 设置字体和大小加粗

设置按钮的大小

button = tk.Button(root, text="点击我", command=on_button_click, width=15, height=2)

button = tk.Button(root, text="点击我", command=on_button_click, padx=20, pady=5)

width 按钮的宽
height 按钮的高
padx 通过修改内边距修改按钮的宽
padx 通过修改内边距修改按钮的高

设置按钮的状态

button = tk.Button(root, text="点击我", command=on_button_click, state=tk.DISABLED)

state=tk.DISABLED 按钮不可点击

使用图片作为按钮

img = tk.PhotoImage(file="path_to_image.png")
button = tk.Button(root, image=img, command=on_button_click)

Button按钮的布局管理器

pack() 布局管理器

pack() 布局管理器用于将控件按顺序放置在主窗口中。它的布局方式是将控件打包到容器的顶部、底部、左侧或右侧，也可以让控件在容器中居中对齐。

grid() 布局管理器

grid() 布局管理器将控件放置在一个网格中，通过指定行和列的位置来安排控件。这适用于需要精确布局的情况。

place 布局管理器

place() 布局管理器允许你通过指定绝对或相对位置来放置控件。这种方法提供了最大的灵活性，但需要你手动计算位置。

Button示例

1. 创建一个button有点击事件

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("Tkinter Button 示例")
root.geometry("300x200")# 定义按钮点击事件的回调函数
def on_button_click():print("按钮被点击了!")# 创建一个按钮
button = tk.Button(root, text="点击我", command=on_button_click)# 放置按钮到主窗口
button.pack(padx=20, pady=20)# 运行主循环
root.mainloop()

2. pack() 布局管理器

import tkinter as tkroot = tk.Tk()
root.title("pack 布局管理器示例")
root.geometry("300x200")# 创建按钮并使用 pack() 布局
button1 = tk.Button(root, text="按钮上")
button1.pack(side=tk.TOP, padx=10, pady=10)button2 = tk.Button(root, text="按钮左")
button2.pack(side=tk.LEFT, padx=10, pady=10)button3 = tk.Button(root, text="按钮右")
button3.pack(side=tk.RIGHT, padx=10, pady=10)button4 = tk.Button(root, text="按钮下")
button4.pack(side=tk.BOTTOM, padx=10, pady=10)root.mainloop()

3. grid() 布局管理器

import tkinter as tkroot = tk.Tk()
root.title("grid 布局管理器示例")
root.geometry("300x200")# 创建按钮并使用 grid() 布局
button1 = tk.Button(root, text="第一行第一列")
button1.grid(row=0, column=0, padx=10, pady=10)button2 = tk.Button(root, text="第一行第二列")
button2.grid(row=0, column=1, padx=10, pady=10)button3 = tk.Button(root, text="第二行第一列")
button3.grid(row=1, column=0, padx=10, pady=10)button4 = tk.Button(root, text="第二行第二列")
button4.grid(row=1, column=1, padx=10, pady=10)root.mainloop()

4. place() 布局管理器写xy坐标

import tkinter as tkroot = tk.Tk()
root.title("place 布局管理器示例")
root.geometry("300x200")# 创建按钮并使用 place() 布局
button1 = tk.Button(root, text="按钮1")
button1.place(x=20, y=20)button2 = tk.Button(root, text="按钮2")
button2.place(x=100, y=20)button3 = tk.Button(root, text="按钮3")
button3.place(x=20, y=100)button4 = tk.Button(root, text="按钮4")
button4.place(x=100, y=100)root.mainloop()

5. 按钮的边框设置

tk.RAISED：按钮看起来有一个向上凸起的效果，边框会有阴影效果，使按钮突出。
tk.SUNKEN：按钮看起来有一个向下凹陷的效果，边框有内阴影效果，使按钮看起来被压入背景中。
tk.FLAT：按钮没有边框的立体效果，边框是平的，看起来像没有边框。
tk.GROOVE：按钮的边框看起来像是有一个凹槽效果，边框看起来凹陷。
tk.RIDGE：按钮的边框看起来像是有一个凸起的脊线效果，形成一个明显的边界。

import tkinter as tkroot = tk.Tk()
root.title("Relief 示例")
root.geometry("300x350")# 创建不同样式的按钮
button_raised = tk.Button(root, text="Raised", relief=tk.RAISED, width=15, height=2)
button_sunken = tk.Button(root, text="Sunken", relief=tk.SUNKEN, width=15, height=2)
button_flat = tk.Button(root, text="Flat", relief=tk.FLAT, width=15, height=2)
button_groove = tk.Button(root, text="Groove", relief=tk.GROOVE, width=15, height=2)
button_ridge = tk.Button(root, text="Ridge", relief=tk.RIDGE, width=15, height=2)# 放置按钮
button_raised.pack(padx=10, pady=10)
button_sunken.pack(padx=10, pady=10)
button_flat.pack(padx=10, pady=10)
button_groove.pack(padx=10, pady=10)
button_ridge.pack(padx=10, pady=10)root.mainloop()

6. 按钮悬停改变颜色

import tkinter as tkdef on_enter(event):button.config(bg="#FF0000", text="悬停中")  # 悬停时修改背景颜色和文本def on_leave(event):button.config(bg="#71B960", text="未悬停")  # 悬停时恢复背景颜色和文本root = tk.Tk()
root.title("按钮悬停效果示例")
root.geometry("300x200")# 创建一个按钮
button = tk.Button(root,text="未悬停",bg="#71B960",fg="white",padx=20,pady=5
)# 绑定悬停事件
button.bind("<Enter>", on_enter)
button.bind("<Leave>", on_leave)button.pack(padx=20, pady=20)root.mainloop()

7. 图片当作按钮

import tkinter as tk
from PIL import Image, ImageTkdef create_resized_image(image_path, size):# 打开图像image = Image.open(image_path)# 调整图像大小image = image.resize(size, Image.LANCZOS)# 转换为 PhotoImage 对象return ImageTk.PhotoImage(image)root = tk.Tk()
root.title("调整图像大小的按钮示例")
root.geometry("300x200")  # 窗口的大小# 设置按钮大小
button_size = (120, 60)  # 例如：宽度 120 像素，高度 60 像素# 载入并调整图像大小
photo = create_resized_image("static/icon/b.png", button_size)  # 替换为你的图像路径# 创建一个按钮并设置图像
button = tk.Button(root,text="图像按钮",        # 文本内容compound=tk.CENTER,     # 图像和文本的组合方式fg="white",             # 文本颜色image=photo,            # 图片borderwidth=0,          # 去除按钮边框, 点击时看不到边框relief=tk.FLAT,         # 边框是平的，看起来像没有边框
)button.pack(padx=20, pady=20)root.mainloop()

Toplevel子窗口组件

Toplevel组件常用方法

title()：设置或获取窗口的标题。
geometry()：设置或获取窗口的尺寸和位置。
resizable()：设置窗口是否可以调整大小。
configure()：配置窗口的各种选项，如背景色、字体等。
transient()：将窗口标记为某个窗口的临时窗口，通常用于对话框。
grab_set()：捕获所有的用户输入，直到窗口被销毁或调用 grab_release()。
wait_window()：阻塞主循环，直到窗口被销毁。
destroy()：销毁窗口，关闭窗口并释放资源。
withdraw()：隐藏窗口而不是销毁它，可以稍后使用 deiconify() 恢复显示。
iconbitmap()：设置窗口的图标。
protocol()：设置窗口关闭时的处理方法，例如添加自定义的处理函数。
focus_set()：设置窗口为当前活动窗口，使其获得焦点。

Toplevel组件示例

1. 打开一个子窗口

import tkinter as tkdef open_new_window():# 创建新的 Toplevel 窗口new_window = tk.Toplevel(root)new_window.title("子窗口")new_window.geometry("250x150")# 在新窗口中添加一些控件label = tk.Label(new_window, text="这是一个子窗口")label.pack(padx=20, pady=20)button = tk.Button(new_window, text="Close", command=new_window.destroy)button.pack(pady=10)# 创建主窗口
root = tk.Tk()
root.title("主窗口")
root.geometry("300x200")# 在主窗口中添加一个按钮，点击后打开新的 Toplevel 窗口
open_button = tk.Button(root, text="打开子窗口", command=open_new_window)
open_button.pack(padx=20, pady=20)# 运行应用程序
root.mainloop()

2. 打开一个子窗口，传递参数到子窗口

import tkinter as tkdef open_new_window(param1, param2):# 创建新的 Toplevel 窗口new_window = tk.Toplevel(root)new_window.title("子窗口")new_window.geometry("250x150")# 在新窗口中添加一些控件label = tk.Label(new_window, text="这是一个子窗口")label.pack(padx=10, pady=10)# 在 Toplevel 窗口中创建一个标签显示传递的参数label = tk.Label(new_window, text=f"参数1: {param1}, 参数二: {param2}")label.pack(padx=10, pady=10)button = tk.Button(new_window, text="Close", command=new_window.destroy)button.pack(pady=10)# 创建主窗口
root = tk.Tk()
root.title("主窗口")
root.geometry("300x200")# 在主窗口中添加一个按钮，点击后打开新的 Toplevel 窗口
open_button = tk.Button(root, text="打开子窗口", command=lambda: open_new_window("Hello", "Toplevel"))
open_button.pack(padx=20, pady=20)# 运行应用程序
root.mainloop()

3. 子窗口打开时不能操作主窗口

import tkinter as tkdef open_new_window():# 创建新的 Toplevel 窗口new_window = tk.Toplevel(root)new_window.title("子窗口")new_window.geometry("250x150")# 不能操作主窗口new_window.grab_set()# 在新窗口中添加一些控件label = tk.Label(new_window, text="这是一个子窗口")label.pack(padx=20, pady=20)button = tk.Button(new_window, text="Close", command=new_window.destroy)button.pack(pady=10)# 创建主窗口
root = tk.Tk()
root.title("主窗口")
root.geometry("300x200")# 在主窗口中添加一个按钮，点击后打开新的 Toplevel 窗口
open_button = tk.Button(root, text="打开子窗口", command=open_new_window)
open_button.pack(padx=20, pady=20)# 运行应用程序
root.mainloop()

4. 捕获窗口关闭事件

import tkinter as tkdef open_window_with_protocol():def on_closing():print("子窗口关闭了")window.destroy()window = tk.Toplevel(root)window.title("子窗口")window.geometry("250x150")# 设置关闭窗口的协议window.protocol("WM_DELETE_WINDOW", on_closing)# 添加控件到窗口label = tk.Label(window, text="这是一个子窗口")label.pack(pady=20)# 创建主窗口
root = tk.Tk()
root.title("主窗口")
root.geometry("300x200")# 添加按钮以打开窗口
protocol_button = tk.Button(root, text="打开子窗口", command=open_window_with_protocol)
protocol_button.pack(pady=20)root.mainloop()

Label标签组件

Label组件常用选项

text: 标签显示的文本内容。
font: 设置文本的字体、大小等（例如 ("Arial", 16)）。
fg: 设置文本颜色（例如 "blue"）。
bg: 设置标签背景颜色（例如 "lightyellow"）。
width: 标签的宽度（以字符数为单位）。
height: 标签的高度（以字符数为单位）。
anchor: 文本对齐方式（例如 "w" 表示左对齐， "e"右对齐，"center"居中）。
padx: 文本和标签边缘之间的水平间距。
pady: 文本和标签边缘之间的垂直间距。
image: 显示图像（需要 PhotoImage 或 BitmapImage 对象）。
compound: 文本和图像的组合方式。
top: 图片在上，文字在下。
bottom: 图片在下，文字在上。
left: 图片在左，文字在右。
right: 图片在右，文字在左。
center: 图片和文字重叠（默认值）。

Label组件示例

1. 创建一个Label组件，显示文本

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("Label 示例")
root.geometry("300x200")# 创建一个标签组件
label = tk.Label(root, text="Hello, Tkinter!", font=("Arial", 16), fg="blue", bg="lightyellow")# 使用 pack 布局管理器放置标签
label.pack(padx=20, pady=20)# 运行主事件循环
root.mainloop()

2. 文本太长，自动换行

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("自动换行示例")
root.geometry("300x200")# 创建 Label，设置宽度和自动换行
label = tk.Label(root, text="这是一个很长的文本，它会根据指定的宽度自动换行显示。", wraplength=150)
label.pack()# 运行主事件循环
root.mainloop()

3. 带边框和内间距间隔

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("设置边框和填充示例")
root.geometry("300x200")# 创建 Label，设置边框宽度和填充
label = tk.Label(root, text="带边框和填充的标签", borderwidth=1, relief="solid", padx=10, pady=10)
label.pack()# 运行主事件循环
root.mainloop()

4. Label的点击事件

import tkinter as tk# 定义点击事件处理程序
def on_label_click(event):print("Label clicked!")# 创建主窗口
root = tk.Tk()
root.title("Label 点击事件示例")
root.geometry("300x200")# 创建标签组件
label = tk.Label(root, text="Click me!")
label.pack(padx=20, pady=20)# 绑定鼠标左键点击事件（<Button-1> 代表左键点击）
label.bind("<Button-1>", on_label_click)# 运行主事件循环
root.mainloop()

5. 显示图片

import tkinter as tk
from PIL import Image, ImageTk# 创建主窗口
root = tk.Tk()
root.title("Label 显示 JPEG 图片示例")# 加载 JPEG 图片
image = Image.open("static/background/a.jpg")
photo = ImageTk.PhotoImage(image)# 创建 Label 并设置图片
label = tk.Label(root, image=photo)
label.pack(padx=20, pady=20)# 保持对 Image 和 PhotoImage 的引用，防止被垃圾回收
label.image = photo# 运行主事件循环
root.mainloop()

6. 显示图片，图片大小不超过Label组件大小，图片不变形百分比缩放

import tkinter as tk
from PIL import Image, ImageTkdef resize_image(image, max_width, max_height):# 获取图像的原始尺寸original_width, original_height = image.size# 计算调整后的宽度和高度ratio = min(max_width / original_width, max_height / original_height)new_width = int(original_width * ratio)new_height = int(original_height * ratio)# 调整图像大小return image.resize((new_width, new_height), Image.LANCZOS)# 创建主窗口
root = tk.Tk()
root.title("Label 显示图片并调整大小示例")
root.geometry("300x200")# 设置 Label 的最大大小，百分比缩放
label_width = 300
label_height = 200# 加载原始图片
original_image = Image.open("static/background/a.jpg")# 调整图片大小以适应 Label
resized_image = resize_image(original_image, label_width, label_height)
photo = ImageTk.PhotoImage(resized_image)# 创建 Label 并设置初始图片
label = tk.Label(root, image=photo, width=label_width, height=label_height)
label.pack(padx=20, pady=20)# 保持对 PhotoImage 对象的引用
label.image = photo# 运行主事件循环
root.mainloop()

7. 图片和文字都显示的组合

import tkinter as tk
from PIL import Image, ImageTkdef resize_image(image, max_width, max_height):# 获取图像的原始尺寸original_width, original_height = image.size# 计算调整后的宽度和高度ratio = min(max_width / original_width, max_height / original_height)new_width = int(original_width * ratio)new_height = int(original_height * ratio)# 调整图像大小return image.resize((new_width, new_height), Image.LANCZOS)# 创建主窗口
root = tk.Tk()
root.title("Label 显示图片并调整大小示例")
root.geometry("300x200")# 设置 Label 的最大大小，百分比缩放
label_width = 100
label_height = 120# 加载原始图片
original_image = Image.open("static/background/a.jpg")# 调整图片大小以适应 Label
resized_image = resize_image(original_image, label_width, label_height)
photo = ImageTk.PhotoImage(resized_image)# 创建 Label 并设置初始图片
label = tk.Label(root, text="头像", compound="bottom", font=("Arial", 14), image=photo, width=label_width,height=label_height)
label.pack(padx=20, pady=20)# 保持对 PhotoImage 对象的引用
label.image = photo# 运行主事件循环
root.mainloop()

Entry单行文本输入框组件

Entry组件常用方法

1. 基本方法

delete(first, last=None): 删除文本框中从 first 到 last 位置的字符。如果只提供 first 参数，则删除该位置的单个字符。常用值包括：

0 或 tkinter.END：删除所有内容。

get(): 返回文本框中当前的内容（文本）。

insert(index, string): 在指定的 index 位置插入文本 string。

index(index): 返回光标位置或索引位置，index 可以是数字、"end" 或 "insert" 等。

icursor(index): 设置插入光标的位置，index 指定位置。

xview(*args): 控制文本框的水平滚动。常用于和水平滚动条 (Scrollbar) 配合使用。

2. 文本选择相关方法

select_adjust(index): 根据指定索引调整当前文本选择的范围。

select_clear(): 取消当前文本选择。

select_from(index): 从指定的 index 位置开始选择文本。

select_present(): 检查当前是否有文本被选择，如果有则返回 True，否则返回 False。

select_range(start, end): 选择从 start 到 end 位置的文本。

select_to(index): 选择从文本框开始到指定的 index 位置的文本。

3. 光标和视图控制方法

see(index): 滚动文本框以确保指定的 index 位置可见。

mark_set(mark, index): 设置一个标记（例如插入光标位置）到指定的 index 位置。

mark_unset(mark): 删除指定名称的标记。

4. 配置和属性方法

config(**options) 或 configure(**options): 更改或获取 Entry 的配置选项，如字体、背景颜色、文本颜色等。

cget(option): 获取指定配置选项的当前值。

5. 状态检查方法

instate(statespec, callback=None, *args, **kw): 如果状态匹配指定的 statespec，则调用回调函数。

state(statespec=None): 获取或设置当前小部件的状态（如 "disabled"、"normal" 等）。

6. 绑定和事件方法

bind(sequence, func, add=None): 绑定一个事件到文本框。例如，<Return> 可以绑定到一个回调函数来处理回车键事件。

bind_all(sequence, func, add=None): 绑定一个事件到所有的文本框组件。

bind_class(className, sequence, func, add=None): 绑定一个事件到所有属于该类的文本框组件。

unbind(sequence, funcid=None): 解除绑定事件。

Entry组件示例

1. 创建 Entry 组件

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 使用示例")
root.geometry("300x200")# 创建标签
label = tk.Label(root, text="请输入您的名字:")
label.pack(pady=10)# 创建 Entry 输入框并设置默认文本
entry = tk.Entry(root)
entry.insert(0, "请输入...")  # 设置默认文本
# 设置输入框宽度
entry.config(width=30)
entry.pack(pady=5)# 运行主循环
root.mainloop()

2. 限制最多输入字符数量

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 使用示例")
root.geometry("300x200")# 定义最大字符数
MAX_CHARACTERS = 20# 定义验证函数
def validate_input(text):return len(text) <= MAX_CHARACTERS# 创建验证命令
validate_cmd = root.register(validate_input)# 创建标签
label = tk.Label(root, text="请输入您的名字:")
label.pack(pady=10)# 创建 Entry 输入框并设置默认文本
entry = tk.Entry(root, validate="key", validatecommand=(validate_cmd, "%P"))
entry.insert(0, "请输入...")
entry.config(width=30)
entry.pack(pady=5)# 运行主循环
root.mainloop()

3. 设置背景颜色

entry = tk.Entry(root, bg="lightyellow")  # 设置背景色为浅黄色

4. 去除边框

entry = tk.Entry(root, borderwidth=0, relief="flat")

5. 输入框颜色与主窗口背景颜色保持一致

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 背景色与主窗口一致")
root.geometry("300x200")# 设置主窗口背景色
root_bg_color = "#f0f0f0"  # 主窗口背景色# 设置主窗口的背景色
root.config(bg=root_bg_color)# 创建标签
label = tk.Label(root, text="请输入您的名字:", bg=root_bg_color)
label.pack(pady=10)# 创建 Entry 输入框
entry = tk.Entry(root, borderwidth=0, relief="flat", bg=root_bg_color, fg="black")  # 背景色与主窗口一致，文本色为黑色
entry.insert(0, "请输入...")
entry.config(width=30)
entry.pack(pady=5)# 运行主循环
root.mainloop()

6. 输入框只显示下边框，宽度和窗口一样宽

import tkinter as tkdef create_entry_with_bottom_border(parent):# 创建一个包含 Entry 和下边框的 Frameframe = tk.Frame(parent, bg="black")# 创建 Entry 输入框frame_entry = tk.Entry(frame, borderwidth=0, relief="flat", bg=root_bg_color)# 重要：fill=tk.X 输入框水平填充满Frame，此时输入框大小和frame大小一致，设置输入宽高失效# ---- pady=(0, 2)：下划线的高度frame_entry.pack(padx=0, pady=(0, 2), fill=tk.X)frame.pack(padx=10, pady=10, fill=tk.X)  # 确保 Frame 宽度填充主窗口return frame_entry# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 只有下边框")
root.geometry("300x200")# 设置主窗口背景色
root_bg_color = "#f0f0f0"  # 主窗口背景色
root.config(bg=root_bg_color)# 创建标签
label = tk.Label(root, text="请输入您的名字:", bg=root_bg_color)
label.pack(pady=10)# 使用自定义函数创建带有下边框的 Entry
entry = create_entry_with_bottom_border(root)
entry.insert(0, "请输入...")  # 设置默认文本# 运行主循环
root.mainloop()

7. 输入框只显示下边框，指定输入框的宽高

import tkinter as tkdef create_entry_with_bottom_border(parent, width, height):# 创建一个包含 Entry 和下边框的 Frameframe = tk.Frame(parent, bg="black", width=width, height=height)frame.pack_propagate(False)  # 防止 Frame 调整其大小以适应内部控件# 创建 Entry 输入框frame_entry = tk.Entry(frame, borderwidth=0, relief="flat", bg=root_bg_color)# 重要：fill=tk.BOTH, expand=True 输入框水平垂直全部填充满Frame，# ---- 此时输入框大小和frame大小一致，设置输入宽高失效，# ---- pady=(0, 2)：下划线的高度frame_entry.pack(padx=0, pady=(0, 2), fill=tk.BOTH, expand=True)frame.pack(padx=10, pady=10)return frame_entry# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 只有下边框")
root.geometry("300x200")# 设置主窗口背景色
root_bg_color = "#f0f0f0"  # 主窗口背景色
root.config(bg=root_bg_color)# 创建标签
label = tk.Label(root, text="请输入您的名字:", bg=root_bg_color)
label.pack(pady=10)# Entry 输入框的宽高
entry_width = 180
entry_height = 20# 使用自定义函数创建带有下边框的 Entry
entry = create_entry_with_bottom_border(root, entry_width, entry_height)
entry.insert(0, "请输入...")  # 设置默认文本# 运行主循环
root.mainloop()

8. 获取输入框内容，清空输入框内容

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("tkinter Entry 使用示例")
root.geometry("300x200")# 创建标签
label = tk.Label(root, text="请输入您的名字:")
label.pack(pady=10)# 创建 Entry 输入框并设置默认文本
entry = tk.Entry(root)
entry.insert(0, "请输入姓名...")  # 设置默认文本
entry.pack(pady=5)# 设置输入框宽度
entry.config(width=30) # 定义获取 Entry 内容的函数
def get_entry_content():content = entry.get()if content == "" or content == "请输入姓名...":result_label.config(text="请先输入内容！")else:print("Entry 内容:", content)result_label.config(text="当前内容: " + content)# 定义清除 Entry 内容的函数
def clear_entry_content():entry.delete(0, tk.END)result_label.config(text="Entry 内容已清除")entry.insert(0, "请输入姓名...")  # 重新设置默认文本# 定义事件处理函数：点击输入框清除默认文本
def on_entry_click(event):if entry.get() == "请输入姓名...":entry.delete(0, tk.END)  # 清空输入框内容# 绑定点击事件到输入框
entry.bind("<Button-1>", on_entry_click)# 创建按钮来获取 Entry 内容
get_button = tk.Button(root, text="获取内容", command=get_entry_content)
get_button.pack(pady=5)# 创建按钮来清除 Entry 内容
clear_button = tk.Button(root, text="清除内容", command=clear_entry_content)
clear_button.pack(pady=5)# 显示当前内容的标签
result_label = tk.Label(root, text="")
result_label.pack(pady=10)# 运行主循环
root.mainloop()

Frame内嵌框架组件

Frame组件常用方法

1. 方法和功能

__init__(self, master=None, cnf={}, **kwargs): 用于初始化一个 Frame 实例。master 参数指定父容器，cnf 和 kwargs 用于设置其他属性。

pack(side=TOP, fill=BOTH, expand=NO, padx=0, pady=0, anchor=CENTER, before=None, after=None): 用于将 Frame 放置到父容器中，按指定的布局选项进行包装。

grid(row=0, column=0, sticky=N+S+E+W, padx=0, pady=0, columnspan=1, rowspan=1, ipadx=0, ipady=0, padx=0, pady=0): 用于将 Frame 放置到父容器中的网格布局中，指定行、列和其他布局参数。

place(x=0, y=0, anchor='nw', bordermode='inside', relx=0.0, rely=0.0, relwidth=1.0, relheight=1.0, width=None, height=None): 用于将 Frame 放置在父容器中的指定位置，支持绝对和相对位置设置。

pack_propagate(False): pack布局时，是否自动调整大小以适应内部组件。

grid_propagate(False): grid布局时，是否自动调整大小以适应内部组件。

config(**kwargs): 用于更新 Frame 的配置选项，类似于 configure 方法。

cget(option): 用于获取 Frame 的指定选项的当前值。

configure(**kwargs): 用于设置 Frame 的选项，如 background、borderwidth 等。

destroy(): 销毁 Frame，并移除其所有子控件。

update(): 更新 Frame 的显示，通常在修改 Frame 的配置后调用。

update_idletasks(): 更新 Frame 的空闲任务队列，确保所有挂起的任务（如布局调整）被处理。

unbind(sequence=None, funcid=None): 解除与指定事件序列相关联的回调函数。

bind(sequence=None, func=None, add=None): 将指定事件序列绑定到回调函数，使得事件发生时调用该函数。

forget(): 从布局管理器中移除 Frame，但不会销毁 Frame 或其子控件。

wait_variable(variable): 等待指定的 Tkinter 变量的值发生变化。

wait_window(window): 等待指定的窗口（通常是对话框）关闭。

2. 常见配置选项

background 或 bg: 设置 Frame 的背景颜色。
borderwidth 或 bd: 设置 Frame 的边框宽度。
relief: 设置 Frame 的边框样式（如 flat、raised、sunken、groove、ridge）。

3. 布局管理

pack(): 控制控件的排列方式。
grid(): 控制控件的网格布局。
place(): 控制控件的位置和大小。

Frame组件示例

1. 创建一个固定大小的 Frame

import tkinter as tkroot = tk.Tk()
root.title("Frame 框架")
root.geometry("300x200")# 创建第一个 Frame
frame = tk.Frame(root, bg="lightgray", width=150, height=100)
frame.pack_propagate(False)  # 防止 Frame 调整其大小以适应内部控件
frame.place(x=20, y=20)label1 = tk.Label(frame, text="Frame")
label1.pack(padx=10, pady=10)root.mainloop()

2. 在 Frame 框架中来排列组件 Grid 布局

import tkinter as tkroot = tk.Tk()
root.title("Grid Layout in Frame")
root.geometry("300x200")# 创建一个 Frame
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)# 在 Frame 中使用 grid 布局。 sticky="e"：右侧对齐
tk.Label(frame, text="姓名:").grid(row=0, column=0, padx=5, pady=5, sticky="e")
tk.Entry(frame).grid(row=0, column=1, padx=5, pady=5)
tk.Label(frame, text="年龄:").grid(row=1, column=0, padx=5, pady=5, sticky="e")
tk.Entry(frame).grid(row=1, column=1, padx=5, pady=5)
# columnspan：跨越2列
tk.Button(frame, text="提交").grid(row=2, column=0, columnspan=2, pady=10)root.mainloop()

3. Pack 布局，平分父窗口

import tkinter as tkroot = tk.Tk()
root.title("Frames with Pack Layout")
root.geometry("300x200")# 创建第一个 Frame
frame1 = tk.Frame(root, bg="lightblue", height=100)
frame1.pack(fill=tk.BOTH, expand=True)  # fill=tk.BOTH 水平垂直方向填充，expand=True外部也填充占满整父窗口label1 = tk.Label(frame1, text="This is Frame 1")
label1.pack(pady=10)# 创建第二个 Frame
frame2 = tk.Frame(root, bg="lightgreen", height=100)
frame2.pack(fill=tk.BOTH, expand=True)label2 = tk.Label(frame2, text="This is Frame 2")
label2.pack(pady=10)root.mainloop()

4. Place 布局，xy坐标指定位置

import tkinter as tkroot = tk.Tk()
root.title("Place Layout Example")
root.geometry("300x200")# 创建一个 Frame
frame = tk.Frame(root, width=200, height=100, bg="lightyellow")
frame.place(x=50, y=50)# 在 Frame 中放置控件
tk.Label(frame, text="This is a frame with 'place' layout", bg="lightyellow").place(x=20, y=20)
tk.Button(frame, text="Click Me").place(x=20, y=60)root.mainloop()

5. Frame 传递参数

import tkinter as tkdef create_frame(parent, bg_color, width, height, name):frame = tk.Frame(parent, bg=bg_color, width=width, height=height)frame.pack_propagate(False)frame.pack(padx=10, pady=10)tk.Label(frame, text=name).pack(pady=10)return frameroot = tk.Tk()
root.title("Frame 传递参数")
root.geometry("300x200")# 创建 Frame 使用函数
create_frame(root, "lightgreen", 200, 100, "参数一 Hello")create_frame(root, "lightcoral", 300, 150, "参数二 Frame")root.mainloop()

6. Frame 右侧打开一个详情页

import tkinter as tk# 创建主窗口
root = tk.Tk()
root.title("右侧详情页")
root.geometry("300x200")  # 设置窗口大小# 在窗口右侧动态添加Frame
def add_frame():# 创建一个新的 Framenew_frame = tk.Frame(root, bg='lightblue', width=150)new_frame.pack_propagate(False)new_frame.pack(side=tk.RIGHT, fill=tk.Y)# 当前Frame没关闭，不能操作主窗口new_frame.grab_set()tk.Label(new_frame, text="我是详情页", bg='lightblue').pack(pady=40)# 关闭详情页tk.Button(new_frame, text="关闭", command=new_frame.destroy).pack()# 创建一个 Frame 用于放按钮
frame = tk.Frame(root, width=100)
frame.pack(side=tk.LEFT, fill=tk.Y)# 打开详情页按钮
add_frame_button = tk.Button(frame, text="打开详情页", command=add_frame)
add_frame_button.place(x=20, y=50)# 运行主循环
root.mainloop()

Canvas画布组件

Canvas组件常用方法

创建 Canvas 对象

canvas = Canvas(parent, width=200, height=100)
parent 是 Canvas 的父组件（通常是 Tk 或 Frame）。
width 和 height 是画布的宽度和高度。

绘制直线

canvas.create_line(x1, y1, x2, y2, options...)
绘制从 (x1, y1) 到 (x2, y2) 的直线。

绘制矩形

canvas.create_rectangle(x1, y1, x2, y2, options...)
绘制一个矩形，左上角坐标为 (x1, y1)，右下角坐标为 (x2, y2)。

绘制椭圆形

canvas.create_oval(x1, y1, x2, y2, options...)
绘制一个椭圆，包围矩形的区域是 (x1, y1) 到 (x2, y2)。

绘制多边形

canvas.create_polygon(x1, y1, x2, y2, ..., options...)
绘制一个由多个顶点组成的多边形。

绘制文本

canvas.create_text(x, y, text="文本", options...)
在 (x, y) 位置绘制文本。

绘制图像

canvas.create_image(x, y, image=image, options...)
在 (x, y) 位置显示图像，其中 image 是一个 PhotoImage 或 BitmapImage 对象。

绘制图形时的参数说明

canvas.create_*(x1, y1, x2, y2, fill, outline, width, font)
fill: 设置图形的填充颜色，例如 fill='red'
outline: 设置图形的边框颜色，例如 outline='black'
width: 设置图形的边框宽度，例如 width=2
font: 设置文本的字体，例如 font=('Helvetica', 12)

获取图形标签

tags = canvas.gettags(tag_or_id)
获取图形的标签。

删除图形

canvas.delete(tag_or_id)
删除指定 ID 或标签的图形。ID通过create_*方法会返回一个图形的唯一 ID。

移动图形

canvas.move(tag_or_id, x, y)
将指定 ID 或标签的图形移动 (x, y) 像素。

调整图形属性

canvas.itemconfig(tag_or_id, option=value)
调整图形的属性，如颜色、字体等。

获取或设置图形位置

coords = canvas.coords(tag_or_id)
取指定图形的坐标信息。

画布事件绑定

canvas.bind("<Button-1>", callback_function)
绑定鼠标左键单击事件到 callback_function。

画布解绑事件

canvas.unbind("<Button-1>")
解绑鼠标左键单击事件。

图形事件绑定

canvas.tag_bind(tag, sequence, callback)
绑定事件序列到标签 tag 的图形项上，并指定回调函数 callback。

图形事件解绑

canvas.tag_unbind(tag, sequence)
解除标签 tag 上的事件序列的绑定。

缩放图形

canvas.scale(tag_or_id, x, y, scale_x, scale_y)
以 (x, y) 为中心缩放指定 ID 或标签的图形项，按比例 scale_x 和 scale_y。

旋转图形

canvas.rotate(tag_or_id, angle, x, y)
以 (x, y) 为中心旋转指定 ID 或标签的图形项 angle 度。

获取图形的边界框

canvas.bbox(tag_or_id)
返回指定 ID 或标签的图形项的边界框 (x1, y1, x2, y2)。

将图形提升到画布最上层

canvas.tag_raise(tag_or_id)

将图形降低到画布最下层

canvas.tag_lower(tag_or_id)

获取画布上所有的图形的id列表

canvas.find_all()

根据标签或 ID 查找图形

canvas.find_withtag(tag_or_id)

更新画布

canvas.update()
强制更新画布显示，处理所有挂起的事件和界面更新。

设置画布滚动区域

canvas.configure(scrollregion=(x1, y1, x2, y2))

坐标说明

x1: 左边的左右
x2: 左边的上下
y1: 右边的左右
y2: 右边的上下

Canvas组件示例

1.创建一个画布，显示画布边框

import tkinter as tkroot = tk.Tk()
root.title("画布")
root.geometry("300x200")# 创建画布
canvas = tk.Canvas(root, width=280, height=180, bg="white", borderwidth=2, relief="solid")
canvas.pack_propagate(False)
canvas.pack()root.mainloop()

2. 绘制图形

import tkinter as tkroot = tk.Tk()
root.title("画布")
root.geometry("320x220")canvas = tk.Canvas(root, width=300, height=200, bg="white", borderwidth=2, relief="solid")# 绘制直线 x1，左边的左右 x2:左边上下，y1:右边的左右  y2:右边上下
canvas.create_line(10, 10, 290, 10, fill="blue", width=2)
# 绘制矩形 x1，左边的左右 x2:左边上下，y1:右边的左右  y2:右边上下
canvas.create_rectangle(10, 20, 290, 50, outline="black", fill="red")
# 绘制椭圆形 x1，左边的左右 x2:左边上下，y1:右边的左右  y2:右边上下
canvas.create_oval(10, 60, 290, 100, outline="green", fill="yellow")
# 绘制文本 x:水平，y:垂直
canvas.create_text(100, 120, text="Hello, Tkinter!", font=("Arial", 16))canvas.pack()root.mainloop()

3. 绘制图像，图片不变形百分比缩放

import tkinter as tk
from PIL import Image, ImageTkdef resize_image(image, max_width, max_height):# 获取图像的原始尺寸original_width, original_height = image.size# 计算调整后的宽度和高度ratio = min(max_width / original_width, max_height / original_height)new_width = int(original_width * ratio)new_height = int(original_height * ratio)# 调整图像大小return image.resize((new_width, new_height), Image.LANCZOS)root = tk.Tk()
root.title("画布")
root.geometry("320x220")# 创建画布
canvas = tk.Canvas(root, width=300, height=200, bg="white", borderwidth=2, relief="solid")
canvas.pack()# 调整图像大小，百分比缩放
new_img_width = 100  # 新的宽度
new_img_height = 100  # 新的高度
# 加载原始图片
original_image = Image.open("static/background/a.jpg")# 调整图片大小以适应画布
resized_image = resize_image(original_image, new_img_width, new_img_height)
photo = ImageTk.PhotoImage(resized_image)# 在 Canvas 上绘制图像
canvas.create_image(150, 100, image=photo)root.mainloop()