Python标准库之Tkinter库详细教程

原文链接：Tkinter教程（非常详细）

简介

Tkinter（即tk interface）是Python标准GUI库，简称“Tk”；从材质上来说，它是对TCL/TK工具包的一种Python接口封装。Tkinter是Python自带的标准库，它支持跨平台运行。

Tkinter编写的程序，也称为GUI程序，也称图形用户界面。

一个GUI程序一般由窗口、下拉菜单或者对话框等图形化组件构成，通过鼠标点击菜单栏、按钮或者弹出对话框的形式来实现人机互动，从而提升人机交互的体验，让“冰冷”的程序变得有“温度”。

教程特点

这套Tkinter教程适合想要了解GUI界面编程的人员学习，如果您刚刚学习图形界面开发，那么这套教程非常适合您。

阅读条件

本套Tkinter教程适合有一定Python基础的人员学习。如果对其他GUI软件包有所了解，比如PyGTK、wxPython等那将再好不过了。

一、GUI是什么

GUI的优势

在开发、设计一款GUI产品时，不能只局限于技术层面，而要对全局进行把控，最终使产品更符合人性化，从而提高用户的使用体验。

GUI开发工具

目前市面上的 GUI 开发软件包有很多，其中多数使用 C/C++ 语言开发。

为什么要采用C/C++库来开发GUI软件包呢？这是因为相比于其他语言，C/C++更适合于开发GUI程序。我们知道 GUI程序其实就是人和计算机的交互操作，因此程序的运行性能是考虑的第一要素，若性能不佳，将非常影响用户的体验。C/C++作为执行效率仅次于汇编语言的编译型语言，用来开发GUI软件包在合适不过了。

1. Python GUI工具：Tkinter、wxPython、PyQT、PyGTK、Pywin32等；
2. Java GUI工具：AWT/SWING/JavaFX等；
3. C#GUI工具：WinForm、WPF等。

虽然上述语言的性能不及C/C++，但是它们的开发效率很高，因此在性能要求不高的情况下，这些软件包也能够满足大多数用户的需求。大家要铭记，开发GUI程序的目的是为了实现人机交互，提升设备或者APP软件的易用性，这是GUI程序的初衷。

二、Tkinter是什么

Tkinter（即tk interface）是Python标准GUI库，简称“Tk”；从材质上来说，它是对TCL/TK工具包的一种Python接口封装。Tkinter是Python自带的标准库，它支持跨平台运行。

作为一款Python GUI工具，Tkinter拥有良好的跨平台性，它传承了Python语言简洁、代码易读的基本特点。

与其他编程语言的GUI工具包相比，Tkinter编码效率高，能够实现快速开发的目的，非常适合初学者学习。Tkinter使用纯Python语言开发，与C/C++开发的Qt框架相比，Tkinter有自身的局限性，比如性能、功能丰富程序等都不及Qt，因此它只适合开发一些简单的程序，比如计算器的界面，或者一个简易的聊天窗口等。

通常情况下不会使用Tkinter来开发较为复杂的桌面应用程序，这是由Python语言自身特点决定的，作为一种解释型语言和脚本语言，Python并不具备开发复杂桌面应用的优势。

但“麻雀虽小，五脏俱全”，Tkinter作为Python GUI工具之一，它具有GUI软件包的必备常用功能。比如，它提供了十多种不同类型的窗口控件、窗口布局管理器、事件处理机制等，加之其开发效率高、代码简洁易读，Tkinter自问世以来，备受大家青睐。

在CMD命令行运行以下命令，可以查看Tkinter的相应版本，同时也会显示一个简易的窗口，命令如下：

python -m tkinter

Python官方提供的IDLE（Integrated Development and Learning Environment），就是完全使用Tkinter开发而成的。

无论您是学习Tkinter，亦或是学习其他语言的GUI软件包，下列给出几点学习建议，帮助您找到学习GUI编程的方法：

Tk提供了诸多窗口控件（后续将详细讲解），这些控件开关各异，功能也不尽相同，在编写GUI程序的过程中，您可以把这些控件看做一块块“积木”，而搭建积木这项工程，不仅要求您了解每块积木的开关（即控件作用），更重要是学会搭建积木的方法，学会如何摆放这些积木。只有这样，最终才能将这些积木构建一个完整、美观的“图形界面”。

Tkinter中会涉及一些GUI编程的概念，比如根窗口（root）、顶级窗口（TopLeve）、Canvas（画布）、Frame（窗口）、标签（Label）等。

三、第一个Tkinter程序

一个最简单的Tkinter程序至少应包含以下四个部分：

1. 导入tkinter模块
2. 创建主窗口，也称root窗口（即根窗口）
3. 添加人机交互控件，同时编写相应的事件函数
4. 通过主循环（mainloop）来显示主窗口

上述四个步骤中，只有第三步属于Tkinter编程的重点，其余三个步骤属于固定的代码格式：

import tkinter as tk

# 调用Tk()创建主窗口

root_window = tk.Tk()

# 给主窗口起一个名字，也就是窗口的名字

root_window.title('C语言中文网：c.biancheng.net')

# 开启主循环，让窗口处于显示状态

root_window.mainloop()

这里的主窗口相当于画板，其他的控件都要建立在主窗口之上。主循环也称“消息循环”或“事件循环”，其作用是让主窗口处于显示状态。

下面我们对上述程序做一下简单的改运，添加一些简单的交互控件：

import tkinter as tk

# 调用Tk()创建主窗口

root_window = tk.Tk()

# 给主窗口起一个名字，也就是窗口的名字

root_window.title('C语言中文网：c.biancheng.net')

# 设置窗口大小：宽x高，注：此处不能“*”，必须使用“x”

root_window.geometry('450x300')

# 更改左上角窗口的icon图标，加载C语言中文网logo标志

root_window.iconbitmap('')

# 设置主窗口：背景颜色、颜色值可以是英文单词，或者颜色值的16进制数，除此之外还可以使用Tk内置的颜色常量

root_window["background"] = "#C9C9C9"

# 添加文本内容，设置字体的前景色和背景色，和字体类型、大小

text=tk.Label(root_window, text="C语言中文网：c.biancheng.net", bg="yellow", fg="red", font=("Times", 20, "bold italic"))

# 将文本内容放置在主窗口内

text.pack()

# 添加按钮，以及按钮的文本，并通过command参数设置关闭窗口的功能

button=tk.Button(root_window, text="关闭", command=root_window.quit)

# 将按钮放置在主窗口内

button.pack(side="bottom")

# 开启主循环，让窗口处于显示状态

root_window.mainloop()

说明：

pack()方法将控件放置在主窗口内（pack方法又称窗口布局管理器）

主窗口是其他一切控件的基础，其他内容元素都要附着在主窗口上，就如同在一块画板上添加描述文字一样。

Tkinter提供了十余种常用类型的控件，每个控件都有相应的属性，比如颜色（前景色/背景色/颜色常量）、文本内容、字体样式、控件大小、控件样式、控件命令等等。

四、Tkinter常用控件和属性

控件类型

下表列出了Tkinter中常用的15个控件

控件基本属性

本节内容，先对这些控件的共用属性做简单介绍，如下所示

五、Tkinter主窗口

主窗口控件（window）是一切控件的基础，它好比是一台调整运转的机器，而其他控件则相当于这台机器上的部件，比如齿轮、链条、螺丝等等。

Tkinter提供了一些关于主窗口对象的常用方法，在本节对这些方法做简单的介绍。

创建一个空白窗口

Tkinter能够很方便地创建一个空白窗口：

# 导入tk

import tkinter as tk

# 创建一个主窗口对象

window = tk.Tk()

# 调用mainloop()显示主窗口

window.mainloop()

1）窗口常用方法

下表列出了窗口的常用方法，其中window代表主窗口对象

获取属性值：window.attributes('-alpha')

示例：

import tkinter as tk

window = tk.Tk()

window.title('小飞日记')

window.geometry('450x300')

print('电脑的分辨率是%dx%d'%(window.winfo_screenwidth(),window.winfo_screenheight()))

# 要求窗口的大小，必须先刷新一下屏幕

window.update()

print("窗口的分辨率是%dx%d"%(window.winfo_width(),window.winfo_height()))

# 禁止拉伸窗口

window.resizable(0,0)

# 改变背景颜色

window.config(background="#6fb765")

# 设置窗口置顶

window.attributes("-topmost", True)

# 设置窗口的透明度

window.attributes('-alpha', 0.8)

# 设置窗口被允许调整的最大范围，与resizable()冲突

# window.maxsize(600,600)

# 设置窗口被允许最小调整的范围，与resizable()冲突

# window.minsize(60,60)

# 更改左上角窗口的icon图标

window.iconbitmap(r'F:\02A业务相关\97A办公小程序\115ico.ico')

# 添加文本内容，并对字体添加相应的格式font（字体，字号，“字体类型”）

text = tk.Label(window, text="小飞日记", bg="yellow", fg="red", font=('Times', 15, 'bold italic underline'))

# 将文本内容放置在窗口内

text.pack()

# 添加按钮，以及按钮的文本，并通过command参数设置关闭窗口的功能

button = tk.Button(window, text="关闭", command=window.quit)

# 将按钮放置在主窗口内

button.pack(side="bottom")

# 进入主循环，显示主窗口

window.mainloop()

程序输出结果：

电脑的分辨率是1920x1080

窗口的分辨率是450x300

2）protocol处理机制

Tkinter除了提供事件绑定机制之外，还提供了协议处理机制，它指的是应用程序和窗口管理器之间的交互，最常用的协议为WM_DELETE_WINDOW。

当Tkinter使用WM_DELETE_WINDOW协议与主窗口进行交互时，Tkinter主窗口右上角X号的关闭功能失效，也就是无法通过点击X来关闭窗口，而是转变成调用用户自定义的函数。

示例：

import tkinter as tk

# 导入对话框控件

from tkinter import messagebox

# 创建主窗口

root = tk.Tk()

# 定义回调函数，当用户点击窗口x退出时，执行用户自定义的函数

def QueryWindow():

if messagebox.showwarning("警告", "出现了一个错误"):

# 这里必须使用destory()关闭窗口

root.destroy()

# 使用协议与窗口交互，并回调用户自定义的函数

root.protocol("WM_DELETE_WINDOW", QueryWindow)

root.mainloop()

通过封装函数的形式来执行相应的GUI控件功能，这在学习Tkinter编程的整个过程中非常常见，比如Button控件的command参数也可以执行回调函数。

设置窗口的位置

当我们运行Tkinter程序时，主窗口都会出现在距离左上角指定的位置上，这是由Tkinter软件包默认设置的。但是在许多情况下，我们需要根据实际情况来移动窗口在电脑屏幕上的位置，这时应该如何处理呢？其实很简单，通过窗口对象的geometry()方法即可改变主窗口的位置，其语法如下：

geometry('450x400+300+200')

上述代码表示，设置主窗口的宽度为450，高度为400，同时窗口距离左边屏幕的距离为300（以像素为单位），距离屏幕顶部的距离为200，这里我们将带“+”的参数值称为“位置参数”，当然，你也可以将它们设置为负数：

geometry('+-1500+-2000')

当设置了一个超过屏幕的负参数值时，主窗口会被移动至“屏幕之外”，此时就看不到主窗口了，这也是隐藏窗口的一种方法。

示例：

import tkinter as tk

window = tk.Tk()

window.title("小飞日记")

# 设置窗口大小变量

width = 300

height = 300

# 窗口居中，获取屏幕尺寸计算布局参数，使窗口居屏幕中央

screenwidth = window.winfo_screenwidth()

screenheight = window.winfo_screenheight()

size_geo = '%dx%d+%d+%d' %(width,height, (screenwidth-width)/2, (screenheight-height)/2)

window.geometry(size_geo)

window.mainloop()

六、Tkinter Label标签控件

Label（标签）控件，是Tkinter中最常使用的一种控件，主要用来显示窗口中的文本或者图像，并且不同的Label（标签）允许设置各自不同的背景图片。

下面对Label（标签）的常用属性做简单介绍

1）Label控件构成

一个控件主要由背景和前景两部分组成。其中背景由三部分构成分别是内容区域、填充区、边框，这三个区域的大小通过以下属性进行控制：

1. width/heigh
2. padx/pady
3. borderwidth

下面通过一个示意图对Label背景的区域构成进行说明：

备注：

1处代表边框使用borderwidth属性来调整大小；

2处代表左右填充区，使用padx属性来调整大小；

3处代表上下填充区，使用pady属性来调整大小。

padx/pady即调整内部左右、上下间距，使内容与容器其他元素之间有额外的间距。

边框的宽度可以通过borderwidth来调整，其样式可以通过relief来设置；填充区（即内间距）的大小调整分为水平方向和垂直方向，使用padx/pady来调整；内容区则主要用来显示文字或者图片，其大小由width/height来控制。

示例：

import tkinter as tk

win = tk.Tk()

win.title("小飞")

win.geometry('400x200')

win.iconbitmap(r'F:\02A业务相关\97A办公小程序\ico.ico')

label = tk.Label(win, text='网址：c.biancheng.net',font=('宋体',20,'bold italic'),bg='#7CDD7C',

# 设置标签内容大小

width=30,height=5,

# 设置填充区域、边框宽度和其样式

padx=10,pady=15,borderwidth=10,relief='sunken')

label.pack()

win.mainloop()

2）标签添加背景图

Label（标签）除了可以显示文本之外，还可以用来显示图片。

import tkinter as  tk

win = tk.Tk()

win.title("C语言中文网")

win.iconbitmap('')

#显示图片(注意这里默认支持的图片格式为GIF)

photo = tk.PhotoImage(file = '')

print(type(photo))

# 将图片放在主窗口的右边

lab =tk.Label(win,image=photo).pack(side="right")

# 显示文字，设置文本格式

text = "C语言中文网欢迎您,\n"\

       "这里有精彩的教程,\n "\

       "这里有数不尽的知识宝藏"

lab_text =tk.Label(win,text=text,fg ='#7CCD7C',font=('微软雅黑',15,'italic'),justify='left',padx=10).pack(side='left')

win.mainloop()

注意：不同的TK版本所支持的图片格式也不完全相同，通过对主述示例的测试，此处只支持显示GIF格式图片。

3）Message控件

Message控件与Label控件的功能类似，它主要用来显示多行不可编辑的文本信息，与Label的不同之处在于该控件增加了自动分行的功能。

from tkinter import *

#创建主窗口

win = Tk()

win.config(bg='#8DB6CD')

win.title("C语言中文网")

win.geometry('400x300')

# win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

txt = "C语言中文网，网址是：c.biancheng.net"

msg = Message (win, text=txt,width =60,font=('微软雅黑',10,'bold'))

msg .pack (side=LEFT)

#开始程序循环

win .mainloop ()

七、Tkinter Button按钮控件

Button控件是Tkinter中常用的窗口部件之一，同时也是实现程序与用户交互的主要控件。通过用户点击按钮的行为来执行回调函数，是Button控件的主要功用。

首先定义一个函数或者方法，然后将函数与按钮关联起来，最后，当用户按下这个按钮时，Tkinter就会自动调用相关函数。

按钮控件使用起来非常简单，它同样可以文本、图像、位图，并通过commad参数回调函数。

import tkinter as tk

# 创建窗口

window =tk.Tk()

# 设置回调函数

def callback():

    print ("click me!")

# 使用按钮控件调用函数

b = tk.Button(window, text="点击执行回调函数", command=callback).pack()

# 显示窗口

tk.mainloop()

Button控件的常用属性如下：

除了Button按钮之外，和其类似的按钮还有复选框按钮（Checkbutton）和单选框按钮（Radiobutton），它们分别有着不同语法和使用场景。

import tkinter as tk

from tkinter import messagebox

window = tk.Tk()

# 设置窗口的标题

window.title('C语言中文网')

# 设置并调整窗口的大小、位置

window.geometry('400x300+300+200')

# 当按钮被点击的时候执行click_button()函数

def click_button():

    # 使用消息对话框控件，showinfo()表示温馨提示

    messagebox.showinfo(title='温馨提示', message='欢迎使用C语言中文网')

# 点击按钮时执行的函数

button = tk.Button(window,text='点击前往',bg='#7CCD7C',width=20, height=5,command=click_button).pack()

# 显示窗口

window.mainloop()

通过上述示例不难看出，Button 控件的作用就是“执行一个函数”，当用户点击按钮时会弹出一个新的对话框，这种操作巧妙地提升了用户的人机交互体验。因此，按钮控件在 GUI 编程中被广泛的使用。

扩展：按钮的布局

按钮在主窗口中的布局，通常使用 grid() 函数来完成，该函数以网格状的形式（即行和列）来管理窗口的布局。

grid() 布局管理器提供了一个sticky参数，通过该参数可以设置按钮的方位，该参数默认将控件设置居中，其他参数值有 N/S/W/E（上/下/左/右），而且可以组合在一起使用，比如 NW/WE/SE/SW/NE 等，这与anchor参数控制文本的显示位置，有着异曲同工之妙。如下图所示：

值得大家注意的是 grid() 布局方法不能与 pack() 混合在一起使用，相关知识在后续内容中还会做针对性讲解。

import tkinter as tk

from tkinter import messagebox

win = tk.Tk()

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.geometry('400x200+100+100')

win.resizable(0,0)

# 将俩个标签分别布置在第一行、第二行

tk.Label(win, text="账号：").grid(row=0)

tk.Label(win, text="密码：").grid(row=1)

# 创建输入框控件

e1 = tk.Entry(win)

# 以 * 的形式显示密码

e2 = tk.Entry(win,show='*')

e1.grid(row=0, column=1, padx=10, pady=5)

e2.grid(row=1, column=1, padx=10, pady=5)

# 编写一个简单的回调函数

def login():

    messagebox.showinfo('欢迎您到来')

# 使用 grid()的函数来布局，并控制按钮的显示位置

tk.Button(win, text="登录", width=10, command=login).grid(row=3, column=0, sticky="w", padx=10, pady=5)

tk.Button(win, text="退出", width=10, command=win.quit).grid(row=3, column=1, sticky="e", padx=10, pady=5)

win.mainloop()

八、Tkinter Entry输入控件

Entry 控件是 Tkinter GUI 编程中的基础控件之一，它的作用就是允许用户输入内容，从而实现 GUI 程序与用户的交互，比如当用户登录软件时，输入用户名和密码，此时就需要使用 Entry 控件。

Entry 控件使用起来非常简单，下面对该控件做简单的介绍。基本语法格式如下：

tk_entry = Entry(master, option, ...)

基本属性

Entry控件除了具备一些共有属性之外，还有一些自身的特殊属性：

1）动态数据类型

上述表格中提及了 StringVar() 方法，和其同类的方法还有 BooleanVar()、DoubleVar()、IntVar() 方法，不难看出他们分别代表一种数据类型，即字符串、布尔值、浮点型、整型，这些方法并不属于 Python 内置方法，而是 Tkinter 特有的方法。

在界面编程的过程中，有时我们需要“动态跟踪”一些变量值的变化，从而保证值的变换及时的反映到显示界面上，但是 Python 内置的数据类型是无法这一目的的，因此使用了 Tcl 内置的对象，我们把这些方法创建的数据类型称为“动态类型”，比如 StringVar() 创建的字符串，称为“动态字符串”。

示例：

import tkinter as tk

import time

root = tk.Tk()

root.title("C语言中文网")

#root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

root.geometry('450x150+100+100')

root.resizable(0,0)

root.title('我们的时钟')

# 获取时间的函数

def gettime():

    # 获取当前时间

    dstr.set(time.strftime("%H:%M:%S"))

    # 每隔 1s 调用一次 gettime()函数来获取时间

    root.after(1000, gettime)

# 生成动态字符串

dstr = tk.StringVar()

# 利用 textvariable 来实现文本变化

lb = tk.Label(root,textvariable=dstr,fg='green',font=("微软雅黑",85))

lb.pack()

# 调用生成时间的函数

gettime()

# 显示窗口

root.mainloop()

说明：

在Python的Tkinter库中，after方法用于在指定时间后安排一个函数调用。这个方法可以用于定时任务或者周期性地执行某个函数。after()方法可以在Tkinter的任何部件上使用。

常用方法

除了一些基本的属性之外，Entry控件还提供了一些常用的方法：

注意：在 Entry 控件中，我们可以通过以下方式来指定字符的所在位置：数字索引：表示从 0 开始的索引数字；

"ANCHOE"：在存在字符的情况下，它对应第一个被选中的字符；

"END"：对应已存在文本中的最后一个位置；

"insert(index,'字符')：将字符插入到 index 指定的索引位置。

示例：

import tkinter as tk

win = tk.Tk()

# 设置主窗口

win.geometry('250x100')

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.resizable(0,0)

# 创建输入框控件

entry1 = tk.Entry(win)

# 放置输入框，并设置位置

entry1.pack(padx=20, pady=20)

entry1.delete(0, "end")

# 插入默认文本

entry1.insert(0,'C语言中文网，网址：c.biancheng.net')

# 得到输入框字符串

print(entry1.get())

# 删除所有字符

# entry1.delete(0, tk.END)

win.mainloop()

示例2：

import tkinter as tk

win =tk.Tk()

# 设置主窗口

win.geometry('250x100')

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.resizable(0,0)

# 新建文本标签

labe1 = tk.Label(win,text="账号：")

labe2 = tk.Label(win,text="密码：")

# grid()控件布局管理器，以行、列的形式对控件进行布局，后续会做详细介绍

labe1.grid(row=0)

labe2.grid(row=1)

# 为上面的文本标签，创建两个输入框控件

entry1 = tk.Entry(win)

entry2 = tk.Entry(win)

# 对控件进行布局管理，放在文本标签的后面

entry1.grid(row=0, column=1)

entry2.grid(row=1, column=1)

# 显示主窗口

win.mainloop()

注意：从上述运行结果可以看出，GUI 界面可以说真的很“简陋”，其实一款界面美观的 GUI 程序会受到诸多因素影响，比如距离调整、样式设置等等

Entry控件验证功能

Entry 控件也提供了对输入内容的验证功能，比如要求输入英文字母，你却输入了数字，这就属于非法输入，Entry 控件通过以下参数实现对内容的校验：

下面对 validate 的参数值做简单的介绍：

示例：

import tkinter as tk

from tkinter import messagebox

win = tk.Tk()

# 设置主窗口

win.geometry('250x200+700+400')

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.resizable(0,0)

# 创建验证函数

def check():

    if entry1.get() == "C语言中文网":

        messagebox.showinfo("输入正确")

        return True

    else:

        messagebox.showwarning("输入不正确")

        entry1.delete(0,tk.END)

        return False

# 新建文本标签

labe1 = tk.Label(win,text="账号：")

labe2 = tk.Label(win,text="密码：")

labe1.grid(row=0)

labe2.grid(row=1)

# 创建动字符串

Dy_String = tk.StringVar()

# 使用验证参数 validata,参数值为 focusout 当失去焦点的时候，验证输入框内容是否正确

entry1 = tk.Entry(win,textvariable =Dy_String,validate ="focusout",validatecommand=check)

entry2 = tk.Entry(win)

# 对控件进行布局管理，放在文本标签的后面

entry1.grid(row=0, column=1)

entry2.grid(row=1, column=1)

win.mainloop()

不仅如此，Tkinter 还为验证函数提供可一些额外的选项，不过想要使用这些额外选项，需要提前使用 register() 方法对验证函数进行注册，。常用的选项如下所示：

示例：

import tkinter as tk

from tkinter import messagebox

win = tk.Tk()

# 设置主窗口

win.geometry('250x200+250+200')

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.resizable(0,0)

# 新建文本标签

labe1 = tk.Label(win,text="账号：")

labe2 = tk.Label(win,text="密码：")

labe1.grid(row=0)

labe2.grid(row=1)

# 创建动态字符串

Dy_String = tk.StringVar()

# 创建验证函数

def check(strings,reason, id):

    if entry1.get() == "C语言中文网":

        messagebox.showinfo("输入正确")

        print(strings,reason,id)

        return True

    else:

        messagebox.showwarning("输入不正确")

        print(strings,reason,id)

        return False

# 对验证函数进行注册

CheckTest = win.register(check)

# 使用验证参数 validata,参数值为 focusout 当失去焦点的时验证输入框内容是否正确

entry1 = tk.Entry(win,textvariable =Dy_String,validate ="focusout",validatecommand=(CheckTest,'%P','%V','%W'))

entry2 = tk.Entry(win)

# 对控件进行布局管理，放在文本标签的后面

entry1.grid(row=0, column=1)

entry2.grid(row=1, column=1)

win.mainloop()

程序输出结果：

 focusout .!entry

工在 focusout .!entry

实例演示

下面看一组实例演示，通过实现一个简单的计算器小程序来对 Entry 控件做进一步说明：

from tkinter import *

# 创建窗体

win = Tk()

win.title("C语言中文网")

win.geometry('300x300')

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建一个容器来包括其他控件

frame = Frame (win)

# 创建一个计算器

def calc() :

# 用户输入的表达式，计算结果后转换为字符串

    result = "= "+ str (eval(expression.get()))

    #将计算的结果显示在Label控件上

    label.config(text =result)

#创建一个Label控件

label = Label (frame)

#创建一个Entry控件

entry = Entry (frame)

#读取用户输入的表达式

expression = StringVar ()

#将用户输入的表达式显示在Entry控件上

entry ["textvariable"] = expression

#创建-一个 Button控件.当用户输入完毕后，单击此按钮即计算表达式的结果

button1 = Button (frame, text="等 于",command=calc)

#设置Entry控件为焦点所在

entry.focus ()

frame.pack ()

#Entry控件位于窗体的上方

entry .pack()

#Label控件位于窗体的左方

label .pack (side="left")

#Button控件位于窗体的右方

button1.pack (side="right")

#开始程序循环

frame .mainloop()

Spinbox高级输入框

Spinbox 是 Entry 控件的升级版，它是 Tkinter 8.4 版本后新增的控件，该控件不仅允许用户直接输入内容，还支持用户使用微调选择器（即上下按钮调节器）来输入内容。在一般情况下，Spinbox 控件用于在固定的范围内选取一个值的时候使用。下面看一组简单的应用示例：

import tkinter as tk

root = tk.Tk()

root.title("C语言中文网")

root.geometry('300x200+300+300')

#root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 如果是数字使用 from_和to参数，范围 0-20,并且与2步长递增或递减

w = tk.Spinbox(root,from_=0,to=20, increment=2,width = 15,bg='#9BCD9B')

w.pack()

# 显示窗口

root.mainloop()

若不是数字，而是字符串形式的选项值，则采用values参数以元组的形式进行传参，如下所示：

import tkinter as tk

root = tk.Tk()

root.title("C语言中文网")

root.geometry('300x200+300+300')

#root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 使用 values 参数以元组的形式进行传参

strings = tk.Spinbox(root,values=('Python','java','C语言','PHP'))

strings.pack()

# 开启事件循环

root.mainloop()

九、Tkinter Text文本框控件

Text文本控件是Tkinter中经常使用的控件，与Entry控件相比，Text控件用于显示和编辑多行文本，而Entry控件则适合处理单行文本。

Text 控件类似 HTML 中的<textarea>标签，允许用户以不同的样式、属性来显示和编辑文本，它可以包含纯文本或者格式化文本，同时支持嵌入图片、显示超链接以及带有 CSS 格式的 HTML 等。Text 控件的有很多的适用场景，比如显示某个产品的详细信息，或者人物介绍等。下面我们对 Text 控件属性和常用方法做简单的介绍。

基本属性

除了基本的共有属性之外，Text 控件还具备以下属性：

基本方法

Text 中的方法有几十个之多，这里不进行一一列举，主要对常用的方法进行介绍，如下表所示：

示例：

from tkinter import *

win = Tk()

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.geometry('400x420')

# 创建一个文本控件

# width 一行可见的字符数；height 显示的行数

text = Text(win, width=50, height=30, undo=True, autoseparators=False)

# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充，Y表示沿垂直方向填充，BOTH表示沿水平、垂直方向填充

text.pack()

# INSERT 光标处插入；END 末尾处插入

text.insert(INSERT, 'C语言中文网，一个有温度的网站')

win.mainloop()

示例2：

from tkinter import *

win = Tk()

win.title("C语言中文网")

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.geometry('400x300')

# 创建一个文本控件

# width 一行可见的字符数；height 显示的行数

text = Text(win, width=50, height=20, undo=True, autoseparators=False)

text.grid()

# INSERT 光标处插入；END 末尾处插入

text.insert(INSERT, 'C语言中文网，一个有温度的网站')

# 定义撤销和恢复方法，调用edit_undo()和 edit_redo()方法

def backout():

    text.edit_undo()

def regain():

    text.edit_redo()

# 定义撤销和恢复按钮

Button(win,text = '撤销',command = backout).grid(row=3, column=0, sticky="w", padx=10, pady=5)

Button(win,text = '恢复',command = regain).grid(row=3, column=0, sticky="e", padx=10, pady=5)

win.mainloop()

注意：点击“撤销”按钮后输入的所有语句都会被删除，如果再点击“恢复”按钮，刚刚删除的内容又会恢复。

文本控件（Text）支持三种类型的特殊结构，即 Mark、Tag 以及 Index，每一种结构都有相应的方法，下面对这些结构做相关的介绍。

Index文本索引

Index 索引，用于指定字符在文本中的真实位置，这与我们经常使用 Python 索引是一样的，不过在 Text 文本控件中，两者之间的使用形式存在一些差异。

Tkinter 提供以下文本索引类型，如下表所示：

示例：

from tkinter import *

root = Tk()

root.title("C语言中文网")

root.geometry('400x200')

#root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

text =Text(root, width=35, heigh=15)

text.pack()

# 在文本域中插入文字

text.insert(INSERT, 'C语言中文网')

# 继续向后插入文字

text.insert("insert", "，I love Python")

# 获取字符，使用get() 方法

print(text.get("1.3", "1.end")) # 第1行的第3个位置开始，到第1行最后一个位置结束

# 显示窗口

root.mainloop()

输出：

中文网，I love Python

Tag文本标签

Tag（标签）用来给一定范围内的文字起一个标签名，通过该标签名就能操控某一范围内的文字，比如修改文本的字体、尺寸和颜色。除此之外，该标签还可以和事件函数绑定在一起使用。

这里需要注意，Tags 的名字是由字符串组成的，但不能是空白字符串。

Tag 提供了一些常用的方法，通过这些方法可以操作 Tag（标签），常用方法如下：

示例：

from tkinter import *

# 创建多行文本框控件

from tkinter import *

# 创建主窗口

win = Tk()

win.title(string = "C语言中文网")

# 创建一个Text控件

text = Text (win)

# 在Text控件内插入- -段文字 ，INSERT表示在光标处插入，END表示在末尾处插入

text.insert (INSERT,  "C语言中文网（网址：c.biancheng.net），一个有温度的网站，一生只做一件事\n\n")

text.insert(END, "END表示在末尾处插入")

# 跳下一行

text.insert (INSERT, "\n\n")

# 在Text控件内插入- -个按钮

button = Button(text, text="关闭",command=win.quit)

text. window_create (END, window=button)

# 填充水平和垂直方向,这里设置 expand为 True 否则不能垂直方向延展

text .pack (fill=BOTH,expand=True)

# 在第一行文字的第0个字符到第6个字符处插入标签，标签名称为"name"

text.tag_add("name", "1.0", "1.6")

# 将插入的按钮设置其标签名为"button"

text.tag_add ("button", button)

#使用 tag_config() 来改变标签"name"的前景与背景颜色,并加下画线，通过标签控制字符的样式

text.tag_config("name", font=('微软雅黑',18,'bold'),background="yellow", foreground= "blue",underline=1)

#设置标签"button"的居中排列

text. tag_config("button", justify="center")

#开始程序循环

win .mainloop()

Mark文本标记

Mark（标记）通常被用来当作书签，它可以帮助用户快速找到内容的指定位置，并且跟随相应的字符一起移动。

Mark 有两种类型的标记，分别是“INSERT”和“CURRENT”，其含义如下：

• INSERT：指定当前插入光标的位置，Tkinter 会在该位置绘制一个闪烁的光标；
• CURRENT：用于指定当前光标所处坐标最邻近的位置。

它们是 Tkinter 中预定义的标记，因此不能被删除。除此上述标记外，我们还可以通过 user-define marks（用户自定义标记） 的方式来自定义 Mark。Tkinter 也提供了一些有关 Mark 的常用的方法，如下所示：

注意：如果在 Mark 标记的位置之前插入或删除文本，那么 Mark 跟着一起移动。如果要删除 Mark 需要使用 mark_unset() 方法，但是只会删除 Mark 周围的文本，并不会删除 Mark 标记本身。

示例：

from tkinter import *

# 创建多行文本框控件

from tkinter import *

# 创建主窗口

win = Tk()

win.title(string = "C语言中文网")

# 创建一个Text控件

text = Text (win)

# 在Text控件内插入- -段文字 ，INSERT表示在光标处插入，END表示在末尾处插入

text.insert (INSERT,  "C语言中文网（网址：c.biancheng.net），一个有温度的网站，一生只做一件事\n\n")

text.insert(END, "END表示在末尾处插入")

# 跳下一行

text.insert (INSERT, "\n\n")

# 在Text控件内插入- -个按钮

button = Button(text, text="关闭",command=win.quit)

text. window_create (END, window=button)

# 填充水平和垂直方向,这里设置 expand为 True 否则不能垂直方向延展

text .pack (fill=BOTH,expand=True)

# 在第一行文字的第0个字符到第6个字符处插入标签，标签名称为"name"

text.tag_add("name", "1.0", "1.6")

# 将插入的按钮设置其标签名为"button"

text.tag_add ("button", button)

#使用 tag_config() 来改变标签"name"的前景与背景颜色,并加下画线，通过标签控制字符的样式

text.tag_config("name", font=('微软雅黑',18,'bold'),background="yellow", foreground= "blue",underline=1)

#设置标签"button"的居中排列

text. tag_config("button", justify="center")

#开始程序循环

win .mainloop()

十、Tkinter列表框和组合框控件详解

Listbox控件

首先介绍一下列表框，即 Listbox。在使用 Tkinter 进行 GUI 编程的过程中，如果需要用户自己进行选择时就可以使用列表框控件。列表框中的选项可以是多个条目，也可以是单个唯一条目，但常用于多个条目。

下面对列表框控件（Listbox）的常用方法做简单的介绍：

除了共有属性之外，列表框控件也有一些其他属性，如下表所示：

1）创建列表框控件

示例：

# 创建一个列表控件，并增加相应的选项

from tkinter import *

# 创建主窗口

win = Tk()

win.title("C语言中文网")

win.geometry('400x200')

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建列表选项

listbox1 =Listbox(win)

listbox1.pack()

# i表示索引值，item 表示值，根据索引值的位置依次插入

for i,item in enumerate(["C","C++","C#","Python","Java"]):

    listbox1.insert(i,item)

# 显示窗口

win.mainloop()

除了上述使用 enumerate() 来实现选项插入的方法外，我们还可以使用 "end" 实现，它表示将选项插入到最后一个位置，所以“Java”一定会被插入到最后一个位置上，而之前的选项会依次向前排列，如下所示：

from tkinter import *

# 创建主窗口

win = Tk()

win.title("C语言中文网")

win.geometry('400x200')

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建列表选项

listbox1 =Listbox(win)

listbox1.pack()

# i表示索引值，item 表示值，根据索引值的位置依次插入

for item in ["C","C++","C#","Python","Java"]:

    listbox1.insert("end",item)

# 显示窗口

win.mainloop()

2）增加滚动和删除功能

下面为上述示例增加一个滚动条和选项的删除功能，如下所示：

from tkinter import *

# 创建主窗口

win = Tk()

win.title("C语言中文网")

win.geometry('400x180')

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建滚动条

s = Scrollbar(win)

# 设置垂直滚动条显示的位置，使得滚动条，靠右侧；通过 fill 沿着 Y 轴填充

s.pack(side = RIGHT,fill = Y)

# 将 selectmode 设置为多选模式，并为Listbox控件添加滚动条

listbox1 =Listbox(win,selectmode = MULTIPLE,height =5, yscrollcommand = s.set)

# i 表示索引值，item 表示值，根据索引值的位置依次插入

for i,item in enumerate(range(1,50)):

    listbox1.insert(i,item)

listbox1.pack()

# 设置滚动条，使用 yview使其在垂直方向上滚动 Listbox 组件的内容，通过绑定 Scollbar 组件的 command 参数实现

s.config(command = listbox1.yview)

# 使用匿名函数,创建删除函数，点击删除按钮，会删除选项

bt = Button(win,text='删除',command = lambda x = listbox1:x.delete(ACTIVE))

# 将按钮放置在底部

bt.pack(side = BOTTOM)

# 显示窗口

win.mainloop()

3）StringVar()添加列表选项

下面演示如何通过StringVar()方法动态地获取列表框中的选项，示例：

import tkinter as tk

from tkinter import messagebox

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x180')

#window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建变量，用var1用来接收鼠标点击的具体选项内容

var1 = tk.StringVar()

l = tk.Label(window, bg='#B0B0B0', font=('微软雅黑', 15), width=20, textvariable=var1)

l.pack()

# 创建一个按钮的点击事件

def click_button():

    # 使用 curselection来选中文本

    try:

        val = lb.get(lb.curselection())

    # 设置label值

        var1.set(val)

    except Exception as e:

        e = '发现一个错误'

        messagebox.showwarning(e,'没有选择任何条目')

# 创建一个按钮并放置，点击按钮调用print_selection函数

b1 = tk.Button(window, text='获取当前选项', command=click_button)

b1.pack()

# 创建Listbox并为其添加内容

var2 = tk.StringVar()

var2.set(("C语言辅导班", "Python答疑辅导", "Java答疑辅导", "C++辅导"))

# 创建Listbox，通过 listvariable来传递变量

lb = tk.Listbox(window, listvariable=var2)

# 新建一个序列，然后将值循环添加到Listbox控件中

items = ["C", "Java", "Python", "C#", "Golang", "Runby"]

for i in items:

    lb.insert('end', i)  # 从最后一个位置开始加入值

lb.insert(0, '编程学习')  # 在第一个位置插入一段字符串

lb.delete(4)  # 删除第2个位置处的索引

lb.pack()

#主窗显示

window.mainloop()

通过前面内容的介绍我们知道 Listbox 是一个供用户从列表项中选择相应条目的控件。但在有些情况下，比如列表的项目过多时，若使用列表控件，列出所有选项就会显得界面格外臃肿，这时就需要用到 Combobox 控件，也就是下拉菜单控件（或称复合框），该控件是列表控件的改进版，具有更加灵活的界面，因此其应用场景相比于前者要更加广泛。

不过需要注意的是 Combobox 并不包含在 tkinter 模块中，而是包含在tkinter.ttk子模块中，因此若想使用 Combobox 控件，需要使用下面的导包方式：

from tkinter import ttk

下面对 Combobox 控件做简单的介绍，其语法格式如下所示：

cbox=Combobox(窗口对象,[参数列表])

Combobox 控件在形式虽然与列表控件存在不同，但它们的本质是相同，因此属性和方法是通用的。

对于 Combobox 控件而言，它常用的方法有两个，分别是 get() 和 current()，前者表示获取当前选中选项的内容，后者表示获取选中选项的索引值。下面通过一组简单的示例进一步了解 Combobox 控件，示例代码如下：

import tkinter

from tkinter import ttk # 导入ttk模块，下拉菜单控件位于ttk子模块中

# 创建窗口

win = tkinter.Tk()

win.title("C语言中文网")

# win.geometry('400x200')

#win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.geometry('400x250')

win.resizable(0,0)

# 创建下拉菜单

cbox = ttk.Combobox(win)

# 使用 grid() 来控制控件的位置

cbox.grid(row = 1, sticky="NW")

# 设置下拉菜单中的值

cbox['value'] = ('C','C#','Go','Python','Java')

#通过 current() 设置下拉菜单选项的默认值

cbox.current(3)

# 编写回调函数，绑定执行事件,向文本插入选中文本

def func(event):

    text.insert('insert',cbox.get()+"\n")

# 绑定下拉菜单事件

cbox.bind("<<ComboboxSelected>>",func)

# 新建文本框

text = tkinter.Text(win)

# 布局

text.grid(pady = 5)

win.mainloop()

十一、Tkinter单选框和多选框按钮

单选框按钮控件（Radiobutton），同样允许用户选择具体的选项值，不过与 Listbox 相比，单选按钮控件仅允许用户选择单一的选项值，各个选项值之间是互斥的关系，因此只有一个选项可以被用户选择。

Radiobutton 控件通常都是成组出现的，所有控件都使用相同的变量。Radiobutton 可以包含文本或图像，每一个按钮都可以与一个 Python 函数相关联。当按钮被按下时，对应的函数会被执行。这里需要注意的是，单选按钮控件仅能显示单一字体的文本，但文本可以跨越多行，除此之外，您还可以为个别的字符添加下划线。

Radiobutton 除常用的共有属性之外，还具有一些其他属性，如下表所示：

Radiobutton 控件的常用方法如下所示：

Radiobutton 控件用来解决多选一的问题，它通常是成组出现的，下面看一组简答的示例：

import tkinter as tk

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x180')

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# IntVar() 用于处理整数类型的变量

v = tk.IntVar()

# 根据单选按钮的 value 值来选择相应的选项

v.set(0)

# 使用 variable 参数来关联 IntVar() 的变量 v

tk.Radiobutton(window, text="C语言中文网", fg='blue',font=('微软雅黑','12','bold'),variable=v, value=0).pack(anchor = 'w')

tk.Radiobutton(window, text="CSDN平台", variable=v, value=2).pack(anchor = 'w')

tk.Radiobutton(window, text="知乎平台", variable=v, value=3).pack(anchor = 'w')

tk.Radiobutton(window, text="牛客网平台", variable=v, value=4).pack(anchor = 'w')

# 显示窗口

window.mainloop()

上述代码是比较直接的写法，虽然编码过程简单，但是从代码重构的角度来讲，它是比较冗余的，因此我们推荐下面这种写法，如下所示：

import tkinter as tk

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x180')

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

site = [('美团外卖',1),

        ('饿了么外卖',2),

        ('美团闪购',3),

        ('艾奇外卖',4)]

# IntVar() 用于处理整数类型的变量

v = tk.IntVar()

# 重构后的写法，也非常简单易懂

for name, num in site:

    radio_button = tk.Radiobutton(window,text = name, variable = v,value =num)

    radio_button.pack(anchor ='w')

# 显示窗口

window.mainloop()

对上述代码稍作修改，当点击某一按钮时，获取选项的内容，代码如下：

import tkinter as tk

def select():

    dict = {1:'C语言中文网',2:'菜鸟教程',3:'W3SCHOOL',4:'微学苑'}

    strings = '您选择了' + dict.get(v.get()) + '，祝您学习愉快' # v.get()获取到的是索引

    lable.config(text = strings)

    print(v.get())

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x180')

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

lable = tk.Label(window,font=('微软雅黑', '15','bold'),fg='#43CD80')

lable.pack(side ='bottom')

site = [('C语言中文网',1),

        ('菜鸟教程',2),

        ('W3SCHOOL',3),

        ('微学苑',4)]

# IntVar() 用于处理整数类型的变量

v = tk.IntVar()

for name, num in site:

    radio_button = tk.Radiobutton(window,text = name, variable = v,value =num,command = select,indicatoron = False)

    radio_button.pack(anchor ='w')

# 显示窗口

window.mainloop()

输出：3

Checkbutton复选框控件

Checkbutton 控件是一种供用户选择相应条目的按钮控件，但与 Radiobutton 不同的是，Checkbutton 控件不仅允许用户选择一项，还允许用户同时选择多项，各个选项之间属于并列的关系。

复选框控件同样有许多适用场景，比如选择兴趣爱好、选择选修课，以及购买多个物品等，在这种情况下都可以使用复选框控件，其语法格式如下：

Checkbutton(master=None, **options)

复选框控件，除了具有常用的共有属性之外，还具有一些其他重要属性和常用方法，下面对它们做简单地介绍：

下面看一组简单的示例，创建一组复选框控件，代码如下：

from tkinter import *

win = Tk()

win.title("C语言中文网")

win.geometry('500x200')

win.resizable(0,0)

lb = Label(text='C语言中文网答疑辅导班',font=('微软雅黑', 18,'bold'),fg='#CD7054')

lb.pack()

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 新建整型变量

CheckVar1 = IntVar()

CheckVar2 = IntVar()

CheckVar3 = IntVar()

# 设置三个复选框控件，使用variable参数来接收变量

check1 = Checkbutton(win, text="Python",font=('微软雅黑', 15,'bold'),variable = CheckVar1,onvalue=1,offvalue=0)

check2 = Checkbutton(win, text="C语言",font=('微软雅黑', 15,'bold'),variable = CheckVar2,onvalue=1,offvalue=0)

check3 = Checkbutton(win, text="Java",font=('微软雅黑', 15,'bold'),variable = CheckVar3,onvalue=1,offvalue=0)

# 选择第一个为默认选项

# check1.select ()

check1.pack (side = LEFT)

check2.pack (side = LEFT)

check3.pack (side = LEFT)

# 定义执行函数

def study():

    # 没有选择任何项目的情况下

    if (CheckVar1.get() == 0 and CheckVar2.get() == 0 and CheckVar3.get() == 0):

        s = '您还没选择任语言'

    else:

        s1 = "Python" if CheckVar1.get() == 1 else ""

        s2 = "C语言" if CheckVar2.get() == 1 else ""

        s3 = "Java" if CheckVar3.get() == 1 else ""

        s = "您选择了%s %s %s" % (s1, s2, s3)

     #设置标签lb2的字体

    lb2.config(text=s)

btn = Button(win,text="选好了",bg='#BEBEBE',command=study)

btn.pack(side = LEFT)

# 该标签，用来显示选择的文本

lb2 = Label(win,text='',bg ='#9BCD9B',font=('微软雅黑', 11,'bold'),width = 5,height=2)

lb2.pack(side = BOTTOM, fill = X)

# 显示窗口

win.mainloop()

复选框控件提供以下常用方法，如下表所示：

下面看一组简答的示例，如下所示：

from tkinter import *

win = Tk()

win.title("C语言中文网")

win.geometry('500x200')

win.resizable(0,0)

lb = Label(text='C语言中文网答疑辅导班',font=('微软雅黑', 18,'bold'),fg='#CD7054')

lb.pack()

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 设置三个复选框控件，

check1 = Checkbutton(win, text="Python",font=('微软雅黑', 15,'bold'),onvalue=1,offvalue=0)

check2 = Checkbutton(win, text="C语言",font=('微软雅黑', 15,'bold'),onvalue=1,offvalue=0)

check3 = Checkbutton(win, text="Java",font=('微软雅黑', 15,'bold'),onvalue=1,offvalue=0)

# 将第一个 复选框按钮的 variable值，设置为 onvalue =1 ，表示选中状态

check1.select ()

# 取消了第一个复选框的选中状态

#check1.toggle()

check1.pack (side = LEFT)

check2.pack (side = LEFT)

check3.pack (side = LEFT)

# 显示窗口

win.mainloop()

十二、Tkinter Scale控件详解

Scale 控件，即滑块控件或标尺控件，该控件可以创建一个类似于标尺式的滑动条对象，用户通过操作它可以直接设置相应的数值（刻度值)。

Scale 控件同样有许多应用场景，并且在我们日常工作中也会经常用到，比如电脑上调节音量的滑动条（数值范围 0-100），如下图所示：

Scale 控件常用的基本属性如下所示：

Scale 常用方法有如下四个，见下表所示：

下面看一组简单的实例应用：创建一个 Scale 控件

from tkinter import *

# 创建主窗口

win =Tk()

win.title("控制管理界面")

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

win.geometry('400x250')

# 添加一个 Scale 控件，默认垂直方向，步长设置为 5，长度为200，滑动块的大小为 50，最后使用label参数文本

s=Scale(win, from_ =100, to =0,resolution =5,length =200,sliderlength= 20,label ='音量控制' )

s.pack()

# 设置滑块的位置

s.set(value=15)

# 显示窗口

mainloop()

下面看一个稍微复杂点的应用示例，代码如下：

import tkinter as tk

window = tk.Tk()

window.title("购物车界面")

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

window.geometry('450x200+450+250')

window.resizable(0,0)

# 创建一个文本标签

label = tk.Label(window, bg='#9FB6CD',width=18, text='')

label.grid(row =2)

# 创建执行函数

def select_price(value):

    label.config(text='您购买的数量是 ' + value)

# 创建 Scale控件

scale = tk.Scale(window,

             label='选择您要购买的数量',

             from_=1,

             to= 100,

             orient=tk.HORIZONTAL,   # 设置Scale控件平方向显示

             length=400,

             tickinterval=9,       # 设置刻度滑动条的间隔

             command=select_price)  # 调用执行函数，是数值显示在 Label控件中

scale.grid(row =1)

# 显示窗口

window.mainloop()

十三、TkinterCanvas画布控件

Canvas 控件具有两个功能，首先它可以用来绘制各种图形，比如弧形、线条、椭圆形、多边形和矩形等，其次 Canvas 控件还可以用来展示图片（包括位图），我们将这些绘制在画布控件上的图形，称之为“画布对象”。

每一个画布对象都有一个“唯一身份ID”，这是 Tkinter 自动为其创建的，从而方便控制和操作这些画布对象。

通过 Canvas 控件创建一个简单的图形编辑器，让用户可以达到自定义图形的目的，就像使用画笔在画布上绘画一样，可以绘制各式各样的形状，从而有更好的人机交互体验。

Canvas控件基本属性

下面对 Canvas 控件的常用属性做简单的介绍，如下表所示：

上述属性是用来设置 Canvas 控件的，下面示例定义了出一张画布（Canvas），如下所示：

import tkinter as tk

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x200')

# 创库不允许改变

window.resizable(0,0)

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建画布

canvas = tk.Canvas(window,

                   bg='#CDC9A5',

                   height=200,

                   width=300)

canvas.pack()

window.mainloop()

Canvas控件绘图常用方法

Cansvas 控件提供了一系列绘制几何图形的常用方法，下面对这些方法做简单介绍:
 

注意：上述方法都会返回一个画布对象的唯一 ID。关于 options 参数，下面会通过一个示例对经常使用的参数做相关介绍。（但由于可选参数较多，并且每个方法中的参数作用大同小异，因此对它们不再逐一列举）

从上述表格不难看出，Canvas 控件采用了坐标系的方式来确定画布中的每一点。一般情况下，默认主窗口的左上角为坐标原点，这种坐标系被称作为“窗口坐标系”，但也会存在另外一种情况，即画布的大小可能大于主窗口，当发生这种情况的时，可以采用带滚动条的 Canvas 控件，此时会以画布的左上角为坐标原点，我们将这种坐标系称为“画布坐标系”。

1) 绘制直线

下面示例展示了如何在画布（Canvas控件）上绘制一条虚线和实线，代码如下：

from tkinter import *

root = Tk()

# 设置窗口的背景颜色以区别画布

root.config(bg='#87CEEB')

root.title("C语言中文网")

root.geometry('450x350')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 设置画布的背景颜色为白色

cv=Canvas(root,bg="white",width =300, height = 250)

# 将控件放置在主窗口中

cv.pack()

# 设置坐标点,此处可以元组的形式来设置坐标点

point=[(10,20),(20,30),(30,40),(40,100),(80,120),(150,90)]

# 创建画布，添加线条

# fill 参数指定填充的颜色，如果为空字符串，则表示透明

# dash 参数表示用来绘制虚线轮廓，元组参数，分别代表虚线中线段的长度和线段之间的间隔

# arrow 设线段的箭头样式，默认不带箭头，参数值 first 表示添加箭头带线段开始位置，last表示到末尾占位置，both表示两端均添加

# smooth 布尔值参数，表示是否以曲线的样式划线，默认为 False

# width 控制线宽

line1=cv.create_line(point,fill="purple",dash=(1,1),arrow=LAST,width=5)

print('线段line1的画布id号:',line1)

line2=cv.create_line(point,fill="red",arrow=BOTH,smooth=TRUE,width=5)

print('线段line2的画布id号:',line2)

# 移动其中一条线段，只需要更改其坐标就可以,使用 coords()方法移动曲线

cv.coords(line2,50,30,25,35,35,40,50,120,60,170,10,220)

# 显示窗口

root.mainloop()

​​​​​​​

上述示例中涉及了一部分参数，比如 fill、dash、arrow 等，下表对 create_line() 函数的相关参数做了简单介绍：

对于扇形、矩形、三角形、圆形等，这些封闭式图形，它们由轮廓线和填充颜色两部分组成。在绘制这些图形时相关函数的可选参数与上述表格也存在略微差异，下面以绘制扇形的 create_arc() 函数为例做简单的介绍：
 

在实际的使用的过程中经常用到的参数有 dash、fill、outline、extend 和 start，但是这么多的参数我们也不可能都记住，这时查手册是一种很好的方法，官网文档地址：点击前往。

下面让我们来一组绘制几何图形的简单示例：

from tkinter import *

root = Tk()

# 设置主窗口区的背景颜色以区别画布区的颜色

root.config(bg='#8DB6CD')

root.title("C语言中文网")

root.geometry('500x400')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 将画布设置为白色

canvas = Canvas(root,width = 400,height = 400,bg='white')

# 设置基准坐标

x0,y0,x1,y1 = 10,10,80,80

# 绘制扇形,起始角度为 0 度，结束角度为 270, 扇形区域填充色为淡蓝色，轮廓线为蓝色，线宽为 2px

arc = canvas.create_arc(x0, y0, x1, y1,start = 0, extent = 270, fill = '#B0E0E6',outline ='blue',width = 2)

# 绘制圆形

oval = canvas.create_oval(x0+150, y0, x1+150, y1,fill ='#CD950C',outline = 'blue',width=2)

# 绘制矩形,并将轮廓线设置为透明色，即不显示最外围的轮廓线，默认为黑色

rect = canvas.create_rectangle(x0,y0+100,x1,y1+100,fill='red',outline = '')

# 绘制一个三角形，填充色为绿色

trigon = canvas.create_polygon(80,80,150,80,200,200, outline="", fill="green",)

# 当然也可以绘制一个任意多边形，只要你的坐标正确就可以

# 绘制一个多边形，首先定义一系列的多边形上的坐标点

poly_points=[(0,280),(140,200),(140,240),(270,240),(270,320),(140,320),(140,360)]

polygon = canvas.create_polygon(poly_points,fill="#BF3EFF")

# 放置画布在主窗口

canvas.pack()

# 显示窗口

root.mainloop()

注意：create_rectangle() 方法的前两个参数决定了矩形的左上角坐标，后两个参数决定了矩形的右下角坐标；另外 create_oval() 方法并不是只能绘制圆形，还能绘制椭圆形，这取决于传入的参数。

除了能够绘制几何图形之外，Tkinter 还可以展示图片、创建位图以及文本信息等，示例如下所示：

from tkinter import *

root=Tk()

# # 设置主窗口区的背景颜色以区别画布区的颜色

root.config(bg='#8DB6CD')

root.title("C语言中文网")

root.geometry('500x300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# # 将画布设置为白色

cv = Canvas(root,bg='white')

# tkinter 提供的内置位图名称

bitmaps = ["error", "gray75", "gray50", "gray25", "gray12",

"hourglass", "info", "questhead", "question", "warning"]

# 列出所有的位图样式

for i in range(len(bitmaps)):

    # 前两个参数指定一个位图的位置，后续依次排列

    cv.create_bitmap((i+1)*30,30,bitmap=bitmaps[i])

#并在画布上添加文本

# 参数说明，前两个参数（x0，y0）参照点，指定文字字符串的左上角坐标

# anchor 指定了文本的对于参照点的相对位置，以方位来指定,比如 W/E/N/S等

cv.create_text(30,80,text = "tkinter内置位图预览",fill ='#7CCD7C',anchor = W,font =('微软雅黑',15,'bold'))

# 展示图片，使用 PhotoImage()来加载图片

img = PhotoImage (file="C:/Users/Administrator/Desktop/c.biancheng.gif")

cv.create_image(30,150,image = img,anchor =W)

cv.create_text(30,220,text = "图片预览",fill ='#7CCD7C',anchor = W,font =('微软雅黑',15,'bold'))

cv.pack()

mainloop()

注意，添加到 Canvas 上的对象会一直保留直着。如果你希望修改它们，您可以使用 coords() 和 move() 方法来移动画布上的对象，当然您可以使用 delete() 来删除它们，示例如下：

from tkinter import *

root=Tk()

# # 设置主窗口区的背景颜色以区别画布区的颜色

root.config(bg='#8DB6CD')

root.title("C语言中文网")

root.geometry('500x300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 定义移动函数

def move_img():

    # 定义移动坐标

    cv.move(image1,50,30)

# # 将画布设置为白色

cv = Canvas(root,bg='white')

# 使用 PhotoImage()来加载图片

img = PhotoImage (file="C:/Users/Administrator/Desktop/c.biancheng.gif")

image1=cv.create_image(30,150,image = img,anchor =W)

# 将按钮放置在画布中

btn=Button(cv,text="点击移动画布",bg="#8A8A8A",activebackground="#7CCD7C",command=move_img)

# 在指定位置创建一个窗口控件，tags来添加标签

cv.create_window(365,250,height=30,width=30,window=btn)

# 调用delete() 删除画布对象,若传入ALL，则删除所有的画布对象

#cv.delete(image1)

cv.pack()

# 显示窗口

root.mainloop()

十四、Tkinter Menu菜单

Menu 控件（菜单控件）可以说是 GUI 中“精髓所在”，它以可视化的方式将一系列的“功能选项卡”进行分组，并在每个分组下又“隐藏”了许多其他的“选项卡”。当打开菜单时，这些选项卡就会“显式”的呈现出来，方便用户进行选择，比如 Windows 系统中记事本文件（.txt文件类型）的界面：

通过使用菜单控件（Menu）可以充分地节省有限的窗口区域，让我们的界面更加简洁优雅，避免臃肿、混乱。 

Tkinter Menu 控件提供了三种类型的菜单，分别是：topleve（主目录菜单）、pull-down（下拉式菜单）、pop-up（弹出式菜单，或称快捷式菜单）。

下表列出创建菜单时用到的相关方法，如下所示：

除了上述方法之外，Menu 控件也提供了一些其他方法来操作菜单项，比如删除菜单项、获取菜单项、设置指定的菜单项等，如下表所示：

下面对 Menu 控件的 options 参数做简单地介绍，如下所示：

1）创建主目录菜单

主目录菜单也称之为“顶级菜单”，下拉菜单等其他子菜单的都需要建立在“顶级菜单”的基础之上，下面示例创建了一个类似于“记事本”界面的程序，代码如下：

from tkinter import *

import tkinter . messagebox

#创建主窗口

win = Tk()

win.config(bg='#87CEEB')

win.title("C语言中文网")

win.geometry('450x350+300+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 绑定一个执行函数，当点击菜单项的时候会显示一个消息对话框

def menuCommand() :

    tkinter.messagebox.showinfo("主菜单栏","你正在使用主菜单栏")

# 创建一个主目录菜单，也被称为顶级菜单

main_menu = Menu (win)

#新增命令菜单项，使用 add_command() 实现

main_menu.add_command (label="文件",command=menuCommand)

main_menu.add_command (label="编辑",command=menuCommand)

main_menu.add_command (label="格式",command=menuCommand)

main_menu.add_command (label="查看",command=menuCommand)

main_menu.add_command (label="帮助",command=menuCommand)

#显示菜单

win.config (menu=main_menu)

win.mainloop()

如上图所示，当点击主目录中的任意一个菜单选项时都会跳出一个消息对话框。

2) 创建下拉菜单

下拉菜单时主菜单的重要组成部分，也是用户选择相关命令的重要交互界面，下拉菜单的创建方式也非常简单，不过需要我们注意，下拉菜单是建立的主菜单（即顶级菜单）的基础之上的，并非主窗口之上，这一点千万不要搞混，否则创建下拉菜单会失败。

下面继续仿照“记事本”的相关功能来创建下拉菜单，示例如下：

#创建一个下拉式菜单

from tkinter import *

import tkinter .messagebox

#创建主窗口

win = Tk()

win.config(bg='#87CEEB')

win.title("C语言中文网")

win.geometry('450x350+300+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

#创建一个执行函数，点击下拉菜单中命令时执行

def menuCommand() :

    tkinter .messagebox .showinfo("下拉菜单", "您正在使用下拉菜单功能")

#创建主目录菜单（顶级菜单）

mainmenu = Menu (win)

#在顶级菜单上新增"文件"菜单的子菜单，同时不添加分割线

filemenu = Menu (mainmenu, tearoff=False)

#新增"文件"菜单的菜单项，并使用 accelerator 设置菜单项的快捷键

filemenu.add_command (label="新建",command=menuCommand,accelerator="Ctrl+N")

filemenu.add_command (label="打开",command=menuCommand, accelerator="Ctrl+O")

filemenu.add_command (label="保存",command=menuCommand, accelerator="Ctrl+S")

# 添加一条分割线

filemenu.add_separator ()

filemenu.add_command (label="退出",command=win. quit)

#在主目录菜单上新增"文件"选项，并通过menu参数与下拉菜单绑定

mainmenu.add_cascade (label="文件",menu=filemenu)

# 将主菜单设置在窗口上

win.config (menu=mainmenu)

# 绑定键盘事件，按下键盘上的相应的键时都会触发执行函数

win.bind ("<Control-n>",menuCommand)

win. bind ("<Control-N>", menuCommand)

win.bind ("<Control-o>",menuCommand)

win. bind ("<Control-O>", menuCommand)

win. bind ("<Control-s>", menuCommand)

win.bind ("<Control-S>",menuCommand)

# 显示主窗口

win.mainloop()

3) 创建弹出菜单栏

弹出式菜单栏，也称为快捷式菜单栏，比如通过点击鼠标右键弹出一个菜单栏，其中包含一些常用的选项卡，如复制、粘贴等，如下所示：在记事本的空白处点击鼠标右键会弹出一个菜单栏。

Tkinter Menu 控件同样可以是实现上述功能，而且并不复杂，示例如下：

import tkinter as tk

root = tk.Tk()

root.config(bg='#8DB6CD')

root.title("C语言中文网")

root.geometry('400x300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

def func():

    print('您通过弹出菜单执行了命令')

# 创建一个弹出菜单

menu = tk.Menu(root, tearoff=False)

menu.add_command(label="新建", command=func)

menu.add_command(label="复制", command=func)

menu.add_command(label="粘贴", command=func)

menu.add_command(label="剪切", command=func)

# 定义事件函数

def command(event):

    # 使用 post()在指定的位置显示弹出菜单

    menu.post(event.x_root, event.y_root)

   

# 绑定鼠标右键，这是鼠标绑定事件

# <Button-3>表示点击鼠标的右键，1 表示左键，2表示点击中间的滑轮

root.bind("<Button-3>", command)

root.mainloop()

4) 菜单按钮控件

Menubutton（菜单按钮控件）是一个与 Menu 控件相关联的按钮，当我们按下按钮的时候下拉菜单就会自动弹出。通过 Menubutton 创建的菜单按钮可以自由地放置在窗口中的任意位置，从而提高了 GUI 界面的灵活性。

下面看一组简单使用示例：

from tkinter import *

win=Tk()

win.config(bg='#87CEEB')

win.title("C语言中文网")

win.geometry('450x350+300+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

#创建一个菜单按钮

menubtn=Menubutton(win, text='点击进行操作', relief='sunk')

# 设置位置（布局）

menubtn.grid(padx=195, pady=105)

#添加菜单,使用 tearoff 参数不显示分割线

filemenu=Menu(menubtn,tearoff = False)

filemenu.add_command(label='新建')

filemenu.add_command(label='删除')

filemenu.add_command(label='复制')

filemenu.add_command(label='保存')

# 显示菜单，将菜单命令绑定在菜单按钮对象上

menubtn.config(menu=filemenu)

win.mainloop()

十五、Tkinter Scrollbar滚动条控件

Scrollbar 控件常用于创建一个水平或者垂直的滚动条，通常情况下，Scrollbar 控件可以与 Listbox、Text、Canvas 以及 Entry 等控件一起使。

滚动条控件是 GUI  程序中经常使用的一种控件类型，它主要用来控制控件区域的可见范围，比如当 Text 控件的文本内容非常多时，为了方便用户阅读，可以给 Text 控件增加滚动条，用户只需拖动滚动条就能完成内容的阅读。

Scrollbar 控件的常用属性，如下表所示：

下面是介绍了 Scrollbar 控件常用的函数：

下面看一组简单的示例：

import tkinter as tk

from tkinter import Scrollbar, Listbox, RIGHT, LEFT, Y, X, BOTH, END, HORIZONTAL

root = tk.Tk()

root.title("C语言中文网")

root.geometry('450x180+300+200')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建一个垂直方向的滚动条控件

sbar1 = Scrollbar(root)

sbar1.pack(side=RIGHT, fill=Y) #

# 创建一个水平方向的滚动条控件

sbar2 = Scrollbar(root, orient=HORIZONTAL)

sbar2.pack(side=BOTTOM, fill=X)

# 创建列表框控件，并添加两个滚动条

mylist = Listbox(root, xscrollcommand=sbar2.set, yscrollcommand=sbar1.set)

for i in range(30):

    mylist.insert(END, '第' + str(i + 1) + '次:' + 'C语言中文网，网址为：c.biancheng.net' + '\n')

mylist.pack(side=LEFT, fill=BOTH)

# 使用 command 关联控件的 yview、xview方法

sbar1.config(command=mylist.yview)

sbar2.config(command=mylist.xview)

# 显示主窗口

root.mainloop()

十六、Tkinter Evenet事件处理

事件处理，是 GUI 程序中不可或缺的重要组成部分，相比来说，控件只是组成一台机器的零部件， 而事件处理则是驱动这台机器“正常”运转的关键所在，它能够将零部件之间“优雅”的贯穿起来，因此“事件处理”可谓是 GUI 程序的“灵魂”，同时它也是实现人机交互的关键。

对于“事件”这一名词，在讲解控件时也偶尔提及过，在本节我们将对 Tkinter 中的事件处理机制做更为详细的介绍。

在一款 GUI 程序中，我们将用户对软件的操作统称为“事件”，比如鼠标点击按钮、键盘输入文本以及窗口管理器触发的重绘事件等，这些事件有一个共同的特点，即都是由用户直接或者间接触发的。

事件绑定方法

Tkinter 提供的事件处理机制允许我们为“控件”绑定相应的事件和事件处理函数（即 callback函数），从而实现控件与用户的交互，其语法格式如下：

widget.bind("<event>",func)

上述语法中，widget 代表控件的实例对象，之后，采用 bind() 方法进行事件绑定，该函数有两个参数：

• <event>：一个字符串参数，表示事件的类型，并使用“尖括号”的形式进行包裹；
• func：表示事件的处理函数（callback，即回调函数），当触发事件时，Tk 会携带事件对象（Event）去调用 func 方法。

注意：bind() 方法可以完成事件与处理函数绑定，而使用 unbind() 方法可以将事件与处理函数解绑。

常用事件类型

事件类型（也称事件码）是 Tkinter 模块规定的，主要包括鼠标、键盘、光标等相关事件，Tkinter 为其规定了相应的语法格式：

<modifier-type-detail>

上述语法由三部分组成，说明如下：

• <>：事件类型必须包含在“尖括号”内；
• modifier：可选项，事件类型的修饰符，通常用于描述组合键、双击<Double-Button-1>、大写锁定键<Lock>以及<Alt-Shift>等；
• type：是必不可少的一项，表示事件的具体类型；
• detail：可选项，通常用于描述具体的哪个按键，比如 <Button-1> 表示鼠标左键；

这里有必要对经常使用的 modifier 修饰符做简单的介绍，修饰符可以修改事件的激活条件，比如双击鼠标或者需要同时按下某个键才触发事件，常用的修饰符如下：

下述表格中介绍了 Tkinter 中经常使用的事件类型，如下所示：

Event事件对象

当事件触发后，Tkinter 会自动将事件对象交给回调函数进行下步的处理，Event 对象包含了以下常用属性：

下面看一组关于“键盘事件”的使用示例：

from tkinter import *

# 定义事件函数，必须用event参数

def show_key(event):

    # 查看触发事件的按钮

    s=event.keysym

    # 将其显示在按钮控件上

    lb.config(text=s)

root=Tk()

root.config(bg='#87CEEB')

root.title("C语言中文网")

root.geometry('450x350+300+200')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 添加一个按钮控件

lb=Label(root,text='请按键',fg='blue',font=('微软雅黑',15))

# 给按钮控件绑定事件，按下任意键，然后调用事件处理函数。注意，此处需要在英文状态下进行输入

lb.bind('<Key>',show_key)

# 设置按钮获取焦点

lb.focus_set()

lb.pack()

# 显示窗口

root.mainloop()

注意：在上述示例中，只有当 Label 控件获取焦点后才能接收键盘事件，因此在给控件绑定事件和回调函数后，需要使用 focus_set() 方法来获取焦点。

下面再看一组关于“鼠标事件”的相关示例：

# 定义事件函数

from tkinter import *

def handleMotion(event):

    lb1['text'] = '你移动了光标的所在位置'

    lb2['text'] = '目前光标位置：x ='+ str(event.x)+';y='+str(event.y)

    print('光标当前位置',event.x,event.y)

# 创建主窗口

win = Tk()

win.config(bg='#87CEEB')

win.title("C语言中文网")

win.geometry('450x350+300+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建一个窗体容器frame

frame = Frame (win, relief=RAISED, borderwidth=2, width=300,height=200)

frame.bind('<Motion>',handleMotion)

lb1 = Label(frame,text='没有任何事件触发', bg='purple', )

# 使用place进行位置布局，下一节会介绍

lb1.place (x=20,y=20)

lb2 = Label(frame,text='')

lb2.place (x=16,y=60)

frame.pack(side=TOP)

# 显示窗口

win.mainloop()

十七、Tkinter布局管理方法

当我们在开发一个 GUI 程序的时候，布局管理发挥着非常重要的作用，它指的是通过管理控件在窗口中的位置（排版），从而实现对窗口和控件布局的目的。

一个优秀的图形用户界面，更像是艺术家的作品，它会给用户非常良好的感官体验，因此布局管理不单单是枯燥的程序代码，更需要以“美”的角度去审视每一个细节，这才是学习布局管理的“不二法门”。Tkinter 提供了一系列布局管理的方法和容器控件，通过对这些内容的学习，您将掌握如何使用不同的方法完成界面布局。

Tkinter 提供了三种常用的布局管理器，分别是 pack()、grid() 以及 place()，如下表所示：

上述三种方法适用于 Tkinter 中的所有控件，在讲解前面内容时，对其中一些方法已经做了相关的介绍，比如 pack() 和 grid()。在本节会对上述三个方法的应用场景做更为详细的介绍。

pack()

pack() 是一种较为简单的布局方法，在不使用任何参数的情况下，它会将控件以添加时的先后顺序，自上而下，一行一行的进行排列，并且默认居中显示。pack() 方法的常用参数如下所示：

下面看一组简单的使用示例：

from tkinter import  *

win = Tk()

win.title("C语言中文网")

win.geometry('450x300+300+300')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

lb_red = Label(win,text="红色",bg="Red",fg='#ffffff',relief=GROOVE)

# 默认以top方式放置

lb_red.pack()

lb_blue = Label(win,text="蓝色",bg="blue",fg='#ffffff',relief=GROOVE)

# 沿着水平方向填充，使用 pady 控制蓝色标签与其他标签的上下距离为 5 个像素

lb_blue.pack(fill=X,pady='5px')

lb_green = Label(win,text="绿色",bg="green",fg='#ffffff',relief=RAISED)

# 将 黄色标签所在区域都填充为黄色，当使用 fill 参数时，必须设置 expand = 1，否则不能生效

lb_green.pack(side=LEFT,expand=1,fill = BOTH)

win.mainloop()

grid()

grid() 函数是一种基于网格式的布局管理方法，相当于把窗口看成了一张由行和列组成的表格。当使用该 grid 函数进行布局的时，表格内的每个单元格都可以放置一个控件。，从而实现对界面的布局管理。

注意：这里的所说的“表格”是虚拟出来，目的是便于大家理解，其实窗体并不会因为使用了 gird() 函数，而增加一个表格。

grid() 函数的常用参数如下所示：

grid() 方法相比 pack() 方法来说要更加灵活，以网格的方式对组件进行布局管理，让整个布局显得非常简洁、优雅。如果说非要从三个布局管理器中选择一个使用的话，那么我推荐大家使用 grid() 方法。

这里有一点需要大家要特别注意，在一个程序中不能同时使用 pack() 和 grid() 方法，这两个方法只能二选一，否则程序会运行错误。

下面看一组有关 grid() 函数的简单的示例：

from tkinter import *

#主窗口

win = Tk()

win.config(bg='#87CEEB')

win.title("C语言中文网")

win.geometry('500x350+300+300')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

#在窗口内创建按钮，以表格的形式依次排列

for i in range (10):

    for j in range (10):

        Button (win, text=" (" + str(i) + ","+ str(j)+ ")",bg='#D1EEEE') .grid(row=i,column=j)

# 在第5行第11列添加一个Label标签

Label(win,text="C语言中文网",fg='blue',font=('楷体',12,'bold')).grid(row =4,column=11)

#开始窗口的事件循环

win. mainloop()

当使用 grid 函数布局的时，其实就是为各个控件指定行号、列号的过程，我们不需要为每个单元格指定大小，因为 grid 会为每个单元格自动设置一个适合的尺寸。

下面通过 grid() 布局管理器制作一个简易的登录界面，代码如下所示：

import tkinter as tk

from tkinter import messagebox

root = tk.Tk()

root.title("C语言中文网")

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

root.resizable(0,0)

tk.Label(root, text="用户名").grid(row=0, sticky="w")

tk.Label(root, text="密码").grid(row=1, sticky="w")

tk.Entry(root).grid(row=0, column=1)

tk.Entry(root, show="*").grid(row=1, column=1)

# 加载图片LOGO,注意这里是gif格式的图片

photo = tk.PhotoImage(file="C:/Users/Administrator/Desktop/1.gif")

tk.Label(root, image=photo).grid(row=0, column=2, rowspan=2, padx='4px', pady='5px')

# 编写一个简单的回调函数

def login():

    messagebox.showinfo('欢迎来到C语言中文网')

# 使用grid()函数来布局，并控制按钮的显示位置

tk.Button(root, text="登录", width=10, command=login).grid(row=3, column=0, columnspan=2,sticky="w", padx=10, pady=5)

tk.Button(root, text="退出", width=10, command=root.quit).grid(row=3, column=1, columnspan=2,sticky="e", padx=10, pady=5)

# 开启事件主循环

root.mainloop()

place()

与前两种布局方法相比，采用 place() 方法进行布局管理要更加精细化，通过 place() 布局管理器可以直接指定控件在窗体内的绝对位置，或者相对于其他控件定位的相对位置。

下面对 place 布局管理器的常用属性做相关介绍：

通过上述描述我们知道，relx和rely参数指定的是控件相对于父组件的位置，而relwidth和relheight参数则是指定控件相对于父组件的尺寸大小。

注意：这里父组件指的是当前可操作控件的上层组件，比如在没有使用容器控件（frame）的窗体中，控件的父组件就是主窗口本身，在《Tkinter布局管理容器控件》一节会做针对性介绍。

上述表格中关于距离位置的参数容易产生“疑惑”，下面通过一组简单的示例来进一步说明：

from tkinter import *

#主窗口

win = Tk()

win.title("C语言中文网")

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

#创建一个frame窗体对象，用来包裹标签

frame = Frame (win, relief=SUNKEN, borderwidth=2, width=450, height=250)

# 在水平、垂直方向上填充窗体

frame. pack (side=TOP, fill=BOTH, expand=1)

# 创建 "位置1"

Label1 = Label ( frame, text="位置1",bg='blue',fg='white')

# 使用 place,设置第一个标签位于距离窗体左上角的位置（40,40）和其大小（width，height）

# 注意这里（x,y）位置坐标指的是标签左上角的位置（以NW左上角进行绝对定位，默认为NW）

Label1.place (x=40,y=40, width=60, height=30)

# 设置标签2

Label2 = Label (frame, text="位置2",bg='purple',fg='white')

# 以右上角进行绝对值定位，anchor=NE，第二个标签的位置在距离窗体左上角的(180，80)

Label2.place(x=180,y=80, anchor=NE, width=60, height=30)

# 设置标签3

Label3 = Label (frame, text="位置3",bg='green',fg='white')

# 设置水平起始位置相对于窗体水平距离的0.6倍，垂直的绝对距离为80，大小为60，30

Label3.place(relx=0.6,y=80, width=60, height=30)

# 设置标签4

Label4 = Label (frame, text="位置4",bg='gray',fg='white')

# 设置水平起始位置相对于窗体水平距离的0.01倍，垂直的绝对距离为80，并设置高度为窗体高度比例的0.5倍，宽度为80

Label4.place(relx=0.01,y=80,relheight=0.4,width=80)

#开始事件循环

win. mainloop()

注意：在一个父组件中 place()方法可以与 grid() 方法混合使用，要与 pack() 进行区别。

十八、Tkinter布局管理控件

除了上一节《Tkinter布局管理方法》中提到的三个常用方法外，Tkinter  还提供了几个常用的布局管理控件，比如 Frame 、LabelFrame 等，这些控件的主要作用是为其他控件提供载体，并将主窗口界面划分成多个区域，从而方便开发者对不同区域进行设计与管理。

在前文讲解其他的 Tkinter 控件时，我们列举的大多数示例都是将控件直接放置在主窗口（即根窗口）内，这样做的目的是为了便于大家理解。但在实际的开发过程中，控件一般放置在容器中，比如 Frame 容器控件，如同 HTML 中的<div>标签一样，把容器看做成一个框架，其他控件则是这个框架中的“元素”。

本节介绍了四种常用的容器控件以及它们的使用方法，分别是 Frame、LabelFrame、PanedWindow 以及 Toplevel。

Frame控件

Frame 本质上也是一个矩形窗体，同其他控件一样也需要位于主窗口内。我们可以在主窗口内放置多个 Frame 控件，并且每个 Frame 中还可以嵌套一个或者多个Frame，从而将主窗口界面划分成多个区域。

Frame 控件的常用属性如下表所示：

下面看一组简单的示例，通过 Frame 将主窗口分成左右两个部分，如下所示：

import tkinter as tk

win = tk.Tk()

win.title("C语言中文网")

win.geometry('400x350+200+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 在主窗口上添加一个frame控件

frame1 = tk.Frame(win)

frame1.pack()

# 在frame_1上添加另外两个frame， 一个在靠左，一个靠右

#左侧的frame

frame_left = tk.Frame(frame1)

tk.Label(frame_left,text='左侧标签1',bg='green',width=10,height=5).grid(row =0,column=0)

tk.Label(frame_left,text='左侧标签2',bg='blue',width=10,height=5).grid(row = 1 ,column =1)

# Label的width和height单位是文本单元（放文字时）

frame_left.pack(side=tk.LEFT)

frame_right = tk.Frame(frame1)

tk.Label(frame_right,text='右侧标签1',bg='gray',width=10,height=5).grid(row = 0 ,column =1)

tk.Label(frame_right,text='右侧标签2',bg='pink',width=10,height=5).grid(row = 1 ,column =0)

tk.Label(frame_right,text='右侧标签3',bg='purple',width=10,height=5).grid(row= 1,column=1)

frame_right.pack(side=tk.RIGHT)

win.mainloop()

上述示例利用 Frame 控件将主窗口分成了左右两个子区域，同时在各自区域中添加了 Label 标签，而且区域之间互不干扰。采用这种分区、分块的布局方式，可以使得 GUI 程序更加规范、简洁化。

LabelFrame控件

LabelFrame 控件也是一种容器类型的控件，它属于是 Frame 控件的变体，因此它们的属性选项大体相同。

在默认情况下，LabelFrame 会在其包裹的子组件周围绘制一个边框和一个标题。当我们想要将一些相关的组件分为一组时，就可以使用 LabelFrame 组件，比如把一系列 Radiobutton（单选按钮）放在一起来供用户选择。

同 Frame 控件一样，LabelFrame 的主要作用也是对控件进行分组处理，下面看一个具体的实例：

import tkinter as tk

win = tk.Tk()

win.title("C语言中文网")

win.geometry('800x350+200+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 定义第一个容器，使用 labelanchor ='w' 来设置标题的方位

frame_left = tk.LabelFrame(win, text="教程", labelanchor="w",bg='#5CACEE')

# 使用 place 控制 LabelFrame 的位置

# relx/rely定义控件相对于根窗口（或其他控件）在水平和垂直方向上的相对位置（即位移比例），取值范围再0.0~1.0 之间

frame_left.place(relx=0.2, rely=0.2, relwidth=0.2, relheight=0.5)

label_1 = tk.Label(frame_left, text="C语言")

label_1.place(relx=0.2, rely=0.2)

label_2 = tk.Label(frame_left, text="Python")

label_2.place(relx=0.6, rely=0.2)

label_3 = tk.Label(frame_left, text="Java")

label_3.place(relx=0.2, rely=0.6)

label_4 = tk.Label(frame_left, text="C++")

label_4.place(relx=0.6, rely=0.6)

# 定义第二个容器，使用 labelanchor ='w' 来设置标题的方位

frame_right = tk.LabelFrame(win, text="辅导班", labelanchor="w",bg='#66CDAA')

# 使用 place 控制 LabelFrame 的位置

frame_right.place(relx=0.5, rely=0.2, relwidth=0.3, relheight=0.6)

label_1 = tk.Label(frame_right, text="C语言辅导班")

label_1.place(relx=0.2, rely=0.2)

label_2 = tk.Label(frame_right, text="数据结构")

label_2.place(relx=0.6, rely=0.2)

label_3 = tk.Label(frame_right, text="C++辅导班")

label_3.place(relx=0.2, rely=0.6)

label_4 = tk.Label(frame_right, text="Python答疑")

label_4.place(relx=0.6, rely=0.6)

win.mainloop()

PanedWindow控件

PanedWindow（窗格界面）也可以理解成一个特殊的 Frame 控件，它是 Tkinter 8.4 版本后新增的空间管理组件，其主要目的是为其他组件提供一个容器或者框架，从而实现以分块的形式对图形界面进行布局。

与 Frame 控件不同， PanedWindow 允许用户自主地调整界面划分以及每块区域的大小。因此，当您需要让用户自己调节每块区域的大小时，就可以采用 PanedWindow 作为组件载体来进行界面的布局。

不仅如此 PanedWindow 组件还提供了“手柄” 功能（设置参数 showhandle=True 来启用），通过拖动“手柄”图标也可以改变每块区域的大小。PanedWindow 组件语法格式如下所示：

PanedWindow(master=None, **options)

其中 master 表示父组件，即包裹该组件的上层组件。其常用属性如下表所示：

PanedWindow 的常用方法如下表所示：

下面示例设计一个简单的界面布局，然后将图形界面分割成四部分：创建一个水平方向的 PanedWindow，并向其中添加两个 Label 组件，之后创建一个垂直的方向的 PanedWindow，并向其中中添加两个 Label 标签。示例代码如下：

import tkinter as tk

win = tk.Tk()

win.title("C语言中文网")

win.geometry('400x400+200+200')

win.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

# 创建一个水平方向的 panedwindow，并添加到主窗口中，默认为水平方向

p_window1 = tk.PanedWindow(win)

p_window1.pack(fill=tk.BOTH, expand=1)

# 在窗口区的左侧添加两个水平方向的 Label

left1 =tk. Label(p_window1, text='C语言中文网', bg='#7CCD7C', width=10,font=('微软雅黑',15))

p_window1.add(left1)

left2 =tk.Label(p_window1, text='网址：c.biancheng.net', bg='#9AC0CD', width=10,font=('微软雅黑',15))

p_window1.add(left2)

# 创建一个垂直方向的panedwindow,并添加一个手柄，设置分割线样式

p_window2 = tk.PanedWindow(orient=tk.VERTICAL,showhandle=True,sashrelief='sunken')

# 添加到 p_window1中

p_window1.add(p_window2)

# 在 p_window2 中添加两个垂直方向的标签

top_label =tk. Label(p_window2, text='教程', bg='#7171C6', height=8,font=('宋体',15))

p_window2.add(top_label)

bottom_label =tk. Label(p_window2, text='辅导班', bg='#8968CD',font=('宋体',15))

p_window2.add(bottom_label)

win.mainloop()

注意：从上述示例中可以看出 PanedWindw 会为每一个 Label 控件创建一个独立的窗格， 当我们将鼠标悬停在两个控件接壤处的白色边框上时，就会出现可以上下或者左右拉伸的指示光标，用户按照可以按照自己的意愿来调整每块区域的大小。

Toplevel控件

Toplevel 是一个顶级窗口控件（也被称为“子窗体”控件），同样类似于 Frame 控件， 不过该控件会脱离根窗口另行创建一个独立窗口，因此它的存在形式不同于上述其他容器。

Toplevel 控件同样隶属于主窗口的子组件，只是存在形式特殊而已。Toplevel 是主窗口之外的弹出框窗口（通过事件来触发执行），在这个窗口内也可以包含其他组件。但需要注意，顶级窗口并不是必须位于窗口的顶部位置，之所以称其为顶级窗口，是因为相对于主窗口而言，Topleve 位于主窗口的上一层。

Toplevel 控件拥有根窗口控件的所有方法和属性，同时它还拥有一些独有的方法，如下表所示：

下面看一组关于创建 Toplevel 的示例，如下所示：

import tkinter as tk

root = tk.Tk()

root.config(bg='#87CEEB')

root.title("C语言中文网")

root.geometry('400x350+300+300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

def create_toplevel():

    top = tk.Toplevel()

    top.title("C语言中文网")

    top.geometry('300x200+100+100')

    top.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

    # 多行文本显示Message控件

    msg = tk.Label(top, text="网址：c.biancheng.net",bg='#9BCD9B',font=('宋体',15))

    msg.pack()

tk.Button(root, text="点击创建Toplevel组件", width=20,height=3,command=create_toplevel).pack()

root.mainloop()

十九、Tkinter对话框控件

在前面的章节中，我们花费了大量的时间讲解了 Tkinter 中常用基本控件，通过对这些控件的学习，我们对  GUI 开发有了基本的认识与掌握，一个完整的 GUI 程序就是由这些组件以合理、美观的布局方式构成的。

除了基本的控件之外，Tkinter 还提供了三种对话框控件：

• 文件选择对话框：filedailog
• 颜色选择对话框：colorchooser
• 消息对话框：messagebox

这些对话框的使用能够在一定程度上增强用户的交互体验，下面对这些对话框控件进行详细地介绍。

19.1 文件选择对话框

文件对话框在 GUI 程序中经常的使用到，比如上传文档需要从本地选择一个文件，包括文件的打开和保存功能都需要一个文件对话框来实现。Tkinter 提供文件对话框被封装在tkinter.filedailog模块中，该模块提供了有关文件对话框的常用函数，经常使用的有以下几个：

上述方法的常用参数值如下所示：

下面看一组具体的实例应用：

from tkinter import *

import tkinter.filedialog  # 注意此处要将文件对话框导入

# 定义一个处理文件的相关函数

def askfile():

    # 从本地选择一个文件，并返回文件的目录

    filename = tkinter.filedialog.askopenfilename()

    if filename != '':

         lb.config(text= filename)

    else:

         lb.config(text='您没有选择任何文件')

root = Tk()

root.config(bg='#87CEEB')

root.title("C语言中文网")

root.geometry('400x200+300+300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

btn=Button(root,text='选择文件',relief=RAISED,command=askfile)

btn.grid(row=0,column=0)

lb = Label(root,text='',bg='#87CEEB')

lb.grid(row=0,column=1,padx=5)

# 显示窗口

root.mainloop()

下面再看一组“保存文件”的示例代码如下：

import tkinter as tk

from tkinter import filedialog

from PIL import Image # 从Pillow库（PIL）导入Image模块

def open_img():

    try:

        global img # 声明全局变量img，这允许在函数内部访问和修改img

        filepath = filedialog.askopenfilename() # 打开文件，返回该文件的完整路径

        filename.set(filepath) # 设置动态字符变量filename的文本为所选文件的路径

        img = Image.open(filename.get()) # 使用Image类的open函数打开在filename.get()中指定的图像文件，并将返回的图像对象存储在变量img中

    except Exception as e:

        print("您没有选择任何文件",e)

def save_png():

    try:

        filetypes = [("PNG","*.png"), ("JPG", "*.jpg"), ("GIF","*.gif"),("txt files","*.txt"),('All files','*')]

        # 返回一个 pathname 文件路径字符串，如果取消或者关闭则返回空字符，返回文件如何操作是后续代码的事情，

        # 该函数知识返回选择文件的文件名字，不具备保存文件的能力

        filenewpath= filedialog.asksaveasfilename(title='保存文件',

                                                filetypes=filetypes,

                                                defaultextension='.png',

                                                initialdir='C:/Users/Administrator/Desktop' )

        path_var.set(filenewpath)

        # 保存文件

        img.save(str(path_var.get()))

    except Exception as e:

        print(e)

window = tk.Tk()

window.title("C语言中文网")

window.geometry('400x200+300+300')

window.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

filename = tk.StringVar()

path_var = tk.StringVar()

# 定义读取文件的组件

entry = tk.Entry(window, textvariable=filename)

entry.grid(row=1, column=0, padx=5, pady=5)

tk.Button(window, text='选择文件', command=open_img).grid(row=1, column=1, padx=5, pady=5)

# 定义保存文件的组件

entry1 = tk.Entry(window, textvariable=path_var)

entry1.grid(row=2, column=0, padx=5, pady=5)

tk.Button(window, text='保存文件', command=save_png).grid(row=2, column=1, padx=5, pady=5)

window.mainloop()

颜色选择对话框

颜色选择对话框（colorchooser），提供了一个非常友善的颜色面板，它允许用户选择自己所需要的颜色。 当用户在面板上选择一个颜色并按下“确定”按钮后，它会返回一个二元祖，其第 1 个元素是选择的 RGB 颜色值，第 2 个元素是对应的 16 进制颜色值。

颜色选择对话款主要应用在画笔、涂鸦等功能上，通过它可以绘制出五彩缤纷的颜色，该对话框的使用非常简单，主要有以下两个常用方法：

常用的颜色对话框的参数值如下表所示：

下面看一组简单的使用示例：

import tkinter as tk

from tkinter import colorchooser

root = tk.Tk()

root.title("颜色选择")

root.geometry('400x200+300+300')

root.iconbitmap('C:/Users/Administrator/Desktop/C语言中文网logo.ico')

def callback():

    # 打开颜色对话款

    colorvalue = tk.colorchooser.askcolor()

    # 在颜色面板点击确定后，会在窗口显示二元组颜色值

    lb.config(text='颜色值:'+ str(colorvalue))

lb=tk.Label(root,text='',font=('宋体',10))

# 将label标签放置在主窗口

lb.pack()

tk.Button(root, text="点击选择颜色", command=callback, width=10, bg='#9AC0CD').pack()

# 显示界面

root.mainloop()

消息对话框

关于消息对话款（messagebox），在前面介绍其他控件时已经使用过，在本节仅对它做简单介绍。

消息对话框主要起到信息提示、警告、说明、询问等作用，通常配合“事件函数”一起使用，比如执行某个操作出现了错误，然后弹出错误消息提示框。通过使用消息对话框可以提升用户的交互体验，也使得 GUI 程序更加人性化。消息对话框主要包含了以下常用方法：

上述方法拥有相同的选项参数，如下表所示：

上述方法的返回值一般会是一个布尔值，或者是“YES”，“NO”，“OK”等，这些方法使用较为简单，此处不进行逐一列举，看个简单的示例即可：

import tkinter.messagebox

result=tkinter.messagebox.askokcancel("提示","确定要关闭窗口吗?")

# 返回布尔值

print(result)