Python5-tkinter库

---

1.tkinter库介绍

Tkinter是Python中最常用的图形用户界面（GUI）库之一。它是Python标准库的一部分，因此不需要单独安装。Tkinter提供了一组工具和控件，用于创建各种GUI应用程序，从简单的对话框到复杂的应用程序。

下面是一些Tkinter库的主要特性和组件：

1. 简单易用：Tkinter提供了简单且易于使用的接口，使得创建GUI应用程序变得容易上手。
2. 跨平台：Tkinter是跨平台的，可以在多个操作系统上运行，包括Windows、macOS和Linux。
3. 控件：Tkinter提供了多种预定义的GUI控件，例如按钮、标签、文本框、列表框、复选框等。这些控件可以用来构建用户界面。
4. 布局管理：Tkinter提供了几种布局管理器，用于管理控件的位置和大小。常用的布局管理器包括Pack、Grid和Place。
5. 事件处理：Tkinter使用事件模型处理用户操作和与控件的交互。可以为控件绑定事件处理函数，以响应用户触发的事件，例如点击按钮或键盘输入。
6. 自定义样式：Tkinter允许自定义GUI应用程序的外观和样式，包括控件的颜色、字体、大小等。
7. 对话框：Tkinter提供了几种常用的对话框，例如文件选择对话框、消息框、颜色选择对话框等。这些对话框可以方便地与用户进行交互。
8. 绘图功能：Tkinter还提供了绘制图形和绘制图像的功能，可以用于创建简单的绘图应用程序。

使用Tkinter创建GUI应用程序的基本步骤包括导入Tkinter模块、创建主窗口、添加控件、设置事件处理函数等。

以下是一个简单的Tkinter应用程序示例，展示了一个包含按钮和标签的窗口：

from tkinter import *

def button_click():
    label.config(text="Hello, Tkinter!")

root = Tk()
root.title("Tkinter Example")

button = Button(root, text="Click Me", command=button_click)
button.pack()

label = Label(root, text="Welcome to Tkinter")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.tkinter布局管理器

Tkinter提供了三种常用的布局管理器，它们分别是Pack、Grid和Place。这些布局管理器可以帮助您在Tkinter应用程序中定位和排列控件。

2.1 Pack布局管理器

Pack布局管理器采用块的方式组织组件。pack根据组件创建生成的顺序将子组件添加到父组件中，通过设置选项可以控制子组件的位置。调用子组件的方法pack()，则子组件在其父组件中采用Pack布局。

当使用Pack布局管理器时，可以设置以下选项来指定部件的排列方式：

1. side（可选值：TOP、BOTTOM、LEFT、RIGHT）：
   该选项指定部件相对于其父容器的位置。可以使用side参数来设置部件在父容器中的放置位置。例如，side=TOP将部件放置在父容器的顶部，side=LEFT将部件放置在父容器的左侧。
2. fill（可选值：NONE、X、Y、BOTH）：
   该选项指定部件在垂直和水平方向上是否填充可用空间。使用fill参数可以设置部件在可用空间中的填充方式。例如，fill=X将部件在水平方向上填充可用空间，fill=BOTH将部件在垂直和水平方向上填充可用空间。
3. expand（可选值：0、1）：
   该选项指定部件是否可以扩展以填充额外的可用空间。使用expand参数可以设置部件是否可以扩展。例如，expand=1允许部件在可用空间中扩展，expand=0则不允许部件扩展。
4. padx、pady：
   这两个选项用于指定部件周围的水平和垂直空白区域的大小。可以使用padx和pady参数来设置部件周围的空白区域的大小。例如，padx=10将在部件左右两侧增加10个像素的空白区域。

这些选项可以与部件的pack()方法一起使用，例如：

widget.pack(side=TOP, fill=X, padx=10, pady=10)
1

这将把部件放置在父容器的顶部，水平方向上填充可用空间，左右两侧各增加10个像素的空白区域。

下面是pack几何布局管理器设计的用户登录界面：

from tkinter import *

root = Tk()
root.title("登录")

# 界面分为3个Frame
f1 = Frame(root)
f1.pack()
f2 = Frame(root)
f2.pack()
f3 = Frame(root)
f3.pack()

# f1放置第一行标签和文本框
Label(f1, text="用户名").pack(side=LEFT)
Entry(f1).pack(side=LEFT)

Label(f2, text="密码").pack(side=LEFT)
Entry(f2,show="*").pack(side=LEFT)

Button(f3, text="登录").pack(side=RIGHT)
Button(f3, text="取消").pack(side=RIGHT)

root.mainloop() 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.2 grid布局管理器

Grid布局管理器是一种用于用户界面设计的布局管理器，它将组件放置在一个二维的网格中。在这个网格中，组件可以被指定为占据一个或多个网格单元，从而实现灵活的布局。

调用子组件的grid()方法，则该子组件在父组件中采用grid布局。

以下是一些常用的Grid布局选项：

1. row：用于指定组件所在的行索引，从0开始计数。例如，row=0表示组件位于第一行。
2. column：用于指定组件所在的列索引，从0开始计数。例如，column=1表示组件位于第二列。
3. rowspan：用于指定组件跨越的行数。例如，rowspan=2表示组件占据当前行和下一行。
4. columnspan：用于指定组件跨越的列数。例如，columnspan=3表示组件占据当前列和接下来的两列。
5. sticky：用于指定组件在单元格中的对齐方式。可以使用N、S、E、W或它们的组合来表示北、南、东、西方向的对齐方式。例如，sticky=N+W表示组件在单元格的左上角对齐。
6. padx：用于指定组件在水平方向上的内边距（即左右间距）。
7. pady：用于指定组件在垂直方向上的内边距（即上下间距）。

下面是grid几何布局管理器设计的用户登录界面：

from tkinter import *

root = Tk();
root.title("登录")

Label(root, text="用户名").grid(row=0, column=0)  # 用户名标签放置第0行第0列
Entry(root).grid(row=0, column=1, columnspan=2)  # 用户名文本框放置第0行第1列，跨2列

Label(root, text="密  码").grid(row=1, column=0)  # 密码标签放置第1行第0列
Entry(root, show="*").grid(row=1, column=1, columnspan=2)  # 密码文本框放置第1行第1列，跨2列

Button(root, text="登录").grid(row=3, column=1, sticky=E)  # 登录按钮右侧贴紧
Button(root, text="取消").grid(row=3, column=2, sticky=W)  # 取消按钮左侧贴紧

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.3 place布局管理器

在Tkinter中，Place布局管理器允许您通过指定组件的绝对位置来放置组件。与其他布局管理器不同，Place布局管理器不依赖于容器的网格或自动调整大小。

调用子组件的place()方法，则该子组件在其父组件中采用place布局。

以下是Place布局管理器的一些选项：可以直接给选项复制或者以字典变量加以修改。

1. x：用于指定组件的x坐标（水平位置）。以容器的左上角为参考点，x=0表示最左边的位置。
2. y：用于指定组件的y坐标（垂直位置）。以容器的左上角为参考点，y=0表示最上面的位置。
3. anchor：用于指定组件相对于其位置的锚点。可以使用常量字符串（如"N"、“S”、“E”、“W”）或它们的组合来表示锚点位置。例如，"NW"表示组件的左上角位于指定的坐标。
4. width：用于指定组件的宽度。
5. height：用于指定组件的高度。
6. relx：用于指定组件相对容器宽度的水平位置。可以使用0.0到1.0之间的值，其中0.0表示最左边，1.0表示最右边。
7. rely：用于指定组件相对容器高度的垂直位置。可以使用0.0到1.0之间的值，其中0.0表示最上面，1.0表示最下面。
8. relwidth：用于指定组件相对容器宽度的宽度比例。可以使用0.0到1.0之间的值，其中1.0表示与容器相同的宽度。
9. relheight：用于指定组件相对容器高度的高度比例。可以使用0.0到1.0之间的值，其中1.0表示与容器相同的高度。

下面是grid几何布局管理器设计的用户登录界面：

from tkinter import *

root = Tk();
root.title("登录")

root['width'] = 200
root['height'] = 80

Label(root, text="用户名", width=6).place(x=1, y=1)  # 用户名标签，绝对坐标(1,1)
Entry(root, width=20).place(x=45, y=1)  # 用户名文本框，绝对坐标(45,1)

Label(root, text="密  码", width=6).place(x=1, y=20)  # 密码标签，绝对坐标(1,20)
Entry(root, width=20, show="*").place(x=45, y=20)  # 密码文本框，绝对坐标(45,20)

Button(root, text="登录", width=8).place(x=40, y=40)  # 登录按钮，绝对坐标(40,40)
Button(root, text="取消", width=8).place(x=110, y=40)  # 取消按钮，绝对坐标(110,40)

root.mainloop()  # 调用组件mainloop()方法，进入事件循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.tkinter事件处理

在Tkinter中，可以使用事件处理程序来响应用户的交互或特定的事件。以下是处理Tkinter中事件的一般步骤：

1.定义事件处理函数：首先，您需要定义一个函数来处理特定的事件。这个函数将在事件发生时被调用。函数应该接受一个参数，通常被命名为event，用于访问与事件相关的信息。

# 普通事件处理函数
def handlerName(event):
	# 函数体
  
# 类方法
def handlerName(self, event):
    # 方法体
1
2
3
4
5
6
7

2.绑定事件处理函数：接下来，您需要将事件处理函数与相应的组件和事件进行绑定。可以使用组件的bind()方法来实现绑定。bind()方法接受两个参数，第一个参数是表示事件的字符串，第二个参数是事件处理函数。

3.处理事件：一旦事件处理函数被绑定到组件上，当事件发生时，函数将自动被调用。

from tkinter import * 

root = Tk();
root.title("事件处理")


def printEvent(event):  # 事件处理函数
    print('当前坐标位置：', event.x, event.y)


root.bind('<Button-1>', printEvent)  # 单击鼠标左键
root.mainloop()  # 调用组件的mainloop方法，进入事件循环
1
2
3
4
5
6
7
8
9
10
11
12

---

关于事件的绑定：

1.创建组件对象实例时指定：

在创建组件对象实例时，可以通过其命名参数command指定事件处理函数。

2.实例绑定：

调用组件对象实例方法bind()，可以为指定组件实例绑定事件。如上面的例子。

3.类绑定：

使用bind_class()方法将事件处理函数与特定组件类（例如按钮、标签等）的所有组件实例绑定。这意味着事件处理函数将应用于该类的所有组件实例。

# 将button_click函数绑定到所有按钮组件的鼠标左键点击事件。
root.bind_class("Button", "<Button-1>", button_click)
1
2

4.程序界面绑定：

使用bind_all()方法将事件处理函数与所有事件绑定。在这种情况下，事件处理函数将被应用于所有组件和所有事件。

# 将quit_application函数绑定到按下"Ctrl+q"组合键的事件，无论焦点在哪个组件上，都会触发该事件。
root.bind_all("<Control-q>", quit_application)
1
2

4.常用组件

4.1 Label标签

Label标签是用于显示文本或图像的组件。

设置标签的属性：

• 可以使用标签的属性和方法来设置其样式和行为。
• 一些常用的属性包括：
  • text：设置或获取标签显示的文本内容。
  • image：设置或获取标签显示的图像对象。
  • font：设置标签的字体。
  • foreground或fg：设置标签文本的颜色。
  • background或bg：设置标签的背景颜色。
  • justify：设置文本对齐方式（“left”、“center”、“right”）。
  • padx和pady：设置标签的内边距。
  • relief：设置标签的边框样式。
  • width和height：设置标签的宽度和高度。

以下是一个创建Label标签、设置Label标签属性的示例：

from tkinter import *

root = Tk()
root.title("Label示例")

w = Label(root, text="姓名")  # 创建Label组件对象，显示文本为"姓名"
w.config(width=20, bg='black', fg='white')  # 设置宽度、背景色、前景色
w['anchor'] = E  # 设置停靠方式为右对齐
w.pack()  # 调用pack()方法调整显示位置和大小

root.mainloop()  # 调用组件mainloop()方法，进入事件循环
1
2
3
4
5
6
7
8
9
10
11

4.2 LabelFrame

LabelFrame是一个带有标题的框架，用于组织和分组其他组件。它提供了一种将相关的组件放置在一起并为它们提供标题的方式。

设置LabelFrame的属性：

• 可以使用LabelFrame的属性和方法来设置其样式和行为。
• 一些常用的属性包括：
  • text：设置或获取LabelFrame的标题文本。
  • font：设置LabelFrame的标题字体。
  • foreground或fg：设置LabelFrame的标题颜色。
  • background或bg：设置LabelFrame的背景颜色。
  • relief：设置LabelFrame的边框样式。
  • width和height：设置LabelFrame的宽度和高度。

以下是一个创建LabelFrame、设置LabelFrame属性的示例：

from tkinter import *

root = Tk()
root.title("LabelFrame")

lf = LabelFrame(root, text="组1")  # 创建LabelFrame组件对象
lf.pack()  # 调用pack()方法调整显示位置和大小

Button(lf, text="确定").pack(side=LEFT)  # “确定”按钮，左停靠
Button(lf, text="取消").pack(side=LEFT)  # “取消”按钮，左停靠

root.mainloop()  # 调用组件mainloop()方法，进入事件循环
1
2
3
4
5
6
7
8
9
10
11
12

4.3 Button

Button（按钮）是用于触发特定动作或执行特定功能的交互式组件。它允许用户点击按钮来触发与按钮关联的事件处理函数。

设置Button的属性：

• 可以使用Button的属性和方法来设置其样式和行为。
• 一些常用的属性包括：
  • text：设置或获取按钮显示的文本内容。
  • command：设置按钮关联的事件处理函数。
  • font：设置按钮的字体。
  • foreground或fg：设置按钮文本的颜色。
  • background或bg：设置按钮的背景颜色。
  • relief：设置按钮的边框样式。
  • width和height：设置按钮的宽度和高度。

现在我们再回头看tkinter库介绍的代码应该就能看懂了。

4.4 Message

Message（消息）是用于显示多行文本的组件。它类似于Label组件，但可以自动换行，并且适用于显示较长的文本内容。

设置Message的属性：

• 可以使用Message的属性和方法来设置其样式和行为。
• 一些常用的属性包括：
  • text：设置或获取Message显示的文本内容。
  • font：设置Message的字体。
  • foreground或fg：设置Message文本的颜色。
  • background或bg：设置Message的背景颜色。
  • width：设置Message的宽度。
  • justify：设置文本对齐方式（“left”、“center”、“right”）。

以下是一个创建Message、设置Message属性的示例：

from tkinter import *

root = Tk()
root.title("Message")

w = Message(root, bg='black', fg='white')  # 创建Message组件对象
w.config(text="内容显示在一个宽高比为150%的消息框中")  # 设置显示文本
w['anchor'] = W  # 设置停靠方式为左对齐
w.pack()  # 调用pack()方法调整显示位置和大小

root.mainloop()  # 调用mainloop()方法进入事件循环
1
2
3
4
5
6
7
8
9
10
11

4.5 Entry（单行文本框）与StringVar类

Entry（输入框）是用于接收用户输入的文本框组件。它允许用户在应用程序中输入和编辑文本。

获取和设置Entry的值：

• 可以使用get()方法来获取Entry中当前输入的文本值。
• 使用set()方法可以设置Entry的文本值。
• 示例：
  • 获取值：entry_value = entry.get()
  • 设置值：entry.set("New value")

import tkinter as tk


def get_entry_value():
    value = entry.get()
    print("Entry value:", value)


root = tk.Tk()
entry = tk.Entry(root)
entry.pack()

button = tk.Button(root, text="Get Value", command=get_entry_value)
button.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在Tkinter中，StringVar是一个变量类，用于在GUI应用程序中跟踪和管理字符串类型的变量。它是Tkinter提供的一种特殊的变量类型，用于与用户界面组件（如Entry、Label等）进行绑定。当StringVar中的值发生变化时，与之绑定的组件也会自动更新。

绑定StringVar到组件：

• 可以使用StringVar对象来绑定到Tkinter组件，例如Label或Entry。
• 在绑定过程中，StringVar中的值将自动与组件的文本内容进行同步。
• 可以使用get()方法来获取StringVar中的值。
• 使用set()方法可以设置StringVar的值。

示例：

import tkinter as tk


def update_label_text():
    new_text = entry.get()
    string_var.set(new_text)


root = tk.Tk()

# 创建一个StringVar对象
string_var = tk.StringVar()

# 设置StringVar的初始值
string_var.set("Hello, StringVar!")

# 创建一个Label组件，并将其与StringVar绑定
label = tk.Label(root, textvariable=string_var)
label.pack()

# 创建一个Entry组件
entry = tk.Entry(root)
entry.pack()

# 创建一个按钮，点击按钮时更新Label的文本
button = tk.Button(root, text="Update Label", command=update_label_text)
button.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4.6 Text（多行文本框）

Text（文本）是一个用于显示和编辑多行文本的组件。它提供了一个可滚动的区域，可以用于输入和显示大段的文本内容。

获取和设置Text的内容：

• 您可以使用get()方法来获取Text中当前显示的文本内容。
• 使用insert()方法可以插入文本到Text中。
• 使用delete()方法可以删除指定范围内的文本。

设置Text的属性：

• Text组件具有许多属性和方法，用于设置其外观和行为。
• 一些常用的属性包括：
  • font：设置Text的字体。
  • foreground或fg：设置文本的颜色。
  • background或bg：设置Text的背景颜色。
  • width：设置Text的宽度。
  • height：设置Text的高度。
  • wrap：设置文本的换行方式（“none”、“char”、“word”）。

import tkinter as tk
from tkinter import filedialog


def open_file():
    file_path = filedialog.askopenfilename()
    if file_path:
        with open(file_path, "r") as file:
            content = file.read()
            text.delete("1.0", tk.END)
            text.insert(tk.END, content)


def save_file():
    file_path = filedialog.asksaveasfilename(defaultextension=".txt")
    if file_path:
        with open(file_path, "w") as file:
            content = text.get("1.0", tk.END)
            file.write(content)


root = tk.Tk()

text = tk.Text(root, width=40, height=10)
text.pack()

open_button = tk.Button(root, text="Open", command=open_file)
open_button.pack()

save_button = tk.Button(root, text="Save", command=save_file)
save_button.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

上面代码中包括一个Text组件用于显示和编辑文本内容，以及两个按钮用于打开和保存文件。

open_file函数使用filedialog模块中的askopenfilename对话框来选择要打开的文件。如果文件路径有效，它会读取文件的内容并将其插入到Text组件中。

save_file函数使用filedialog模块中的asksaveasfilename对话框来选择要保存的文件路径。如果文件路径有效，它会获取Text组件的内容，并将其写入到文件中。

通过点击"Open"按钮，用户可以选择并打开一个文件，在Text组件中显示文件的内容。点击"Save"按钮时，用户可以选择文件的保存位置，并将Text组件的内容保存到文件中。

4.7 Radiobutton（单选按钮）

Radiobutton（单选按钮）是一种用于在多个选项中选择单个选项的组件。每个Radiobutton都代表一个选项，并且在同一组Radiobutton中只能选择一个选项。Radiobutton可以显示文本，也可以显示图片。

以下是Radiobutton组件的使用示例：

import tkinter as tk


def show_selection():
    selected_option = selected.get()
    label.config(text="Selected option: " + str(selected_option))


root = tk.Tk()

# 创建一个IntVar变量用于跟踪选项的值
selected = tk.IntVar()

# 创建Radiobutton组件，并将其与IntVar和选项值进行绑定
option1 = tk.Radiobutton(root, text="Option 1", variable=selected, value=1)
option1.pack()

option2 = tk.Radiobutton(root, text="Option 2", variable=selected, value=2)
option2.pack()

option3 = tk.Radiobutton(root, text="Option 3", variable=selected, value=3)
option3.pack()

# 创建一个按钮，点击按钮时显示选择的选项
button = tk.Button(root, text="Show Selection", command=show_selection)
button.pack()

# 创建一个Label用于显示选择的选项
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

上述示例中，我们创建了三个Radiobutton组件，每个组件代表一个选项。我们使用text参数设置每个Radiobutton的标签文本。每个Radiobutton都与一个共享的IntVar类型变量selected进行绑定，并使用value参数设置每个选项的值。

点击"Show Selection"按钮时，show_selection函数会获取selected变量的值，并将其显示在Label组件中。

注意，同一组的Radiobutton组件应该使用相同的variable参数来绑定到同一个变量，以确保它们是互斥的，即只能选择一个选项。

4.8 Checkbutton（复选框）

Checkbutton（复选框）是一种用于选择或取消选择一个或多个选项的组件。与Radiobutton不同，Checkbutton允许同时选择多个选项。Checkbutton可以显示文本，也可以显示图像。

以下是Checkbutton组件的使用示例：

import tkinter as tk

def show_selection():
    selected_options = []
    for option, var in options.items():
        if var.get() == 1:
            selected_options.append(option)
    label.config(text="Selected options: " + ", ".join(selected_options))

root = tk.Tk()

# 创建一个字典用于存储选项和对应的IntVar变量
options = {}

# 创建Checkbutton组件，并将其与IntVar和选项值进行绑定
option1_var = tk.IntVar()
option1 = tk.Checkbutton(root, text="Option 1", variable=option1_var)
option1.pack()
options["Option 1"] = option1_var

option2_var = tk.IntVar()
option2 = tk.Checkbutton(root, text="Option 2", variable=option2_var)
option2.pack()
options["Option 2"] = option2_var

option3_var = tk.IntVar()
option3 = tk.Checkbutton(root, text="Option 3", variable=option3_var)
option3.pack()
options["Option 3"] = option3_var

# 创建一个按钮，点击按钮时显示选择的选项
button = tk.Button(root, text="Show Selection", command=show_selection)
button.pack()

# 创建一个Label用于显示选择的选项
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

在上述示例中，我们创建了三个Checkbutton组件，每个组件代表一个选项。我们使用text参数设置每个Checkbutton的标签文本。每个Checkbutton都与一个独立的IntVar类型变量进行绑定，并将其存储在字典options中，以便在后续的处理中使用。

点击"Show Selection"按钮时，show_selection函数会遍历options字典，检查每个选项对应的变量的值。如果值为1，表示选项被选中，将其添加到selected_options列表中。最后，函数将选择的选项列表显示在Label组件中。

4.9 Listbox（列表框）

Listbox（列表框）是一种用于显示和选择列表项的组件。它允许用户从一个或多个可选项中选择一个或多个项。

以下是Listbox组件的使用示例：

import tkinter as tk


def show_selection():
    selected_indices = listbox.curselection()
    selected_items = [listbox.get(index) for index in selected_indices]
    label.config(text="Selected items: " + ", ".join(selected_items))


root = tk.Tk()

# 创建一个Listbox组件
listbox = tk.Listbox(root, selectmode=tk.MULTIPLE)
listbox.pack()

# 向Listbox中添加选项
options = ["Option 1", "Option 2", "Option 3", "Option 4"]
for option in options:
    listbox.insert(tk.END, option)

# 创建一个按钮，点击按钮时显示选择的选项
button = tk.Button(root, text="Show Selection", command=show_selection)
button.pack()

# 创建一个Label用于显示选择的选项
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在上述示例中，创建了一个Listbox组件，并使用selectmode参数设置其选择模式为tk.MULTIPLE，以允许多个选项的选择。通过使用insert()方法将选项添加到Listbox中。在这个示例中，我们使用tk.END作为索引，将选项添加到Listbox的末尾。

点击"Show Selection"按钮时，show_selection函数会获取当前选择的项的索引列表，然后使用get()方法获取每个索引对应的选项内容，并将选择的选项内容显示在Label组件中。

注意，Listbox的选择模式可以是tk.SINGLE（单选模式）或tk.MULTIPLE（多选模式）。

4.10 OptionMenu（选择项）

OptionMenu（选项菜单）是一种用于选择单个选项的下拉菜单组件。它允许用户从一个预定义的选项列表中选择一个选项。

以下是OptionMenu组件的使用示例：

import tkinter as tk


def show_selection(selected_option):
    label.config(text="Selected option: " + selected_option)


root = tk.Tk()

# 创建一个StringVar变量用于跟踪选项的值
selected = tk.StringVar()

# 创建OptionMenu组件，并将其与StringVar和选项列表进行绑定
option_menu = tk.OptionMenu(root, selected, "Option 1", "Option 2", "Option 3")
option_menu.pack()

# 创建一个按钮，点击按钮时显示选择的选项
button = tk.Button(root, text="Show Selection", command=lambda: show_selection(selected.get()))
button.pack()

# 创建一个Label用于显示选择的选项
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在上述示例中，创建了一个OptionMenu组件，其中包含预定义的选项列表。我们使用StringVar类型的变量selected来跟踪当前选择的选项。点击"Show Selection"按钮时，show_selection函数会获取selected变量的值，并将其显示在Label组件中。

注意，OptionMenu的第1个参数是一个变量，用于存储当前选择的选项的值。后续的参数是选项列表，您可以根据需要添加或修改这些选项。

4.11 Scale（移动滑块）

Scale（滑动条）是一种用于选择数值范围的滑动条组件。它允许用户通过拖动滑块来选择一个数值。

以下是Scale组件的使用示例：

import tkinter as tk


def show_value(value):
    label.config(text="Selected value: " + str(value))


root = tk.Tk()

# 创建一个Scale组件，并设置其取值范围和初始值
scale = tk.Scale(root, from_=0, to=100, orient=tk.HORIZONTAL, command=show_value)
scale.pack()

# 创建一个Label用于显示选择的值
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上述示例中，创建了一个水平方向的Scale组件，其取值范围从0到100。我们使用from_和to参数设置取值范围。每当滑块的位置发生变化时，show_value函数会被调用，并将当前的数值作为参数传递给它。函数将数值转换为字符串，并将其显示在Label组件中。

可以根据需要设置Scale的方向（水平或垂直），以及取值范围和初始值。您还可以自定义Scale的外观，例如设置长度、颜色、刻度等。另外，可以使用get()方法获取当前Scale的值，或使用set(value)方法设置Scale的值。

4.12 Toplevel（顶级窗口）

Toplevel是一个顶级窗口（Top-level window）组件，它可以作为主窗口的子窗口或独立的顶级窗口。它用于创建一个新的窗口，可以包含其他组件和自定义布局。

以下是Toplevel组件的使用示例：

import tkinter as tk


def open_new_window():
    new_window = tk.Toplevel(root)
    new_window.title("New Window")
    new_window.geometry("200x200")

    label = tk.Label(new_window, text="This is a new window")
    label.pack()


root = tk.Tk()

button = tk.Button(root, text="Open New Window", command=open_new_window)
button.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Toplevel窗口是独立的窗口，它可以在主窗口之外显示，并具有自己的标题栏和边框。

4.13 ttk（子模块控件）

tkinter模块包含子模块ttk，ttk包含了tkinter缺少的基本控件Combobox、Progressbar、Notebook、Treeview等，这使得tkinter更实用。此外ttk还支持控件呈现操作系统本地化风格，在Windows下更像Windows，在Mac OS X下想Mac，在Linux下像Linux。

ttk提供了一组主题化的组件，用于创建具有现代外观的用户界面。ttk模块扩展了Tkinter，提供了更丰富的组件和样式选项。以下是ttk的使用示例：

import tkinter as tk
from tkinter import ttk


def handle_selection(event):
    selected_item = treeview.focus()
    item_text = treeview.item(selected_item)["text"]
    label.config(text="Selected item: " + item_text)


root = tk.Tk()

# 创建一个ttk风格的Treeview组件
treeview = ttk.Treeview(root)
treeview.pack()

# 添加根节点
root_node = treeview.insert("", "end", text="Root")

# 添加子节点
child1 = treeview.insert(root_node, "end", text="Child 1")
child2 = treeview.insert(root_node, "end", text="Child 2")

# 添加子节点的子节点
treeview.insert(child1, "end", text="Grandchild 1")
treeview.insert(child1, "end", text="Grandchild 2")

# 绑定选择事件处理函数
treeview.bind("<<TreeviewSelect>>", handle_selection)

# 创建一个Label用于显示选择的节点
label = tk.Label(root, text="")
label.pack()

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

上面代码中创建了一个ttk风格的Treeview组件，并将其添加到主窗口中。使用insert()方法来添加根节点和子节点到Treeview中。每个节点都有一个唯一的标识符，可以通过该标识符进行引用和操作。还创建了一个选择事件处理函数handle_selection()，它会在用户选择Treeview中的节点时被调用。通过focus()方法获取当前选中的节点，然后使用item()方法获取节点的属性，其中包括节点的文本内容。最后，创建了一个Label组件，用于显示选择的节点的文本内容。

5.对话框

对话框用于用户和检索信息。tkinter模块中的子模块 messagebox、filedialog、colorchooser、simpledialog 包括一些常用的预定义的对话框，用户也可以通过继承TopLevel创建自定义对话框。

5.1 通用消息对话框

import tkinter as tk
from tkinter import messagebox

# 1.信息框（Information Box）对话框
messagebox.showinfo("信息", "这是一个信息框对话框")

# 2.警告框（Warning Box）对话框
messagebox.showwarning("警告", "这是一个警告框对话框")

# 3.错误框（Error Box）对话框
messagebox.showerror("错误", "这是一个错误框对话框")

# 4.提问框（Question Box）对话框
# askquestion
result = messagebox.askquestion("提问", "你是否同意？")
if result == 'yes':
    print("用户选择了同意")
else:
    print("用户选择了不同意")

# ok cancel
result = messagebox.askokcancel("询问", "你是否要继续？")
if result:
    print("用户选择了继续")
else:
    print("用户选择了取消")
    

# askyesno
result = messagebox.askyesno("询问", "你是否同意？")
if result:
    print("用户选择了同意")
else:
    print("用户选择了不同意")
    
    
# askyesnocancel
result = messagebox.askyesnocancel("询问", "你是否要保存？")
if result is None:
    print("用户选择了取消")
elif result:
    print("用户选择了是")
else:
    print("用户选择了否")
    
# askretrycancel
result = messagebox.askretrycancel("询问", "操作失败，是否重试？")
if result:
    print("用户选择了重试")
else:
    print("用户选择了取消")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

第一个参数是标题、第二个参数是对话框显示内容、第三个参数options可选

5.2 文件对话框

tkinter.filedialog模块中包含如下若干用于打开文件对话框的函数。

import tkinter as tk
from tkinter import filedialog

# 1.选择目录
dir_path = filedialog.askdirectory()
print("选择的目录路径：", dir_path)

# 2.选择文件路径 askopenfilename askopenfilenames
file_path = filedialog.askopenfilename()
print("选择的文件路径：", file_path)

# 3.保存文件对话框
file_path = filedialog.asksaveasfilename()
print("保存的文件路径：", file_path)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.3 颜色选择对话框

使用colorchooser模块提供的函数来创建颜色选择对话框。

import tkinter as tk
from tkinter import colorchooser

# 创建主窗口
root = tk.Tk()
root.withdraw()  # 隐藏主窗口

# 打开颜色选择对话框
color = colorchooser.askcolor()

# 处理选择的颜色
if color[1]:  # 如果用户选择了颜色
    selected_color = color[1]
    print("选择的颜色：", selected_color)
else:
    print("未选择颜色")

# 关闭主窗口
root.destroy()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

选择的颜色以元组的形式返回，其中包含两个值：第一个值是颜色的RGB值，第二个值是颜色的十六进制表示。我们通过检查第二个值，确定用户是否选择了颜色。如果选择了颜色，我们将选定的颜色存储在selected_color变量中，并进行相应的处理。如果用户取消了选择，则第二个值将为None。

5.4 简单对话框

简单对话框模块tkinter.simpledialog，它可以用于显示一些基本的对话框，如输入字符串、选择按钮等

import tkinter as tk
from tkinter import simpledialog

# 1.输入字符串对话框 askstring
user_input = simpledialog.askstring("输入", "请输入你的姓名:")
if user_input:
    print("你输入的姓名是:", user_input)
else:
    print("没有输入字符串")

# 2.选择按钮对话框 askinteger、askfloat
choice = simpledialog.askinteger("选择", "请选择一个数字:", initialvalue=1, minvalue=1, maxvalue=10)
if choice is not None:
    print("你选择的数字是:", choice)
else:
    print("没有选择按钮")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.菜单和工具栏

图形用户界面应用程序通常提供菜单，菜单包括各种按照主题分组的基本命令。图形用户界面应用程序包括如下3种类型菜单。

1.主菜单：提供窗体的菜单系统。通过单击可以下拉出子菜单，选择命令可以执行相关的操作。常用的主菜单通常包括文件、编辑、视图、帮助等。

2.上下文菜单（快捷菜单）：通过鼠标右击某对象而弹出的菜单，一般为与该对象相关的常用菜单命令，例如剪切、复制、粘贴等。

3.工具栏：提供窗体的工具栏。通过单击工具栏上的图标可以执行相关的操作。

6.1 主菜单

在下面的示例中，首先创建了主窗口。然后，创建了一个名为menu_bar的主菜单，并将其配置为主窗口的菜单栏。

接下来，创建了三个子菜单：文件菜单、编辑菜单和帮助菜单。使用menu_bar.add_cascade方法将这些子菜单添加到主菜单中。

然后，使用add_command方法添加了文件菜单、编辑菜单和帮助菜单的菜单项。每个菜单项都有一个标签(label)和一个关联的命令(command)。菜单项的命令可以是一个函数或方法，用于处理菜单项的点击事件。

最后，通过调用root.mainloop()方法来运行Tkinter的主循环，以启动应用程序并显示主窗口及其菜单。

import tkinter as tk


def file_new():
    print("执行新建命令")


def file_open():
    print("执行打开命令")


def file_save():
    print("执行保存命令")


def edit_cut():
    print("执行剪切命令")


def edit_copy():
    print("执行复制命令")


def edit_paste():
    print("执行粘贴命令")


def help_about():
    print("执行关于命令")


# 创建主窗口
root = tk.Tk()

# 创建主菜单
menu_bar = tk.Menu(root)
root.config(menu=menu_bar)

# 创建文件菜单
file_menu = tk.Menu(menu_bar, tearoff=False)
menu_bar.add_cascade(label="文件", menu=file_menu)

# 添加文件菜单项
file_menu.add_command(label="新建", command=file_new)
file_menu.add_command(label="打开", command=file_open)
file_menu.add_command(label="保存", command=file_save)
file_menu.add_separator()
file_menu.add_command(label="退出", command=root.quit)

# 创建编辑菜单
edit_menu = tk.Menu(menu_bar, tearoff=False)
menu_bar.add_cascade(label="编辑", menu=edit_menu)

# 添加编辑菜单项
edit_menu.add_command(label="剪切", command=edit_cut)
edit_menu.add_command(label="复制", command=edit_copy)
edit_menu.add_command(label="粘贴", command=edit_paste)

# 创建帮助菜单
help_menu = tk.Menu(menu_bar, tearoff=False)
menu_bar.add_cascade(label="帮助", menu=help_menu)

# 添加帮助菜单项
help_menu.add_command(label="关于", command=help_about)

# 运行主循环
root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

6.2 上下文菜单

下面的例子中，首先创建了一个Menu对象作为上下文菜单。使用add_command方法可以添加菜单项，使用add_separator方法可以添加分隔线。

然后，使用bind方法将右键单击事件"<Button-3>"绑定到show_context_menu函数上。在该函数中，使用post方法显示上下文菜单，并指定菜单的位置为鼠标点击的位置(event.x_root和event.y_root)。

最后，通过调用mainloop方法启动Tkinter的事件循环，使窗口和上下文菜单可交互。

import tkinter as tk


def show_context_menu(event):
    context_menu.post(event.x_root, event.y_root)


root = tk.Tk()

# 创建上下文菜单
context_menu = tk.Menu(root, tearoff=0)
context_menu.add_command(label="选项1")
context_menu.add_command(label="选项2")
context_menu.add_separator()
context_menu.add_command(label="退出", command=root.quit)

# 绑定右键单击事件
root.bind("<Button-3>", show_context_menu)

root.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20