Tkinter 一文读懂

news2024/11/18 6:24:50

Tkinter 简介

Tkinter(即 tk interface,简称“Tk”)本质上是对 Tcl/Tk 软件包的 Python 接口封装,它是 Python 官方推荐的 GUI 工具包,属于 Python 自带的标准库模块,当您安装好 Python 后,就可以直接使用它,而无须另行安装。

作为一款 Python GUI 工具,Tkinter 拥有良好的跨平台性,支持 Windows、Linux、Mac 平台,它传承了 Python 语法简洁、代码易读的基本特点。

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

Tkinter 快速入门

Tkinter 程序至少应包含以下四个部分:

  • 导入 tkinter 模块
  • 创建主窗口,也称 root 窗口(即根窗口)
  • 添加人机交互控件,同时编写相应的事件函数
  • 通过主循环(mainloop)来显示主窗口
# 第一章节:Tkinter 快速入门
import tkinter

# 调用Tk()创建主窗口
root_window = tkinter.Tk()
# 给主窗口起一个名字,也就是窗口的名字
root_window.title('Tkinter 快速入门')
# 开启主循环,让窗口处于显示状态
root_window.mainloop()

上述代码创建了一个没有添加任何交互控件的 Tkinter 程序,它也是最简单的 GUI 程序。这里的主窗口相当于画板,其他的控件都要建立在主窗口之上。主循环也称“消息循环”或“事件循环”其主要作用是让主窗口处于显示状态。

下面通过Tkinter实现简单登入页面,代码如下所示:

# 第二章节:Tkinter 实现简单登入页面
import tkinter

import tkinter
import tkinter.messagebox

# 创建应用程序窗口
root = tkinter.Tk()
varName = tkinter.StringVar()
varName.set('')
varPwd = tkinter.StringVar()
varPwd.set('')
# 创建标签
labelName = tkinter.Label(root, text='用户名:', justify=tkinter.RIGHT, width=80)
# 将标签放到窗口上
labelName.place(x=10, y=5, width=80, height=20)
# 创建文本框,同时设置关联的变量
entryName = tkinter.Entry(root, width=80, textvariable=varName)
entryName.place(x=100, y=5, width=80, height=20)

labelPwd = tkinter.Label(root, text='密 码:', justify=tkinter.RIGHT, width=80)
labelPwd.place(x=10, y=30, width=80, height=20)
# 创建密码文本框
entryPwd = tkinter.Entry(root, show='*', width=80, textvariable=varPwd)
entryPwd.place(x=100, y=30, width=80, height=20)


# 登录按钮事件处理函数
def login():
    # 获取用户名和密码
    name = entryName.get()
    pwd = entryPwd.get()
    if name == 'admin' and pwd == '123456':
        tkinter.messagebox.showinfo(title='Python tkinter', message='登录成功!')
    else:
        tkinter.messagebox.showerror(title='Python tkinter', message='登录失败')


# 创建按钮组件,同时设置按钮事件处理函数
buttonOk = tkinter.Button(root, text='登录', command=login)
buttonOk.place(x=30, y=70, width=50, height=20)


# 取消按钮的事件处理函数
def cancel():
    # 清空用户输入的用户名和密码
    varName.set('')
    varPwd.set('')


buttonCancel = tkinter.Button(root, text='取消', command=cancel)
buttonCancel.place(x=90, y=70, width=50, height=20)

# 启动消息循环
root.mainloop()

效果截图:

下面对登入页面进行简单分析:

1) 主窗口设置

主要对主窗口进行实例化

# 创建应用程序窗口
root = tkinter.Tk()

2) 添加标签控件和文本输入框

上述程序中,我们添加二个标签控件和二个文本输入框。需要注意的是,当成功创建标签(文本)对象后,使用 place 方法将其放置在主窗口内(place 方法又称绝对/相对布局管理器)。

# 创建标签
labelName = tkinter.Label(root, text='用户名:', justify=tkinter.RIGHT, width=80)
# 将标签放到窗口上
labelName.place(x=10, y=5, width=80, height=20)
# 创建文本框,同时设置关联的变量
entryName = tkinter.Entry(root, width=80, textvariable=varName)
entryName.place(x=100, y=5, width=80, height=20)

labelPwd = tkinter.Label(root, text='密 码:', justify=tkinter.RIGHT, width=80)
labelPwd.place(x=10, y=30, width=80, height=20)
# 创建密码文本框
entryPwd = tkinter.Entry(root, show='*', width=80, textvariable=varPwd)
entryPwd.place(x=100, y=30, width=80, height=20)

3) 添加按钮

添加按钮的逻辑和添加文本标签类似,值得注意的是,按钮控件通过command参数实现了"登入"/"取消"功能。

# 登录按钮事件处理函数
def login():
    # 获取用户名和密码
    name = entryName.get()
    pwd = entryPwd.get()
    if name == 'admin' and pwd == '123456':
        tkinter.messagebox.showinfo(title='Python tkinter', message='登录成功!')
    else:
        tkinter.messagebox.showerror(title='Python tkinter', message='登录失败')


# 创建按钮组件,同时设置按钮事件处理函数
buttonOk = tkinter.Button(root, text='登录', command=login)
buttonOk.place(x=30, y=70, width=50, height=20)


# 取消按钮的事件处理函数
def cancel():
    # 清空用户输入的用户名和密码
    varName.set('')
    varPwd.set('')


buttonCancel = tkinter.Button(root, text='取消', command=cancel)
buttonCancel.place(x=90, y=70, width=50, height=20)

Tkinter常用控件和属性

Tkinter 的提供各种控件,如按钮,标签和文本框,一个 GUI 应用程序中使用。这些控件通常被称为控件或者部件。

Tkinter控件

目前有 15 种 Tkinter 的部件。我们提出这些部件以及一个简短的介绍,在下面的表:

控件描述
Button按钮控件;在程序中显示按钮。
Canvas画布控件;显示图形元素如线条或文本
Checkbutton多选框控件;用于在程序中提供多项选择框
Entry输入控件;用于显示简单的文本内容
Frame框架控件;在屏幕上显示一个矩形区域,多用来作为容器
Label标签控件;可以显示文本和位图
Listbox列表框控件;在Listbox窗口小部件是用来显示一个字符串列表给用户
Menubutton菜单按钮控件,由于显示菜单项。
Menu菜单控件;显示菜单栏,下拉菜单和弹出菜单
Message消息控件;用来显示多行文本,与label比较类似
Radiobutton单选按钮控件;显示一个单选的按钮状态
Scale范围控件;显示一个数值刻度,为输出限定范围的数字区间
Scrollbar滚动条控件,当内容超过可视化区域时使用,如列表框。.
Text文本控件;用于显示多行文本
Toplevel容器控件;用来提供一个单独的对话框,和Frame比较类似
Spinbox输入控件;与Entry类似,但是可以指定输入范围值
PanedWindowPanedWindow是一个窗口布局管理的插件,可以包含一个或者多个子控件。
LabelFramelabelframe 是一个简单的容器控件。常用与复杂的窗口布局。
tkMessageBox用于显示你应用程序的消息框。

控件通用基本属性

在 Tkinter 中不同的控件受到各自参数的约束(即参数),所有控件既有相同属性,也有各自独有的属性。我们先对这些控件的共用属性做简单介绍,如下表所示:

属性名称说明
anchor定义控件或者文字信息在窗口内的位置
bgbg 是 background 的缩写,用来定义控件的背景颜色,参数值可以颜色的十六进制数,或者颜色英文单词
bitmap定义显示在控件内的位图文件
borderwidth定于控件的边框宽度,单位是像素
command该参数用于执行事件函数,比如单击按钮时执行特定的动作,可将执行用户自定义的函数
cursor当鼠标指针移动到控件上时,定义鼠标指针的类型,字符换格式,参数值有 crosshair(十字光标)watch(待加载圆圈)plus(加号)arrow(箭头)等
font若控件支持设置标题文字,就可以使用此属性来定义,它是一个数组格式的参数 (字体,大小,字体样式)
fgfg 是 foreground 的缩写,用来定义控件的前景色,也就是字体的颜色
height该参数值用来设置控件的高度,文本控件以字符的数目为高度(px),其他控件则以像素为单位
image定义显示在控件内的图片文件
justify定义多行文字的排列方式,此属性可以是 LEFT/CENTER/RIGHT
padx/pady定义控件内的文字或者图片与控件边框之间的水平/垂直距离
relief定义控件的边框样式,参数值为FLAT(平的)/RAISED(凸起的)/SUNKEN(凹陷的)/GROOVE(沟槽桩边缘)/RIDGE(脊状边缘)
text定义控件的标题文字
state控制控件是否处于可用状态,参数值默认为 NORMAL/DISABLED,默认为 NORMAL(正常的)
width用于设置控件的宽度,使用方法与 height 相同

Tkinter主窗口 

主窗口是一切控件的基础,所有的控件的都需要通过主窗口来显示。

创建一个空白窗口

# 第三章节:Tkinter 创建空白页面
from tkinter import *

# 创建一个主窗口对象
window = Tk()
# 调用mainloop()显示主窗口
window.mainloop()

窗口常用方法

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

函数说明
window.title("my title")接受一个字符串参数,为窗口起一个标题
window.resizable()是否允许用户拉伸主窗口大小,默认为可更改,当设置为 resizable(0,0)或者resizable(False,False)时不可更改
window.geometry()设定主窗口的大小以及位置,当参数值为 None 时表示获取窗口的大小和位置信息。
window.quit()关闭当前窗口
window.update()刷新当前窗口
window.mainloop()设置窗口主循环,使窗口循环显示(一直显示,指导窗口被关闭)
window.iconbitmap()设置窗口左上角的图标(图标是.ico文件类型)
window.config(background ="red")设置窗口的背景色为红色,也可以接受 16 进制的颜色值
window.minsize(50,50)设置窗口被允许调整的最小范围,即宽和高各50
window.maxsize(400,400)设置窗口被允许调整的最大范围,即宽和高各400
window.attributes("-alpha",0.5)用来设置窗口的一些属性,比如透明度(-alpha)、是否置顶(-topmost)即将主屏置于其他图标之上、是否全屏(-fullscreen)全屏显示等
window.state("normal")用来设置窗口的显示状态,参数值 normal(正常显示),icon(最小化),zoomed(最大化),
window.withdraw()用来隐藏主窗口,但不会销毁窗口。
window.iconify()设置窗口最小化
window.deiconify()将窗口从隐藏状态还原
window.winfo_screenwidth()
window.winfo_screenheight()
获取电脑屏幕的分辨率(尺寸)
window.winfo_width()
window.winfo_height() 
获取窗口的大小,同样也适用于其他控件,但是使用前需要使用 window.update() 刷新屏幕,否则返回值为1
window.protocol("协议名",回调函数)启用协议处理机制,常用协议有 WN_DELETE_WINDOW,当用户点击关闭窗口时,窗口不会关闭,而是触发回调函数。
# 第四章节:Tkinter 主窗口相关函数
from tkinter import *


window = Tk()
# 设置窗口title
window.title('Tkinter 快速入门')
# 设置窗口大小:宽x高,注,此处不能为 "*",必须使用 "x"
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',1)
# 设置窗口被允许最大调整的范围,与resizble()冲突
window.maxsize(600, 600)
# 设置窗口被允许最小调整的范围,与resizble()冲突
window.minsize(50, 50)
# 更改左上角窗口的的icon图标,加载C语言中文网logo标
window.iconbitmap("img/1.png")

# 进入主循环,显示主窗口
window.mainloop()

 设置主窗位置

实际情况中窗口的位置在电脑屏幕的居中位置,我们应该如何处理呢?其实很简单,通过窗口对象的 geometry() 方法即可改变主窗口的位置,其语法格式如下:

geometry('450x400+300+200')

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

geometry('+-1500+-2000')

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

# 第五章节:Tkinter 主窗口屏幕居中显示
import tkinter as tk

window = tk.Tk()
# 设置窗口大小变量
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 控件使用指南

Tkinter Label标签控件

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

下面对 Label(标签)的常用属性做简单介绍:
 

属性名称说明
anchor控制文本(或图像)在 Label 中显示的位置(方位),通过方位的英文字符串缩写(n、ne、e、se、s、sw、w、nw、center)实现定位,默认为居中(center)
bg用来设置背景色
bd即 borderwidth 用来指定 Label 控件的边框宽度,单位为像素,默认为 2 个像素
bitmap指定显示在 Label 控件上的位图,若指定了 image 参数,则该参数会被忽略
compound控制 Lable 中文本和图像的混合模式,若选项设置为 CENTER,则文本显示在图像上,如果将选项设置为 BOTTOM、LEFT、RIGHT、TOP,则图像显示在文本旁边。
cursor指定当鼠标在 Label 上掠过的时候,鼠标的的显示样式,参数值为 arrow、circle、cross、plus
disableforeground指定当 Label 设置为不可用状态的时候前景色的颜色
font指定 Lable 中文本的 (字体,大小,样式)元组参数格式,一个 Lable 只能设置一种字体
fg设置 Label 的前景色
height/width设置 Lable 的高度/宽度,如果 Lable 显示的是文本,那么单位是文本单元,如果 Label 显示的是图像,那么单位就是像素,如果不设置,Label 会自动根据内容来计算出标签的高度
highlightbackground当 Label 没有获得焦点的时候高亮边框的颜色,系统的默认是标准背景色
highlightcolor指定当 Lable 获得焦点的话时候高亮边框的颜色,系统默认为0,不带高亮边框
image指定 Label 显示的图片,一般是 PhotoImage、BitmapImage 的对象
justify表示多行文本的对齐方式,参数值为 left、right、center,注意文本的位置取决于 anchor 选项
padx/padypadx 指定 Label 水平方向上的间距(即内容和边框间),pady 指定 Lable 水平方向上的间距(内容和边框间的距离)
relief指定边框样式,默认值是 "flat",其他参数值有 "groove"、"raised"、"ridge"、"solid"或者"sunken"
state该参数用来指定 Lable 的状态,默认值为"normal"(正常状态),其他可选参数值有"active"和"disabled"
takefocus默认值为False,如果是 True,表示该标签接受输入焦点
text用来指定 Lable 显示的文本,注意文本内可以包含换行符
underline给指定的字符添加下划线,默认值为 -1 表示不添加,当设置为 1 时,表示给第二个文本字符添加下划线。
wraplength将 Label 显示的文本分行,该参数指定了分行后每一行的长度,默认值为 0

Label控件构成

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

  • width/height
  • padx/pady
  • borderwidth


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

Label控件组成

图1:Label控件组成


边框的宽度可以通过 borderwidth 来调整,其样式可以通过relief来设置(默认为平的 flat);填充区的大小调整分为水平方向和垂直方向,可以使用padxpady来调整;内容区则主要用来显示文字或者图片,其大小由 width/height 来控制。

# 第六章节:Tkinter Label标签
import tkinter as tk

window = tk.Tk()
# 设置窗口大小变量
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)

# 若内容是文字则以字符为单位,图像则以像素为单位
label = tk.Label(window, text="Tkinter Label标签", bg="red",
                 # 设置标签内容区大小
                 width=30, height=5,
                 # 设置填充区距离、边框宽度和其样式(凹陷式)
                 padx=10, pady=15, borderwidth=10, relief="sunken")
label.pack()
window.mainloop()
# 第六章节:Tkinter Label标签:label 设置背景图片
import tkinter as tk

window = tk.Tk()
# 设置窗口大小变量
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)

# 若内容是文字则以字符为单位,图像则以像素为单位
label = tk.Label(window, text="Tkinter Label标签", bg="red",
                 # 设置标签内容区大小
                 width=30, height=5,
                 # 设置填充区距离、边框宽度和其样式(凹陷式)
                 padx=10, pady=15, borderwidth=10, relief="sunken")
label.pack()

# 显示图片
photo = tk.PhotoImage(file='img/1.png')
tk.Label(window, image=photo).pack()

window.mainloop()

 Message控件

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

# 第八章节:Tkinter Message标签
import tkinter as tk

window = tk.Tk()
# 设置窗口大小变量
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)

# 若内容是文字则以字符为单位,图像则以像素为单位
txt = "鹅,鹅,鹅,曲项向天歌。白毛浮绿水,红掌拨清波"
msg = tk.Message(window, text=txt, width=60, font=('微软雅黑', 10, 'bold'))
msg .pack()

window.mainloop()

Tkinter Button 按钮控件

Button 控件是 Tkinter 中常用的窗口部件之一,同时也是实现程序与用户交互的主要控件。通过用户点击按钮的行为来执行回调函数,是 Button 控件的主要功用。首先自定义一个函数或者方法,然后将函数与按钮关联起来,最后,当用户按下这个按钮时,Tkinter 就会自动调用相关函数。

温馨提示:按钮控件使用起来非常简单,它同样可以包含文本、图像、位图,并通过command参数回调函数。当然按钮也并非一定要执行回调函数(callback function),它也只可以当一个“摆设”,不过这样的按钮是没有“灵魂的”。

# 第九章节:Tkinter Button按钮标签:点击关闭按钮,实现窗口关闭
import tkinter as tk

window = tk.Tk()
# 设置窗口大小变量
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)


# 设置回调函数
def callback():
    window.destroy()
# 使用按钮控件调用函数
tk.Button(window, text="关闭按钮", command=callback).pack()


window.mainloop()

Button 控件的常营属性如下所示:

属性说明
anchor控制文本所在的位置,默认为中心位置(CENTER)
activebackground当鼠标放在按钮上时候,按妞的背景颜色
activeforeground当鼠标放在按钮上时候,按钮的前景色
bd按钮边框的大小,默认为 2 个像素
bg按钮的背景色
command用来执行按钮关联的回调函数。当按钮被点击时,执行该函数
fg按钮的前景色
font按钮文本的字体样样式
height按钮的高度
highlightcolor按钮控件高亮处要显示的颜色
image按钮上要显示的图片
justify按钮显示多行文本时,用来指定文本的对齐方式,参数值有 LEFT/RIGHT/CENTER
padx/padypadx 指定 x 轴(水平方向)的间距大小,pady 则表示 y轴(垂直方向)的间距大小
ipadx/ipadyipadx 指标签文字与标签容器之间的横向距离;ipady 则表示标签文字与标签容器之间的纵向距离
state设置按钮的可用状态,可选参数有NORMAL/ACTIVE/DISABLED,默认为 NORMAL
text按钮控件要显示的文本

拓展:按钮布局

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

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

tk button方位

# 第九章节:Tkinter Button按钮标签:基于grid网格布局,实现高仿计算器
import tkinter as tk
from tkinter import NSEW

root = tk.Tk()
root.geometry("200x240+200+300")
root.title("计算器界面设计")

frame = tk.Frame(root)
frame.pack()

ent = tk.Entry(frame)
ent.grid(row=0, column=0, columnspan=4, pady=10)  # columnspan跨列

btnText = (('MC', 'M+', 'M-', 'MR'),
           ('C', '±', '➗', '✖'),
           (7, 8, 9, '-'),
           (4, 5, 6, '+'),
           (1, 2, 3, '='),
           (0, '.'))

for rindex, r in enumerate(btnText):
    for cindex, c in enumerate(r):
        if c == '=':
            tk.Button(frame, text=c, width=2).grid(row=rindex + 1, column=cindex, sticky=NSEW, rowspan=2)
        elif c == 0:
            tk.Button(frame, text=c, width=2).grid(row=rindex + 1, column=cindex, sticky=NSEW, columnspan=2)
        elif c == '.':
            tk.Button(frame, text=c, width=2).grid(row=rindex + 1, column=cindex + 1, sticky=NSEW)
        else:
            tk.Button(frame, text=c, width=2).grid(row=rindex + 1, column=cindex, sticky=NSEW)


root.mainloop()

Tkinter Entry输入控件

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

基本语法格式如下:

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

基本属性

Entry 控件除了具备一些共有属性之外,还有一些自身的特殊属性,如下表所示:

属性名称说明
exportselection默认情况下,如果在输入框中选中文本会复制到粘贴板,如果要忽略这个功能,可以设置为 exportselection=0
selectbackground选中文字时的背景颜色
selectforeground选中文字时的前景色
show指定文本框内容以何种样式的字符显示,比如密码可以将值设为 show="*"
textvariable输入框内值,也称动态字符串,使用 StringVar() 对象来设置,而 text 为静态字符串对象
xscrollcommand设置输入框内容滚动条,当输入的内容大于输入框的宽度时使用户

动态数据类型 

现状:在界面编程的过程中,有时我们需要“动态跟踪”一些变量值的变化,从而保证值的变换及时的反映到显示界面上,但是 Python 内置的数据类型是无法这一目的的,因此使用了 Tkinter内置的对象,我们把这些方法创建的数据类型称为“动态类型”。支持类型:StringVar()、 BooleanVar()、DoubleVar()、IntVar()

下面通过时钟案例,加深对"动态数据类型" 理解。

# 第十一章节:Tkinter:时钟功能
import tkinter as tk
import time

root = tk.Tk()
root.title("时钟")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 获取时间的函数
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()

常用方法

除了一些基本的属性之外,Entry 控件还提供了一些常用的方法,如下所示:

方法说明
delete()根据索引值删除输入框内的值
get()获取输入框内的是
set()设置输入框内的值
insert()在指定的位置插入字符串
index()返回指定的索引值
select_clear()取消选中状态
select_adujst()确保输入框中选中的范围包含 index 参数所指定的字符,选中指定索引和光标所在位置之前的字符
select_from (index)设置一个新的选中范围,通过索引值 index 来设置
select_present()返回输入框是否有处于选中状态的文本,如果有则返回 true,否则返回 false。
select_to()选中指定索引与光标之间的所有值
select_range()选中指定索引与光标之间的所有值,参数值为 start,end,要求 start 必须小于 end。


温馨提示:在 Entry 控件中,我们可以通过以下方式来指定字符的所在位置:

  • 数字索引:表示从 0 开始的索引数字;
  • "ANCHOE":在存在字符的情况下,它对应第一个被选中的字符;
  • "END":对应已存在文本中的最后一个位置;
  • "insert(index,'字符'):将字符插入到 index 指定的索引位置。

# 第十二章节:Tkinter Entry:常用方法
import tkinter as tk

root = tk.Tk()
root.title("Tkinter Entry常用方法")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建输入框控件
entry = tk.Entry(root)
# 放置输入框,并设置位置
entry.pack(padx=20, pady=20)
# 文本清空
entry.delete(0, "end")
# 默认文本
entry.insert(0, 'Tkinter Entry常用方法详解')
# 获取输入框字符串
print(entry.get())
# 文本清空
# entry.delete(0, "end")

# 显示窗口
root.mainloop()

Entry控件验证功能

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

参数说明
validate指定验证方式,字符串参数,参数值有 focus、focusin、focusout、key、all、none。 
validatecommand指定用户自定义的验证函数,该函数只能返回 True 或者 Fasle
invalidcommand当 validatecommand 指定的验证函数返回 False 时,可以使用该参数值再指定一个验证函数。

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

参数值说明
focus当 Entry 组件获得或失去焦点的时候验证
focusin当 Entry 组件获得焦点的时候验证
focuson当 Entry 组件失去焦点的时候验证
key当输入框被编辑的时候验证
all当出现上边任何一种情况的时候验证
none 默认不启用验证功能,需要注意的是这里是字符串的 'none'

# 第十二章节:Tkinter Entry:数据校验
import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("Tkinter Entry常用方法")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 创建验证函数
def check():
    if entry.get() == "abc123":
        messagebox.showinfo("输入正确")
        return True
    else:
        messagebox.showwarning("输入不正确")
        entry.delete(0, tk.END)
        return False

# 创建动字符串
dy_String = tk.StringVar()
# 创建输入框控件
entry = tk.Entry(root, textvariable=dy_String, validate="focusout", validatecommand=check)
# 放置输入框,并设置位置
entry.pack(padx=20, pady=20)

# 显示窗口
root.mainloop()

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

选项说明
%d有 3 个参数值,其中 0 表示删除操作;1 表示插入操作;2 表示获得、失去焦点或 textvariable 变量的值被修改导
%i当用户进行插入或者删除操作的时,该选项不爱哦是插入或者删除的索引位置,若是其他的情况则选项值为 -1
%P该选项值指定了输入框内的文本内容,只有当输入框的值允许改变的时候,该选项值才会生效。
%s改值为调用验证函数钱输入框内的文本内容
%S该选项值,只有插入或者删除操作触发验证函数的时候才会生效,它表示了被删除或者插入的内容
%v表示当前 Entry 控件的 validate 参数的值
%V表示触发验证函数的原因,值为 focus、focusin 、focusout、all、key.. 中的一个。
%W该选项表示控件类型,即控件的名字(Entry)
# 第十四章节:Tkinter Entry:使用register() 实现数据校验
import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("Tkinter Entry常用方法")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 创建验证函数
def check(strings, reason, id):
    if entry.get() == "abc123":
        messagebox.showinfo("输入正确")
        print(strings, reason, id)
        return True
    else:
        messagebox.showwarning("输入不正确")
        entry.delete(0, tk.END)
        print(strings, reason, id)
        return False

# 对验证函数进行注册
checkTest = root.register(check)
# 创建动字符串
dy_String = tk.StringVar()
# 创建输入框控件
entry = tk.Entry(root, textvariable=dy_String, validate="focusout", validatecommand=(checkTest, '%P', '%V', '%W'))
# 放置输入框,并设置位置
entry.pack(padx=20, pady=20)

# 显示窗口
root.mainloop()

Spinbox 高级输入框

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

# 第十五章节:Tkinter Spinbox:
import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("Tkinter Spinbox")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 如果是数字使用 from_和to参数,范围 0-20,并且与2步长递增或递减
w = tk.Spinbox(root, from_=0, to=20, increment=2, width=15, bg='#9BCD9B')
w.pack()
# 显示窗口
root.mainloop()

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

# 使用 values 参数以元组的形式进行传参
strings = tk.Spinbox(root,values=('Python','java','C语言','PHP'))
strings.pack()

Tkinter Text文本框控件

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

Text 控件的有很多的适用场景,比如显示某个产品的详细信息,或者人物介绍等。下面我们对 Text 控件属性和常用方法做简单的介绍。

基本属性

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

属性说明
autoseparators默认为 True,表示执行撤销操作时是否自动插入一个“分隔符”(其作用是用于分隔操作记录)
exportselection默认值为 True,表示被选中的文本是否可以被复制到剪切板,若是 False 则表示不允许。
insertbackground设置插入光标的颜色,默认为 BLACK
insertborderwidth设置插入光标的边框宽度,默认值为 0
insertofftime该选项控制光标的闪烁频频率(灭的状态)
insertontime该选项控制光标的闪烁频频率(亮的状态)
selectbackground指定被选中文本的背景颜色,默认由系统决定
selectborderwidth指定被选中文本的背景颜色,默认值是0
selectforeground指定被选中文本的字体颜色,默认值由系统指定
setgrid默认值是 False,指定一个布尔类型的值,确定是否启用网格控制
spacing1指定 Text 控件文本块中每一行与上方的空白间隔,注意忽略自动换行,且默认值为 0。
spacing2指定 Text 控件文本块中自动换行的各行间的空白间隔,忽略换行符,默认值为0
spacing3指定 Text 组件文本中每一行与下方的空白间隔,忽略自动换行,默认值是 0
tabs定制 Tag 所描述的文本块中 Tab 按键的功能,默认被定义为 8 个字符宽度,比如 tabs=('1c', '2c', '8c') 表示前 3 个 Tab 宽度分别为 1厘米,2厘米,8厘米。
undo该参数默认为 False,表示关闭 Text 控件的“撤销”功能,若为 True 则表示开启
wrap该参数用来设置当一行文本的长度超过 width 选项设置的宽度时,是否自动换行,参数值 none(不自动换行)、char(按字符自动换行)、word(按单词自动换行)
xscrollcommand该参数与 Scrollbar 相关联,表示沿水平方向上下滑动
yscrollcommand该参数与 Scrollbar 相关联,表示沿垂直方向左右滑动

基本方法

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

方法说明
bbox(index)返回指定索引的字符的边界框,返回值是一个 4 元组,格式为(x,y,width,height)
edit_modified()该方法用于查询和设置 modified 标志(该标标志用于追踪 Text 组件的内容是否发生变化)
edit_redo()“恢复”上一次的“撤销”操作,如果设置 undo 选项为 False,则该方法无效。
edit_separator()插入一个“分隔符”到存放操作记录的栈中,用于表示已经完成一次完整的操作,如果设置 undo 选项为 False,则该方法无效。
get(index1, index2)返回特定位置的字符,或者一个范围内的文字。
image_cget(index, option)返回 index 参数指定的嵌入 image 对象的 option 选项的值,如果给定的位置没有嵌入 image 对象,则抛出 TclError 异常
image_create()在 index 参数指定的位置嵌入一个 image 对象,该 image 对象必须是 Tkinter 的 PhotoImage 或 BitmapImage 实例。
insert(index, text)在 index 参数指定的位置插入字符串,第一个参数也可以设置为 INSERT,表示在光标处插入,END 表示在末尾处插入。
delete(startindex [, endindex])删除特定位置的字符,或者一个范围内的文字。
see(index)如果指定索引位置的文字是可见的,则返回 True,否则返回 False。
# 第十七章节:Tkinter Text:
import tkinter as tk
from tkinter import messagebox, INSERT

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个文本控件
# width 一行可见的字符数;height 显示的行数
text = tk.Text(root, width=50, height=30, undo=True, autoseparators=False)
# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充,Y表示沿垂直方向填充,BOTH表示沿水平、垂直方向填充
text.pack()
# INSERT 光标处插入;END 末尾处插入
text.insert(INSERT, 'Tkinter Text 简单实例')

# 显示窗口
root.mainloop()

Text 控件通过 heigt 和 width 参数来控制文本域的大小(即纸张大小),当然您也可以将其设置为自适用模式,即不设置具体的文本域大小。

下面的示例:为上一个示例,增加“撤销”和“恢复”的功能。

# 第十七章节:Tkinter Text:
import tkinter as tk
from tkinter import messagebox, INSERT

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('400x300')

# 创建一个文本控件
# width 一行可见的字符数;height 显示的行数
text = tk.Text(root, width=50, height=3, undo=True, autoseparators=False)
# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充,Y表示沿垂直方向填充,BOTH表示沿水平、垂直方向填充
text.grid()
# INSERT 光标处插入;END 末尾处插入
text.insert(INSERT, 'Tkinter Text 简单实例')


# 定义撤销和恢复方法,调用edit_undo()和 edit_redo()方法
def backout():
    text.edit_undo()

def regain():
    text.edit_redo()


# 定义撤销和恢复按钮
tk.Button(root, text='撤销', command=backout).grid(row=3, column=0, sticky="w", padx=10, pady=5)
tk.Button(root, text='恢复', command=regain).grid(row=3, column=0, sticky="e", padx=10, pady=5)


# 显示窗口
root.mainloop()

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

Index文本索引

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

Tkinter 提供以下文本索引类型,如下表所示:

索引类型说明
INSERT对应插入光标的位置
CURRENT对应与鼠标坐标最接近的位置
END对应 Text 控件的文本域中最后一个字符的下一个位置
"line.column"表示某一行某一列的一个位置,比如 1.2 表示第一行第二列的一个位置
"line.end"表示某一行到末尾的最后一个位置
SEL一种针对于 Tag 的特殊索引用法,(SEL_FIRST,SEL_LAST) 表示当前被选中的范围
# 第十七章节:Tkinter Text:
import tkinter as tk
from tkinter import messagebox, INSERT

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个文本控件
# width 一行可见的字符数;height 显示的行数
text = tk.Text(root, width=50, height=30, undo=True, autoseparators=False)
# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充,Y表示沿垂直方向填充,BOTH表示沿水平、垂直方向填充
text.pack()
# INSERT 光标处插入;END 末尾处插入
text.insert(INSERT, 'Tkinter Text 简单实例')

# 显示窗口
root.mainloop()

Tag文本标签

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

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

Tag 提供了一些常用的方法,通过这些方法可以操作 Tag(标签),常用方法如下:

方法说明
tag_add(tagName,index1,index2)为指定索引范围内的内容添加一个标签名字,如果 index2 不存在,则单独为 Index1 指定的内容添加 Tag
tag_bind(tagName, sequence, func, add=None)为 Tag 绑定事件,解除绑定使用 tag_unbind() 方法
tag_cget(tagName,option)返回 tagName 指定的 option 选项的值
tag_configure(tagName, cnf=None, **kw)设置 tagName 的选项
tag_delete(tagNames)删除单个或者多个 tagNames 指定的标签
tag_lower(tagName, belowThis=None)降低 Tag 的优先级,如果 belowThis 参数不为空,则表示 tagName 需要比 belowThis 指定的 Tag 优先级更低
tag_names(index=None)如果不带参数,表示返回 Text 组件中所有 Tags 的名字,若存在 index 参数则返回该位置上所有 Tags 的名字
tag_nextrange(tagName, index1, index2=None) 在 index1 到 index2 的范围内第一个 tagName 的位置,若不存在则返回空字符串。
tag_raise(tagName, aboveThis=None)提高 Tag 的优先级,如果 aboveThis 参数不为空,则表示 tagName 需要比 aboveThis 指定的 Tag 优先级更高
tag_ranges(tagName)返回所有 tagName 指定的文本,并将它们的范围以列表的形式返回
tag_remove(tagName, index1, index2=None)删除 index1 到 index2 之间所有的 tagName,如果忽略 index2 参数,那么只删除 index1 指定字符的 tagName
# 第十七章节:Tkinter Text: Tag标签
import tkinter as tk
from tkinter import messagebox, INSERT, END

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个文本控件
# width 一行可见的字符数;height 显示的行数
text = tk.Text(root, width=50, height=30, undo=True, autoseparators=False)
# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充,Y表示沿垂直方向填充,BOTH表示沿水平、垂直方向填充
text.pack()
# INSERT 光标处插入;END 末尾处插入
text.insert(INSERT, 'Tkinter Text 简单实例')

# 在Text控件内插入- -个按钮
button = tk.Button(text, text="关闭", command=root.quit)
text. window_create(END, window=button)

# 在第一行文字的第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")


# 显示窗口
root.mainloop()

Mark文本标记

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

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

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


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

方法说明
mark_gravity(markName, direction=None)设置 Mark 的移动方向,默认是 "right",也可以设置为 "left" ,表示即如果在 Mark 处插入文本的话,Mark 的标记移动方向,也就是文本的插入方向。
mark_names()返回 Text 组件中所有 Marks 的名字
mark_next(index)返回在 index 指定的位置后边的一个 Mark 的名字
mark_previous(index)返回在 index 指定的位置前边的一个 Mark 的名字
mark_set(markName, index)移动 Mark 到 index 参数指定的位置,如果 markName 参数指定的 Mark 不存在,则创建一个新的 Mark
mark_unset(MarkName)删除指定的 Mark


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

# 第十七章节:Tkinter Text: Mark标签
import tkinter as tk
from tkinter import messagebox, INSERT, END

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个文本控件
# width 一行可见的字符数;height 显示的行数
text = tk.Text(root, width=50, height=30, undo=True, autoseparators=False)
# 适用 pack(fill=X) 可以设置文本域的填充模式。比如 X表示沿水平方向填充,Y表示沿垂直方向填充,BOTH表示沿水平、垂直方向填充
text.pack()
# INSERT 光标处插入;END 末尾处插入
text.insert(INSERT, 'Tkinter Text 简单实例')

# 在Text控件内插入- -个按钮
button = tk.Button(text, text="关闭", command=root.quit)
text. window_create(END, window=button)

# 在第一行文字的第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")

# 设置标记,这里的 1.end 表示 第一行最后一个字符,当然也可以使用数字来表示比如 1.5 表示第一行第五个字符
text.mark_set("name", "1.end")
# 在标记之后插入相应的文字
text.insert("name", ",Mark 标签")
# 跟着自动移动,往后插入,而不是停留在原位置
text.insert("name", ",欢迎光临")
# 若使用 mark_unset() 可以删除指定的标记
# text.mark_unset("name")
# 但使用delete来清楚所有的内容, mark 标记依旧会存在
# text.delete("1.0","end")
# 依然可以使用 name标记来插入
# text.insert("name", "Python3.0")


# 显示窗口
root.mainloop()

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

列表框(Listbox)和复选框(Combobox)是 Tkinter 中两个控件,由于其非常相似,本节将它们放在一起进行介绍。

Listbox控件

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

列表框控件(Listbox)常用方法介绍:

方法说明
activate(index)将给定索引号对应的选项激活,即文本下方画一条下划线
bbox(index)返回给定索引号对应的选项的边框,返回值是一个以像素为单位的 4 元祖表示边框:(xoffset, yoffset, width, height), xoffset 和 yoffset 表示距离左上角的偏移位置
curselection()返回一个元组,包含被选中的选项序号(从 0 开始)
delete(first, last=None) 删除参数 first 到 last 范围内(包含 first 和 last)的所有选项
get(first, last=None)返回一个元组,包含参数 first 到 last 范围内(包含 first 和 last)的所有选项的文本
index(index)返回与 index 参数相应选项的序号
itemcget(index, option)获得 index 参数指定的项目对应的选项(由 option 参数指定)
itemconfig(index, **options)设置 index 参数指定的项目对应的选项(由可变参数 **option 指定)
nearest(y)返回与给定参数 y 在垂直坐标上最接近的项目的序号
selection_set(first, last=None)设置参数 first 到 last 范围内(包含 first 和 last)选项为选中状态,使用 selection_includes(序号) 可以判断选项是否被选中。 
size()返回 Listbox 组件中选项的数量
xview(*args)该方法用于在水平方向上滚动 Listbox 组件的内容,一般通过绑定 Scollbar 组件的 command 选项来实现。 如果第一个参数是 "moveto",则第二个参数表示滚动到指定的位置:0.0 表示最左端,1.0 表示最右端;如果第一个参数是 "scroll",则第二个参数表示滚动的数量,第三个参数表示滚动的单位(可以是 "units" 或 "pages"),例如:xview("scroll", 2, "pages")表示向右滚动二行。
yview(*args)该方法用于在垂直方向上滚动 Listbox 组件的内容,一般通过绑定 Scollbar 组件的 command 选项来实现

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

属性说明
listvariable1. 指向一个 StringVar 类型的变量,该变量存放 Listbox 中所有的项目
2. 在 StringVar 类型的变量中,用空格分隔每个项目,例如 var.set("c c++ java python")
selectbackground1. 指定当某个项目被选中的时候背景颜色,默认值由系统指定
selectborderwidth1. 指定当某个项目被选中的时候边框的宽度
2. 默认是由 selectbackground 指定的颜色填充,没有边框
3. 如果设置了此选项,Listbox 的每一项会相应变大,被选中项为 "raised" 样式
selectforeground1. 指定当某个项目被选中的时候文本颜色,默认值由系统指定
selectmode1. 决定选择的模式,tk 提供了四种不同的选择模式,分别是:"single"(单选)、"browse"(也是单选,但拖动鼠标或通过方向键可以直接改变选项)、"multiple"(多选)和 "extended"(也是多选,但需要同时按住 Shift 键或 Ctrl 键或拖拽鼠标实现),默认是 "browse"
setgrid指定一个布尔类型的值,决定是否启用网格控制,默认值是 False
takefocus指定该组件是否接受输入焦点(用户可以通过 tab 键将焦点转移上来),默认值是 True
xscrollcommand为 Listbox 组件添加一条水平滚动条,将此选项与 Scrollbar 组件相关联即可
yscrollcommand为 Listbox 组件添加一条垂直滚动条,将此选项与 Scrollbar 组件相关联即可
# 第二十一章节:Tkinter ListBox
import tkinter as tk
from tkinter import messagebox, INSERT, END

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建列表选项
listbox1 = tk.Listbox(root)
listbox1.pack()
# i表示索引值,item 表示值,根据索引值的位置依次插入
for i, item in enumerate(["C", "C++", "JavaScript", "Python", "Java", "SQL"]):
    listbox1.insert(i, item)


# 显示窗口

 温馨提示:除了使用 enumerate() 来实现选项插入的方法外,我们还可以使用 “end” 实现,它表示将选项插入到最后一个位置。核心代码片段:

# i表示索引值,item 表示值,根据索引值的位置依次插入
for item in ["C","C++","C#","Python","Java"]:
    listbox1.insert("end",item)

为列表框控件(Listbox)增加滚动条和删除功能

# 第二十一章节:Tkinter ListBox 添加滚动条和删除功能
import tkinter as tk
from tkinter import messagebox, INSERT, END, RIGHT, Y, MULTIPLE, ACTIVE, BOTTOM

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建滚动条
s = tk.Scrollbar(root)
# 设置垂直滚动条显示的位置,使得滚动条,靠右侧;通过 fill 沿着 Y 轴填充
s.pack(side=RIGHT, fill=Y)

# 创建列表选项,将selectmode设置为多选模式,并为Listbox控件添加滚动条
listbox1 = tk.Listbox(root, selectmode=MULTIPLE, height=5, yscrollcommand=s.set)
listbox1.pack()
# i表示索引值,item 表示值,根据索引值的位置依次插入
for i, item in enumerate(["C", "C++", "JavaScript", "Python", "Java", "SQL"]):
    listbox1.insert(i, item)
# 设置滚动条,使用 yview使其在垂直方向上滚动 Listbox 组件的内容,通过绑定 Scollbar 组件的 command 参数实现
s.config(command=listbox1.yview)

# 使用匿名函数,创建删除函数,点击删除按钮,会删除选项
bt = tk.Button(root, text='删除', command=lambda x=listbox1:x.delete(ACTIVE))
# 将按钮放置在底部
bt.pack(side=BOTTOM)
# 显示窗口
root.mainloop()

StringVar() 动态获取列表选项

如何通过 StringVar() 方法动态地获取列表框中的选中项,示例代码如下:

# 第二十一章节:Tkinter ListBox 获取列表项选择值
import tkinter as tk
from tkinter import messagebox, INSERT, END, RIGHT, Y, MULTIPLE, ACTIVE, BOTTOM

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建变量,用var1用来接收鼠标点击的具体选项内容
var1 = tk.StringVar()
l = tk.Label(root, bg='#B0B0B0', font=('微软雅黑', 15), width=20, textvariable=var1)
l.pack()


# 创建一个按钮的点击事件
def click_button():
    # 使用 curselection来选中文本
    try:
        val = listbox1.get(listbox1.curselection())
        # 设置label值
        var1.set(val)
    except Exception as e:
        e = '发现一个错误'
        messagebox.showwarning(e, '没有选择任何条目')


# 创建一个按钮并放置,点击按钮调用print_selection函数
b1 = tk.Button(root, text='获取当前选项', command=click_button)
b1.pack()

# 创建Listbox并为其添加内容
var2 = tk.StringVar()
var2.set(("C语言辅导班", "Python答疑辅导", "Java答疑辅导", "C++辅导"))

s = tk.Scrollbar(root)
# 设置垂直滚动条显示的位置,使得滚动条,靠右侧;通过 fill 沿着 Y 轴填充
s.pack(side=RIGHT, fill=Y)

# 创建列表选项,将selectmode设置为多选模式,并为Listbox控件添加滚动条
listbox1 = tk.Listbox(root, selectmode=MULTIPLE, height=5, yscrollcommand=s.set, listvariable=var2)
listbox1.pack()
# i表示索引值,item 表示值,根据索引值的位置依次插入
for i, item in enumerate(["C", "C++", "JavaScript", "Python", "Java", "SQL"]):
    listbox1.insert(i, item)
# 设置滚动条,使用 yview使其在垂直方向上滚动 Listbox 组件的内容,通过绑定 Scollbar 组件的 command 参数实现
s.config(command=listbox1.yview)

# 使用匿名函数,创建删除函数,点击删除按钮,会删除选项
bt = tk.Button(root, text='删除', command=lambda x=listbox1:x.delete(ACTIVE))
# 将按钮放置在底部
bt.pack(side=BOTTOM)
# 显示窗口
root.mainloop()

Combobox控件

Combobox,是一个组合框控件,它是 Entry 控件和 Listbox 控件的组合,用户可以从下拉列表中选择一项,也可以手动输入。

其语法格式如下所示:

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

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

# 第二十一章节:Tkinter ComboxBox
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


def callback(event):
    print("选择项:", combo.get())


# 创建一个 Combobox
combo = ttk.Combobox(root)
# 设置 Combobox 的选项
combo['values'] = ("选项 A", "选项 B", "选项 C")

# 设置默认选择的项
combo.current(0)

# 为选项选择设置一个回调函数
combo.bind("<<ComboboxSelected>>", callback)

combo.pack()

# 显示窗口
root.mainloop()

Tkinter单选框和多选框按钮

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

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

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

属性说明
activebackground设置当 Radiobutton 处于活动状态(通过 state 选项设置状态)的背景色,默认值由系统指定
activeforeground设置当 Radiobutton 处于活动状态(通过 state 选项设置状态)的前景色,默认值由系统指定
compound1. 默认值为 None,控制 Radiobutton 中文本和图像的混合模式,默认情况下,如果有指定位图或图片,则不显示文本
2. 如果该选项设置为 "center",文本显示在图像上(文本重叠图像)
3. 设置为 "bottom","left","right" 或 "top",那么图像显示在文本的旁边,比如如"bottom",则显示图像在文本的下方。
disabledforeground指定当 Radiobutton 不可用的时的前景色颜色,默认由系统指定
indicatoron1. 该参数表示选项前面的小圆圈是否被绘制,默认为 True,即绘制;
2. 如果设置为 False,则会改变单选按钮的样式,当点击时按钮会变成 "sunken"(凹陷),再次点击变为 "raised"(凸起)
selectcolor设置当 Radiobutton 为选中状态的时候显示的图片;如果没有指定 image 选项,该选项被忽略
takefocus如果是 True,该组件接受输入焦点,默认为 False
variable表示与 Radiobutton 控件关联的变量,注意同一组中的所有按钮的 variable 选项应该都指向同一个变量,通过将该变量与 value 选项值对比,可以判断用户选中了哪个按钮


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

方法说明
deselect()取消该按钮的选中状态
flash()刷新 Radiobutton 控件,该方法将重绘 Radiobutton控件若干次(即在"active" 和 "normal" 状态间切换)
invoke()1. 调用 Radiobutton 中 command 参数指定的函数,并返回函数的返回值
2. 如果 Radiobutton 控件的 state(状态) 是 "disabled" (不可用)或没有指定 command 选项,则该方法无效
select()将 Radiobutton 控件设置为选中状态
# 第二十五章节:Tkinter Radiobutton
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)
# IntVar() 用于处理整数类型的变量
v = tk.IntVar()
# 根据单选按钮的 value 值来选择相应的选项
v.set(0)
# 使用 variable 参数来关联 IntVar() 的变量 v
tk.Radiobutton(root, text="苹果", fg='blue', font=('微软雅黑', '12', 'bold'), variable=v, value=0).pack(anchor='w')
tk.Radiobutton(root, text="香蕉", variable=v, value=2).pack(anchor='w')
tk.Radiobutton(root, text="梨", variable=v, value=3).pack(anchor='w')
tk.Radiobutton(root, text="西瓜", variable=v, value=4).pack(anchor='w')


# 显示窗口
root.mainloop()

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

# 第二十五章节:Tkinter Radiobutton 优化
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

site = [('Java 从入门到精通', 1),
        ('SQL 从入门到放弃', 2),
        ('JavaScrit 高手荆棘之路', 3),
        ('Python 项目实战', 4)]
# IntVar() 用于处理整数类型的变量
v = tk.IntVar()
# 重构后的写法,也非常简单易懂
for name, num in site:
    radio_button = tk.Radiobutton(root, text=name, variable=v, value=num)
    radio_button.pack(anchor='w')

# 显示窗口
root.mainloop()

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

# 第二十五章节:Tkinter Radiobutton 优化 + 点击事件
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk


def select():
    dicts = {1: 'Java 从入门到精通', 2: 'SQL 从入门到放弃', 3: 'JavaScrit 高手荆棘之路', 4: 'Python 项目实战'}
    strings = '您选择了' + dicts.get(v.get()) + ',祝您学习愉快'
    lable.config(text=strings)


root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

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


site = [('Java 从入门到精通', 1),
        ('SQL 从入门到放弃', 2),
        ('JavaScrit 高手荆棘之路', 3),
        ('Python 项目实战', 4)]
# IntVar() 用于处理整数类型的变量
v = tk.IntVar()
# 重构后的写法,也非常简单易懂
for name, num in site:
    radio_button = tk.Radiobutton(root, text=name, variable=v, value=num, command=select, indicatoron=False)
    radio_button.pack(anchor='w')

# 显示窗口
root.mainloop()

Checkbutton复选框控件

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

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

Checkbutton(master=None, **options)

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

属性说明
text显示的文本,使用 "\n" 来对文本进行换行。
variable1. 和复选框按钮关联的变量,该变量值会随着用户选择行为来改变(选或不选),即在 onvalue 和 offvalue 设置值之间切换,这些操作由系统自动完成
2. 在默认情况下,variable 选项设置为 1 表示选中状态,反之则为 0,表示不选中。
onvalue通过设置 onvalue 的值来自定义选中状态的值。
offvalue通过设置 offvalue 的值来自定义未选中状态的值。
indicatoron默认为 True,表示是否绘制用来选择的选项的小方块,当设置为 False 时,会改变原有按钮的样式,与单选按钮相同
selectcolor选择框的颜色(即小方块的颜色),默认由系统指定
selectimage设置当 Checkbutton 为选中状态的时候显示的图片,若如果没有指定 image 选项,该选项被忽略
textvariableCheckbutton 显示 Tkinter 变量(通常是一个 StringVar 变量)的内容,如果变量被修改,Checkbutton 的文本会自动更新
wraplength表示复选框文本应该被分成多少行,该选项指定每行的长度,单位是屏幕单元,默认值为 0
# 第二十五章节:Tkinter Checkbutton
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 新建整型变量
CheckVar1 = tk.IntVar()
CheckVar2 = tk.IntVar()
CheckVar3 = tk.IntVar()
# 设置三个复选框控件,使用variable参数来接收变量
check1 = tk.Checkbutton(root, text="Python", font=('微软雅黑', 15, 'bold'), variable=CheckVar1, onvalue=1, offvalue=0)
check2 = tk.Checkbutton(root, text="C语言", font=('微软雅黑', 15, 'bold'), variable=CheckVar2, onvalue=1, offvalue=0)
check3 = tk.Checkbutton(root, 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 = tk.Button(root, text="选好了", bg='#BEBEBE', command=study)
btn.pack(side=LEFT)
# 该标签,用来显示选择的文本
lb2 = tk.Label(root, text='', bg='#9BCD9B', font=('微软雅黑', 11, 'bold'), width=5, height=2)
lb2.pack(side=BOTTOM, fill=X)

# 显示窗口
root.mainloop()

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

方法属性
desellect()取消 Checkbutton 组件的选中状态,也就是设置 variable 为 offvalue
flash()刷新 Checkbutton 组件,对其进行重绘操作,即将前景色与背景色互换从而产生闪烁的效果。
invoke()1. 调用 Checkbutton 中 command 选项指定的函数或方法,并返回函数的返回值
2. 如果 Checkbutton 的state(状态)"disabled"是 (不可用)或没有指定 command 选项,则该方法无效
select()将 Checkbutton 组件设置为选中状态,也就是设置 variable 为 onvalue
toggle()改变复选框的状态,如果复选框现在状态是 on,就改成 off,反之亦然

核心代码片段:

# 设置三个复选框控件,使用variable参数来接收变量
check1 = tk.Checkbutton(root, text="Python", font=('微软雅黑', 15, 'bold'), variable=CheckVar1, onvalue=1, offvalue=0)
check2 = tk.Checkbutton(root, text="C语言", font=('微软雅黑', 15, 'bold'), variable=CheckVar2, onvalue=1, offvalue=0)
check3 = tk.Checkbutton(root, 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)

Tkinter Scale控件详解

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

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

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

参数说明
activebackground指定当鼠标在上方飘过的时候滑块的背景颜色
bigincrement1. 设置“大”增长量
2. 该选项设置增长量的大小
3. 默认值是 0,增长量为范围的 1/10
borderwidth1. 指定边框宽度
2. 默认值是 2
command1. 指定一个函数,每当滑块发生改变的时候都会自动调用该函数
2. 该函数有一个唯一的参数,就是最新的滑块位置
3. 如果滑块快速地移动,函数可能无法获得每一个位置,但一定会获得滑块停下时的最终位置
digits1. 设置最多显示多少位数字
2. 补充注释:例如设置 from 选项为 0,to 选项为 20,digits 选项设置为 5,那么滑块的范围就是在 0.000 ~ 20.000 直接滑动
3. 默认值是 0(不开启)
font1. 指定滑块左侧的 Label 和刻度的文字字体
2. 默认值由系统指定
from_1. 设置滑块最顶(左)端的位置
2. 默认值是 0
highlightcolor1. 指定当 Scale 获得焦点的时候高亮边框的颜色
2. 默认值由系统指定
label1. 你可以在垂直的 Scale 组件的顶端右侧(水平的话是左端上方)显示一个文本标签
2. 默认值是不显示标签
length1. Scale 组件的长度,默认值是 100 像素
orient1. 设置 Scale 控件是水平放置(HORIZONTAL)还是垂直放置(VERTICAL)
2. 默认值是 VERTICAL(垂直放置)
repeatdelay1. 该选项指定鼠标左键点击滚动条凹槽的响应时间
2. 默认值是 300(毫秒)
repeatinterval1. 该选项指定鼠标左键紧按滚动条凹槽时的响应间隔
2. 默认值是 100(毫秒)
resolution1. 指定 Scale 组件的分辨率(每点击一下移动的步长)
示例: 比如 resolution 选项设置为 0.1 的话,那么每点击一下鼠标就是在 0.0 ~ 20.0 之间以 0.1 的步长移动
2. 该参数的默认值是 1
showvalue1. 设置是否显示滑块旁边的数字
2. 默认值为 True
sliderlength1. 设置滑块的长度
2. 默认值是 30 像素
state1. 默认情况下 Scale 组件支持鼠标事件和键盘事件,可以通过设置该选项为 DISABLED 来禁用此功能
2. 默认值是 NORMAL
takefocus1. 指定使用 Tab 键是否可以将焦点移动到该 Scale 组件上
2. 默认是开启的,可以通过将该选项设置为 False 避免焦点落在此组件上
tickinterval1. 设置显示的刻度,如果设置一个值,那么就会按照该值的倍数显示刻度
2. 默认值是不显示刻度
to1. 设置滑块最底(右)端的位置
2. 默认值是 100
troughcolor1. 设置凹槽的颜色
2. 默认值由系统指定
variable1. 指定一个与 Scale 组件相关联的 Tkinter 变量,该变量存放滑块最新的位置
2. 当滑块移动的时候,该变量的值也会发生相应的变化
width1. 指定 Scale 组件的宽度
2. 默认值是 15 像素


Scale 常用方法有如下四个,见下表所示:

方法说明
coords(value=None)1. 获得当前滑块位置相对于 Scale 控件左上角位置的相对坐标,
2. 如果设置了 value 值,则返回当滑块位于该位置时与左上角的相对坐标
get()获得当前滑块的位置(即当前数值),返回值可以为整型或者浮点型
identify(x, y)返回一个字符串表示指定位置下的 Scale 控件
set(value)设置 Scale 控件的值,即滑块的位置,默认为初始位置
# 第二十五章节:Tkinter Scale
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 添加一个 Scale 控件,默认垂直方向,步长设置为 5,长度为200,滑动块的大小为 50,最后使用label参数文本
s = tk.Scale(root, from_=100, to=0, resolution=5, length=200, sliderlength=20, label='音量控制')
s.pack()
# 设置滑块的位置
s.set(value=15)


# 显示窗口
root.mainloop()

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

# 第二十五章节:Tkinter Scale
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个文本标签
label = tk.Label(root, bg='#9FB6CD', width=18, text='')
label.grid(row=2)


# 创建执行函数
def select_price(value):
    label.config(text='您购买的数量是 ' + value)


# 创建 Scale控件
scale = tk.Scale(root,
                 label='选择您要购买的数量',
                 from_=1,
                 to=100,
                 orient=tk.HORIZONTAL,  # 设置Scale控件平方向显示
                 length=400,
                 tickinterval=9,  # 设置刻度滑动条的间隔
                 command=select_price)  # 调用执行函数,是数值显示在 Label控件中
scale.grid(row=1)


# 显示窗口
root.mainloop()

Tkinter Menu菜单控件

Menu 控件(菜单控件)可以说是 GUI 中“精髓所在”,它以可视化的方式将一系列的“功能选项卡”进行分组,并在每个分组下又“隐藏”了许多其他的“选项卡”。当打开菜单时,这些选项卡就会“显式”的呈现出来,方便用户进行选择。

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

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

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

方法说明
add_cascade(**options)添加一个父菜单,将一个指定的子菜单,通过 menu 参数与父菜单连接,从而创建一个下拉菜单。
add_checkbutton(**options)添加一个多选按钮的菜单项
add_command(**options) 添加一个普通的命令菜单项
add_radiobutton(**options)添加一个单选按钮的菜单项
add_separator(**options) 添加一条分割线
add(add(itemType, options))添加菜单项,此处 itemType 参数可以是以下几种:"command"、"cascade",
"checkbutton"、"radiobutton"、"separator" 五种,并使用 options 选项来设置
菜单其他属性。


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

方法说明
delete(index1, index2=None)1. 删除 index1 ~ index2(包含)的所有菜单项
2. 如果忽略 index2 参数,则删除 index1 指向的菜单项
entrycget(index, option)获得指定菜单项的某选项的值
entryconfig(index, **options)设置指定菜单项的选项
index(index)返回与 index 参数相应的选项的序号
insert(index, itemType, **options)插入指定类型的菜单项到 index 参数指定的位置,类型可以是
是:"command","cascade","checkbutton","radiobutton"
或 "separator" 中的一个,或者也可以使用 insert_类型() 形式来,
比如 insert_cascade(index, **options)..等
invoke(index)调用 index 指定的菜单项相关联的方法
post(x, y)在指定的位置显示弹出菜单
type(index)获得 index 参数指定菜单项的类型
unpost()移除弹出菜单
yposition(index)返回 index 参数指定的菜单项的垂直偏移位置


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

属性说明
accelerator1. 设置菜单项的快捷键,快捷键会显示在菜单项目的右边,比如 accelerator = "Ctrl+O" 表示打开;
2. 注意,此选项并不会自动将快捷键与菜单项连接在一起,必须通过按键绑定来实现
command选择菜单项时执行的 callback 函数
label定义菜单项内的文字
menu此属性与 add_cascade() 方法一起使用,用来新增菜单项的子菜单项
selectcolor指定当菜单项显示为单选按钮或多选按钮时选择中标志的颜色
state定义菜单项的状态,可以是 normal、active 或 disabled
onvalue/offvalue1. 默认情况下,variable 选项设置为 1 表示选中状态,反之设置为 0,设置 offvalue/onvalue 的值可以自定义未选中状态的值
2. 
tearoff1. 如果此选项为 True,在菜单项的上面就会显示一个可选择的分隔线;
2. 注意:分隔线会将此菜单项分离出来成为一个新的窗口
underline设置菜单项中哪一个字符要有下画线
value1. 设置按钮菜单项的值
2. 在同一组中的所有按钮应该拥有各不相同的值
3. 通过将该值与 variable 选项的值对比,即可判断用户选中了哪个按钮
variable当菜单项是单选按钮或多选按钮时,与之关联的变量

1)创建主目录菜单

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

# 第三十一章节:Tkinter Menu
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 绑定一个执行函数,当点击菜单项的时候会显示一个消息对话框
def menuCommand():
    tk.messagebox.showinfo("主菜单栏", "你正在使用主菜单栏")


# 创建一个主目录菜单,也被称为顶级菜单
main_menu = tk.Menu(root)
# 新增命令菜单项,使用 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)
# 显示菜单
root.config(menu=main_menu)

# 显示窗口
root.mainloop()

2) 创建下拉菜单

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

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

# 第三十一章节:Tkinter Menu
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 绑定一个执行函数,当点击菜单项的时候会显示一个消息对话框
def menuCommand():
    tk.messagebox.showinfo("主菜单栏", "你正在使用主菜单栏")


# 创建一个主目录菜单,也被称为顶级菜单
main_menu = tk.Menu(root)



# 在顶级菜单上新增"文件"菜单的子菜单,同时不添加分割线
filemenu = tk.Menu(root, 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=root.quit)
# 在主目录菜单上新增"文件"选项,并通过menu参数与下拉菜单绑定
main_menu.add_cascade(label="文件", menu=filemenu)
# 新增命令菜单项,使用 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)


# 显示菜单
root.config(menu=main_menu)

# 显示窗口
root.mainloop()

3) 创建弹出菜单栏

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

# 第三十一章节:Tkinter Menu
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


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 界面的灵活性。

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

# 第三十一章节:Tkinter Menu
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个菜单按钮
menubtn = tk.Menubutton(root, text='点击进行操作', relief='sunk')
# 设置位置(布局)
menubtn.grid(padx=195, pady=105)
# 添加菜单,使用 tearoff 参数不显示分割线
filemenu = tk.Menu(menubtn, tearoff=False)
filemenu.add_command(label='新建')
filemenu.add_command(label='删除')
filemenu.add_command(label='复制')
filemenu.add_command(label='保存')
# 显示菜单,将菜单命令绑定在菜单按钮对象上
menubtn.config(menu=filemenu)


# 显示窗口
root.mainloop()

Tkinter Scrollbar滚动条控件

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

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

Scrollbar 控件的常用属性,如下表所示:

属性说明
activebackground指定当鼠标在上方飘过的时候滑块和箭头的背景颜色,默认由系统决定
activerelief指定当鼠标在滑块上方飘过时滑块的样式,默认值是 "raised",其他可选值有 "flat","sunken","groove","ridge"
background(bg)指定背景颜色,默认值由系统指定
borderwidth(bd)指定边框宽度,默认值是 0
command当滚动条更新时回调的函数,通常指定对应组件的 xview() 或 yview() 方法
cursor指定当鼠标在上方飘过的时的鼠标样式,默认值由系统指定
elementborderwidth1. 指定滚动条和箭头的边框宽度
2. 默认值是 -1(表示使用 borderwidth 选项的值)
jump1. 指定当用户拖拽滚动条时的行为
2. 默认值为 False,滚动条的任何一丝变动都会即刻调用 command 指定的回调函数
3. 设置为 True 则当用户松开鼠标才调用
orient指定绘制 "horizontal"(垂直滚动条)还是 "vertical"(水平滚动条),默认值是 VERTICAL
repeatdelay该选项指定鼠标左键点击滚动条凹槽的响应时间,默认值是 300(毫秒)
repeatinterval该选项指定鼠标左键紧按滚动条凹槽时的响应间隔,默认值是 100(毫秒)
takefocus指定使用 Tab 键可以将焦点移到该 Scrollbar 组件上,默认为开启,可以将该选项设置为 False 避免焦点在此组件上
troughcolor指定凹槽的颜色,默认由系统指定
width指定滚动条的宽度,默认值是 16px


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

属性说明
activate(element) 1. 显示 element 参数指定的元素的背景颜色和样式;
2. element 参数可以设置为:"arrow1"(箭头1),"arrow2"(箭头2)或 "slider"(滑块)
delta(deltax, deltay)1. 给定一个鼠标移动的范围 deltax 和 deltay,然后该方法返回一个浮点类型的值(范围 -1.0 ~ 1.0)
2. 注意:deltax 表示水平移动量,deltay 表示垂直移动量
fraction(x, y)给定一个像素坐标 (x, y),该方法返回最接近给定坐标的滚动条位置。
get() 返回当前滑块的位置 (a, b),其中 a 值表示当前滑块的顶端或左端的位置,b 值表示当前滑块的底端或右端的位置。
identify(x, y)1. 返回一个字符串表示指定位置下(如果有的话)的滚动条部件,
2. 返回值可以是:"arrow1"(箭头1),"arrow2"(箭头2)、"slider"(滑块)或 ""(空)
set(*args)1. 设置当前滚动条的位置
2. 该方法有两个参数即 (first, last),其中 first 表示当前滑块的顶端或左端的位置,last 表示当前滑块的底端或右端的位置(范围 0.0 ~ 1.0)

滚动条示例:

# 第三十五章节:Tkinter Scrollbar
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)

# 创建一个滚动条控件,默认为垂直方向
sbar1=tk.Scrollbar(root)
# 将滚动条放置在右侧,并设置当窗口大小改变时滚动条会沿着垂直方向延展
sbar1.pack(side=RIGHT, fill=Y)
# 创建水平滚动条,默认为水平方向,当拖动窗口时会沿着X轴方向填充
sbar2 = tk.Scrollbar(root, orient=HORIZONTAL)
sbar2.pack(side=BOTTOM, fill=X)
# 创建列表框控件,并添加两个滚动条(分别在垂直和水平方向),使用 set() 进行设置
mylist = tk.Listbox(root, xscrollcommand=sbar2.set, yscrollcommand=sbar1.set)
for i in range(30):
    mylist.insert(END, '第' + str(i+1)+'次:\n')
# 当窗口改变大小时会在X与Y方向填满窗口
mylist.pack(side=LEFT, fill=BOTH)
# 使用 command 关联控件的 yview、xview方法
sbar1.config(command=mylist.yview)
sbar2.config(command=mylist.xview)


# 显示窗口
root.mainloop()

 通过滑动滚动条可以浏览列表框中的内容,垂直方向的滚动条沿着上下浏览,水平方向的滚动条则沿着左右方向浏览。

Tkinter Event事件处理

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

在一款 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 修饰符做简单的介绍,修饰符限制事件的激活条件,比如双击鼠标或者需要同时按下某个键才触发事件,常用的修饰符如下: 

修饰符说明
Control事件发生时需按下 Control 键
Alt事件发生时需按下 Alt 键
Shift事件发生时需按下 Shift 键
Lock事件发生时需处于大写锁定状态
Double事件连续发生两次,比如双击鼠标
Triple事件连续发生三次
Quadruple事件连续发生四次

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

事件码说明
<ButtonPress-1>单击鼠标左键,简写为<Button-1>,后面的数字可以是1/2/3,分别代表左键、中间滑轮、右键
<ButtonRelease-1>释放鼠标左键,后面数字可以是1/2/3,分别代表释放左键、滑轮、右键
<B1-Motion>按住鼠标左键移动,<B2-Motion>和<B3-Motion>分别表示按住鼠标滑轮移动、右键移动
<MouseWheel>转动鼠标滑轮
<Double-Button-1>双击鼠标左键
<Enter>鼠标光标进入控件实例
<Leave>鼠标光标离开控件实例
<Key>按下键盘上的任意键
<KeyPress-字母>/<KeyPress-数字>按下键盘上的某一个字母或者数字键
<KeyRelease>释放键盘上的按键
<Return>回车键,其他同类型键有<Shift>/<Tab>/<Control>/<Alt>
<Space>空格键
<UP>/<Down>/<Left>/<Right>方向键
<F1>...<F12>常用的功能键
<Control-Alt>组合键,再比如<Control-Shift-KeyPress-T>,表示用户同时点击 Ctrl + Shift + T
<FocusIn>当控件获取焦点时候触发,比如鼠标点击输入控件输入内容,可以调用 focus_set() 方法使控件获得焦点
<FocusOut>当控件失去焦点时激活,比如当鼠标离开输入框的时候
<Configure >控件的发生改变的时候触发事件,比如调整了控件的大小等
<Deactivate>当控件的状态从“激活”变为“未激活”时触发事件
<Destroy>当控件被销毁的时候触发执行事件的函数
<Expose>当窗口或组件的某部分不再被覆盖的时候触发事件
<Visibility>当应用程序至少有一部分在屏幕中是可见状态时触发事件

Event事件对象

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

属性说明
widget发生事件的是哪一个控件
x,y相对于窗口的左上角而言,当前鼠标的坐标位置
x_root,y_root相对于屏幕的左上角而言,当前鼠标的坐标位置
char用来显示所按键相对应的字符
keysym按键名,比如 Control_L 表示左边的 Ctrl 按键
keycode按键码,一个按键的数字编号,比如 Delete 按键码是107
num1/2/3中的一个,表示点击了鼠标的哪个按键,按键分为左、中、右
width,height控件的修改后的尺寸,对应着 <Configure>事件
type事件类型
# 第三十五章节:Tkinter 事件绑定
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


# 定义事件函数,必须用event参数
def show_key(event):
    # 查看触发事件的按钮
    s=event.keysym
    # 将其显示在按钮控件上
    lb.config(text=s)


# 添加一个按钮控件
lb = tk.Label(root, text='请按键', fg='blue', font=('微软雅黑', 15))
# 给按钮控件绑定事件,按下任意键,然后调用事件处理函数。注意,此处需要在英文状态下进行输入
lb.bind('<Key>', show_key)
# 设置按钮获取焦点
lb.focus_set()
lb.pack()


# 显示窗口
root.mainloop()

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

鼠标事件示例:

# 第三十五章节:Tkinter 事件绑定:鼠标事件
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


def handleMotion(event):
    lb1['text'] = '你移动了光标的所在位置'
    lb2['text'] = '目前光标位置:x =' + str(event.x) + ';y=' + str(event.y)
    print('光标当前位置', event.x, event.y)


# 创建一个窗体容器frame
frame = tk.Frame(root, relief=RAISED, borderwidth=2, width=300, height=200)
frame.bind('<Motion>', handleMotion)
lb1 = tk.Label(frame, text='没有任何事件触发', bg='purple', )
# 使用place进行位置布局,下一节会介绍
lb1.place(x=20, y=20)
lb2 = tk.Label(frame, text='')
lb2.place(x=16, y=60)
frame.pack(side=TOP)

# 显示窗口
root.mainloop()

Tkinter布局管理器

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

Tkinter 提供了一系列布局管理的方法和容器控件,通过对这些内容的学习,您将掌握如何使用不同的方法完成界面布局。

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

方法说明
pack()按照控件的添加顺序其进行排列,遗憾的是此方法灵活性较差
grid()以行和列(网格)形式对控件进行排列,此种方法使用起来较为灵活
place()可以指定组件大小以及摆放位置,三个方法中最为灵活的布局方法

pack()

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

属性说明
anchor组件在窗口中的对齐方式,有 9 个方位参数值,比如"n"/"w"/"s"/"e"/"ne",以及 "center" 等(这里的 e w s n分别代表,东西南北)
expand是否可扩展窗口,参数值为 True(扩展)或者 False(不扩展),默认为 False,若设置为 True,则控件的位置始终位于窗口的中央位置
fill参数值为 X/Y/BOTH/NONE,表示允许控件在水平/垂直/同时在两个方向上进行拉伸,比如当 fill = X 时,控件会占满水平方向上的所有剩余的空间。
ipadx,ipady需要与 fill 参数值共同使用,表示组件与内容和组件边框的距离(内边距),比如文本内容和组件边框的距离,单位为像素(p),或者厘米(c)、英寸(i)
padx,pady用于控制组件之间的上下、左右的距离(外边距),单位为像素(p),或者厘米(c)、英寸(i)
side组件放置在窗口的哪个位置上,参数值 'top','bottom','left','right'。注意,单词小写时需要使用字符串格式,若为大写单词则不必使用字符串格式

 pack 方法示例:

# 第三十六章节:Tkinter 布局:pack
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x150+100+100')
root.resizable(0, 0)


def handleMotion(event):
    lb1['text'] = '你移动了光标的所在位置'
    lb2['text'] = '目前光标位置:x =' + str(event.x) + ';y=' + str(event.y)
    print('光标当前位置', event.x, event.y)


# 创建一个窗体容器frame
frame = tk.Frame(root, relief=RAISED, borderwidth=2, width=300, height=200)
frame.bind('<Motion>', handleMotion)
lb1 = tk.Label(frame, text='没有任何事件触发', bg='purple', )
# 使用place进行位置布局,下一节会介绍
lb1.place(x=20, y=20)
lb2 = tk.Label(frame, text='')
lb2.place(x=16, y=60)
frame.pack(side=TOP)

# 显示窗口
root.mainloop()

grid()

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

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

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

属性说明
column控件位于表格中的第几列,窗体最左边的为起始列,默认为第 0 列
columnsapn控件实例所跨的列数,默认为 1 列,通过该参数可以合并一行中多个领近单元格。
ipadx,ipady用于控制内边距,在单元格内部,左右、上下方向上填充指定大小的空间。
padx,pady用于控制外边距,在单元格外部,左右、上下方向上填充指定大小的空间。
row控件位于表格中的第几行,窗体最上面为起始行,默认为第 0 行
rowspan控件实例所跨的行数,默认为 1 行,通过该参数可以合并一列中多个领近单元格。
sticky该属性用来设置控件位于单元格那个方位上,参数值和 anchor 相同,若不设置该参数则控件在单元格内居中


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

温馨提示,在一个容器中不能同时使用 pack() 和 grid() 方法,这两个方法只能二选一,否则程序会运行错误。

grid 方法简单示例:

# 第三十六章节:Tkinter 布局:grid
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x350+100+100')
root.resizable(0, 0)

# 在窗口内创建按钮,以表格的形式依次排列
for i in range(10):
    for j in range(10):
        tk.Button(root, text=" (" + str(i) + "," + str(j) + ")", bg='#D1EEEE').grid(row=i, column=j)


# 显示窗口
root.mainloop()

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

place()

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

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

属性说明
anchor定义控件在窗体内的方位,参数值N/NE/E/SE/S/SW/W/NW 或 CENTER,默认值是 NW
bordermode定义控件的坐标是否要考虑边界的宽度,参数值为 OUTSIDE(排除边界) 或 INSIDE(包含边界),默认值 INSIDE。
x、y定义控件在根窗体中水平和垂直方向上的起始绝对位置
relx、rely1. 定义控件相对于根窗口(或其他控件)在水平和垂直方向上的相对位置(即位移比例),取值范围再 0.0~1.0 之间
2. 可设置 in_ 参数项,相对于某个其他控件的位置
height、width控件自身的高度和宽度(单位为像素)
relheight、relwidth控件高度和宽度相对于根窗体高度和宽度的比例,取值也在 0.0~1.0 之间

通过上述描述我们知道,relxrely参数指定的是控件相对于父组件的位置,而relwidthrelheight参数则是指定控件相对于父组件的尺寸大小。

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

 place 方法示例:

# 第三十六章节:Tkinter 布局:place
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP, SUNKEN, NE

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x350')
root.resizable(0, 0)

# 创建一个frame窗体对象,用来包裹标签
frame = tk.Frame(root, relief=SUNKEN, borderwidth=2, width=450, height=250)
# 在水平、垂直方向上填充窗体
frame.pack(side=TOP, fill=BOTH, expand=1)
# 创建 "位置1"
Label1 = tk.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 = tk.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 = tk.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 = tk.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)


# 显示窗口
root.mainloop()

Tkinter布局管理控件

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

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

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

Frame控件

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

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

属性说明
bg设置 Frame 的背景颜色
bd指定 Frame 的边框宽度
colormap指定  Frame 组件及其子组件的颜色映射
container布尔值参数,若参数值为 True,则窗体将被用作容器使用,一些其他程序也可以被嵌入。
cursor指定鼠标在 Frame 上飘过的鼠标样式,默认由系统指定
height/width设置 Frame 的高度和宽度
highlightbackground指定当 Frame 没有获得焦点的时候高亮边框的颜色,通常由系统指定为标准颜色
highlightcolor指定当 Frame 获得焦点的时候高亮边框的颜色
highlightthickness指定高亮边框的宽度,默认值是 0
padx/pady距离主窗口在水平/垂直方向上的外边距
relief指定边框的样式,参数值 "sunken","raised","groove" 或 "ridge","flat",默认为 "falt'
takefocus布尔值参数,默认为 False,指定该组件是否接受输入焦点(即用户通过 Tab 键将焦点转移上来)

 Frame控件 示例:

# 第三十六章节:Tkinter 布局控件:Frame
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP, SUNKEN, NE

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x350')
root.resizable(0, 0)

# 在主窗口上添加一个frame控件
frame1 = tk.Frame(root)
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)
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)


# 显示窗口
root.mainloop()

LabelFrame控件

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

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

LabelFrame 控件示例:

# 第三十六章节:Tkinter 布局控件:LabelFrame
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP, SUNKEN, NE

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x450')
root.resizable(0, 0)

# 定义第一个容器,使用 labelanchor ='w' 来设置标题的方位
frame_left = tk.LabelFrame(root, text="教程", labelanchor="w", bg='#5CACEE')
# 使用 place 控制 LabelFrame 的位置
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(root, 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)


# 显示窗口
root.mainloop()

PanedWindow控件

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

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

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

PanedWindow(master=None, **options) 

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

属性说明
handlepad1. 调节“手柄”的位置
2. 比如当 orient ='vertical' 设置垂直时,handlepad 表示“分割线”上的手柄与左端的距离,默认为 8 像素
handlesize设置“手柄”的尺寸(由于“手柄”必须是一个正方形,所以是设置正方形的边长)默认为 8 像素
opaqueresize1. 该选项定义了用户调整窗格尺寸的操作,如果该选项的值为 True(默认),窗格的尺寸随用户鼠标的拖拽而改变
2.  如果该选项的值为 False,那么窗格的尺寸,在用户释放鼠标时才会更新到新的位置上
orient指定窗格的分布方式,默认为水平方向分布("horizontal"),或者还可以设置为垂直纵向分布("vertical")
relif指定边框的样式,默认为 "flat",还可以设置为  "sunken","raised","groove" 或 "ridge"
sashpad设置每一条分割线到窗格间的间距
sashrelief设置分割线的样式,默认值是:"flat",还可以设置 "sunken","raised","groove" 或 "ridge"
sashwidth设置分割线的宽度
showhandle设置是否显示调节窗格的手柄,默认为 False
height/width设置 PanedWindow 的高度、宽度,若不设置,则其大小由其子组件的尺寸决定

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

方法说明
add(child)添加一个新的子组件到窗格中语法格式 add(child,**option),参数值 after、before、sticky
forget(child)删除一个子组件
panecget(child, option)获得子组件指定选项的值
paneconfig(child, **options)设置子组件的各种选项
panes()将父组件中包含的子组件以列表的形式返回
sash_coord(index)返回一个二元组表示指定分割线的起点坐标
sash_place(index, x, y)将指定的分割线移动到一个新的位置

PanedWindow 控件示例 :

# 第三十六章节:Tkinter 布局控件:PanedWindow
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP, SUNKEN, NE

root = tk.Tk()
root.title("Tkinter Text")
root.geometry('450x450')
root.resizable(0, 0)

# 创建一个水平方向的 panedwindow,并添加到主窗口中,默认为水平方向
p_window1 = tk.PanedWindow(root)
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='CSDN', 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='Java教程', 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)


# 显示窗口
root.mainloop()

Toplevel控件

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

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

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

方法说明
deiconify()在使用 iconify() 或 withdraw() 方法后,即窗口最小化和移除窗口后(只是看不见,并没销毁),使用该方法来显示该窗口
frame()返回一个系统特定的窗口识别码
group(window)将顶级窗口加入 window 窗口群组中,如果忽略该参数,将返回当前窗口群的主窗口
 iconify()将窗口图标化(最小化),需要重新显示窗口,使用 deiconify() 方法
 protocol(name, function)将回调函数 function 与相应的规则 name 绑定;
1) name 参数可以是 "WM_DELETE_WINDOW":窗口被关闭的时候;
2) name 参数可以是 "WM_SAVE_YOURSELF":窗口被保存的时候;
3) name 参数可以是 "WM_TAKE_FOCUS":窗口获得焦点的时候。
 state()设置和获得当前窗口的状态,参数值 "normal"(正常状态),"withdrawn(移除窗口)","icon"(最小化)和 "zoomed"(放大)
transient(master)指定为 master 的临时窗口
withdraw()将窗口从屏幕上移除,只是移动到了窗口之外,并没销毁,需要重新显示窗口,使用 deiconify() 方法

Toplevel 控件示例 

# 第三十六章节:Tkinter 布局控件:Toplevel
import tkinter as tk
from tkinter import messagebox, INSERT, END, ttk, LEFT, BOTTOM, X, RIGHT, Y, HORIZONTAL, BOTH, RAISED, TOP, SUNKEN, NE

root = tk.Tk()
root.title("Tkinter 控件")
root.geometry('450x450')
root.resizable(0, 0)


def create_toplevel():
    top = tk.Toplevel()
    top.title("Tkinter Toplevel")
    top.geometry('300x200+100+100')
    # 多行文本显示Message控件
    msg = tk.Label(top, text="www.google.com", bg='#9BCD9B', font=('宋体', 15))
    msg.pack()


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

# 显示窗口
root.mainloop()

Tkinter对话框控件

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

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

文件选择对话框

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

方法说明
Open()打开个某个文件
SaveAs()打开一个保存文件的对话框
askopenfilename()打开某个文件,并以包函文件名的路径作为返回值
askopenfilenames()同时打开多个文件,并以元组形式返回多个文件名
askopenfile()打开文件,并返回文件流对象
askopenfiles()打开多个文件,并以列表形式返回多个文件流对象
asksaveasfilename()选择以什么文件名保存文件,并返回文件名
asksaveasfile()选择以什么类型保存文件,并返回文件流对象
askdirectory选择目录,并返回目录名

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

参数说明
defaultextension指定文件的后缀名,当保存文件时自动添加文件名,如果自动添加了文件的后缀名,则该选项值不会生效
filetypes指定筛选文件类型的下拉菜单选项,该选项值是由 2 元祖构成的列表,其中每个二元祖由两部分组成 (类型名,后缀),比如 filetypes = [("PNG","*.png"), ("JPG", "*.jpg"), ("GIF","*.gif"),("文本文件","*.txt")...] 
initialdir指定打开/保存文件的默认路径,默认路径是当前文件夹
parent 如果不指定该选项,那么对话框默认显示在根窗口上,通过设置该参数可以使得对话框显示在子窗口上
title指定文件对话框的标题

文件选择对话框示例:

# 第三十六章节:Tkinter 文件选择对话框

import tkinter as tk
from tkinter import RAISED, filedialog

root = tk.Tk()
root.title("Tkinter 控件")
root.geometry('450x450')
root.resizable(0, 0)


# 定义一个处理文件的相关函数
def askfile():
    # 从本地选择一个文件,并返回文件的目录
    filename = filedialog.askopenfilename()
    if filename != '':
         lb.config(text=filename)
    else:
         lb.config(text='您没有选择任何文件')


btn = tk.Button(root, text='选择文件', relief=RAISED, command=askfile)
btn.grid(row=0, column=0)
lb = tk.Label(root, text='', bg='#87CEEB')
lb.grid(row=0, column=1, padx=5)
# 显示窗口
root.mainloop()

保存文件示例:

# 第三十六章节:Tkinter 文件选择对话框之文件保存

import tkinter as tk
from tkinter import RAISED, filedialog
from PIL import Image

root = tk.Tk()
root.title("Tkinter 控件")
root.geometry('450x450')
root.resizable(0, 0)


def open_img():
    try:
        global img
        filepath = filedialog.askopenfilename() # 打开文件,返回该文件的完整路径
        filename.set(filepath)
        img = Image.open(filename.get())
    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)


filename = tk.StringVar()
path_var = tk.StringVar()
# 定义读取文件的组件
entry = tk.Entry(root, textvariable=filename)
entry.grid(row=1, column=0, padx=5, pady=5)
tk.Button(root, text='选择文件', command=open_img).grid(row=1, column=1, padx=5, pady=5)
# 定义保存文件的组件
entry1 = tk.Entry(root, textvariable=path_var)
entry1.grid(row=2, column=0, padx=5, pady=5)
tk.Button(root, text='保存文件', command=save_png).grid(row=2, column=1, padx=5, pady=5)

# 显示窗口
root.mainloop()

颜色选择对话框

颜色选择对话框(colorchooser),提供了一个非常友善的颜色面板,它允许用户选择自己所需要的颜色。 当用户在面板上选择一个颜色并按下“确定”按钮后,它会返回一个二元祖,其第 1 个元素是选择的 RGB 颜色值,第 2 个元素是对应的 16 进制颜色值。

颜色选择对话款主要应用在画笔、涂鸦等功能上,通过它可以绘制出五彩缤纷的颜色,该对话框的使用非常简单,主要有以下两个常用方法:

方法说明
askcolor()打开一个颜色对话框,并将用户选择的颜色值以元组的形式返回(没选择返回None),格式为((R, G, B), "#rrggbb")
Chooser()打开一个颜色对话框,并用户选择颜色确定后,返回一个二元组,格式为((R, G, B), "#rrggbb")

常用的颜色对话框的参数值如下表所示:

属性说明
default要显示的初始的颜色,默认颜色是浅灰色(light gray)
title指定颜色选择器标题栏的文本,默认标题为“颜色”
parent1. 如果不指定该选项,那么对话框默认显示在根窗口上
2. 如果想要将对话框显示在子窗口上,那么可以设置 parent = 子窗口对象

颜色对话框示例:

# 第三十六章节:Tkinter 颜色对话框
import tkinter as tk
from tkinter import RAISED, filedialog, colorchooser

root = tk.Tk()
root.title("Tkinter 控件")
root.geometry('450x450')
root.resizable(0, 0)


def callback():
    # 打开颜色对话款
    colorvalue = 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 程序更加人性化。消息对话框主要包含了以下常用方法:

方法说明
askokcancel(title=None, message=None)打开一个“确定/取消”的对话框
askquestion(title=None, message=None)打开一个“是/否”的对话框。
askretrycancel(title=None, message=None)打开一个“重试/取消”的对话框
askyesno(title=None, message=None)打开一个“是/否”的对话框
showerror(title=None, message=None)打开一个错误提示对话框
showinfo(title=None, message=None)打开一个信息提示对话框
showwarning(title=None, message=None)打开一个警告提示对话框

上述方法拥有相同的选项参数,如下表所示:

属性说明
default1. 设置默认的按钮(也就是按下回车响应的那个按钮)
2. 默认是第一个按钮(像“确定”,“是”或“重试”)
3. 可以设置的值根据对话框函数的不同,可以选择 CANCEL,IGNORE,OK,NO,RETRY 或 YES
icon1. 指定对话框显示的图标
2. 可以指定的值有:ERROR,INFO,QUESTION 或 WARNING
3. 注意:不能指定自己的图标
parent1. 如果不指定该选项,那么对话框默认显示在根窗口上
2. 如果想要将对话框显示在子窗口上,那么可以设置 parent= 子窗口对象

上述方法的返回值一般会是一个布尔值,或者是“YES”,“NO”,“OK”等,这些方法使用较为简单,此处不进行逐一列举,看个简单的示例即可:

# 第三十六章节:Tkinter 消息对话框
import tkinter as tk
from tkinter import RAISED, filedialog, colorchooser

root = tk.Tk()
root.title("Tkinter 控件")
root.geometry('450x450')
root.resizable(0, 0)


def callMessageDialog():
    result = tk.messagebox.askokcancel("提示", " 你确定要关闭窗口吗? ")
    # 返回布尔值参数
    print(result)

tk.Button(root, text="点击消息对话框", command=callMessageDialog, width=10, bg='#9AC0CD').pack()

# 显示窗口
root.mainloop()

本文参考:Tkinter 教程

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1537777.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

AI新工具(20240322) 免费试用Gemini Pro 1.5;先进的AI软件工程师Devika;人形机器人Apptronik给你打果汁

✨ 1: Gemini Pro 1.5 免费试用Gemini Pro 1.5 Gemini 1.5 Pro是Gemini系列模型的最新版本&#xff0c;是一种计算高效的多模态混合专家&#xff08;MoE&#xff09;模型。它能够从数百万个上下文Token中提取和推理细粒度信息&#xff0c;包括多个长文档和数小时的视频、音频…

R语言逻辑回归与lasso模型

一、数据描述 数据集heart_learning.csv与heart_test.csv是关于心脏病的数据集&#xff0c;heart_learning.csv是训练数据集&#xff0c;heart_test.csv是测试数据集。 变量名称变量说明age年龄sex性别&#xff0c;取值1代表男性&#xff0c;0代表女性pain 胸痛的类型&#x…

SQLiteC/C++接口详细介绍sqlite3_stmt类(十二)

返回&#xff1a;SQLite—系列文章目录 上一篇&#xff1a;SQLiteC/C接口详细介绍sqlite3_stmt类&#xff08;十一&#xff09; 下一篇&#xff1a; SQLiteC/C接口详细介绍sqlite3_stmt类&#xff08;十三&#xff09; 48、sqlite3_stmt_isexplain sqlite3_stmt_is…

Django日志(四)

一、Filters介绍 过滤器用于从logger传递给handler的哪些日志要做额外控制 默认情况下,满足日志级别的任何消息都将处理。只要级别匹配,任何日志消息都会被处理。不过,也可以通过添加 filter 来给日志处理的过程增加额外条件。例如,可以添加一个 filter 只允许某个特定来源…

手机网页关键词视频爬虫采集软件可导出视频分享链接|视频无水印批量下载工具

全新音视频批量下载工具&#xff0c;为您解放视频管理烦恼&#xff01; 现如今&#xff0c;音上涌现出大量精彩的视频内容&#xff0c;但是要想高效地获取、管理和分享这些视频却是一件颇具挑战的事情。针对这一难题&#xff0c;我们自主研发了全新的音视频批量下载工具&#x…

什么是单点登录?

单点登录&#xff08;Single Sign On&#xff0c;简称 SSO&#xff09;简单来说就是用户只需在一处登录&#xff0c;不用在其他多系统环境下重复登录。用户的一次登录就能得到其他所有系统的信任。 为什么需要单点登录 单点登录在大型网站应用频繁&#xff0c;比如阿里旗下有淘…

B-tree - 深度解析+C语言实现+opencv绘图助解

B-tree - 深度解析C语言实现opencv绘图助解 1. 概述2. B-tree介绍3. Btree算法实现3.1 插入3.1.1 排序3.1.2 分裂1) 叶子节点的分裂2) 根节点的分裂&#xff08;特殊的分裂&#xff09;3) 内节点的分裂 3.2 删除3.2.1 再平衡&#xff08;Rebalance&#xff09;左旋右旋合并 3.2…

蓝桥杯 2022 省B 积木画

这是个典型的动态规划问题&#xff0c;重点在于找到他的递推方程。 可简单算出填满第0 1 2 3 4列个数为0 1 2 5 11&#xff1b; 运气好点&#xff0c;找到递推公式dp[i]2*dp[i-1]dp[i-3]; 直接解决了。 但我们还是按照动态规划一步一步来。 思路分析&#xff1a; 状态定义&a…

css3鼠标悬停图片特效,图片悬停效果源码

特效介绍 css3鼠标悬停图片特效,图片悬停效果源码&#xff0c;可以在网页上面作为自己的动态加载名片&#xff0c;放到侧边栏或者网站合适的位置即可 动态效果 代码下载 css3鼠标悬停图片特效,图片悬停效果源码

docker进阶篇,docker集群介绍

docker swarm 官网&#xff1a;https://docs.docker.com/engine/swarm/how-swarm-mode-works/nodes/ 什么是 docker swarm docker swarm 是 docker 官方提供的容器编排和集群管理工具。它允许用户将多个 docker 主机组成一个虚拟的 docker 集群&#xff0c;以便更高效地管理…

解决用POI库生成的word文件中的表格在python-docx无法解析的问题

问题背景 用apache-poi生成word文件中表格&#xff0c;在使用python-docx库解析时报错&#xff1a; 问题分析 1. word文档本质上是一个rar压缩包&#xff0c;用winrar解析后如下&#xff1a; 2. 查看document.xml&#xff0c;可以看到table元素下面是没有<w:tblGrid>这…

HTTP --- 上

目录 1. HTTP协议 2. 认识URL 2.1. URL中的四个主要字段 2.2. URL Encode && URL Decode 3. HTTP 协议格式 3.1. 快速构建 HTTP 请求和响应的报文格式 3.1.1. HTTP 请求格式 3.1.2. HTTP 响应格式 3.1.3. 关于 HTTP 请求 && 响应的宏观理解 3.2. 实现…

基于PID控制器的四旋翼无人机控制系统的simulink建模与仿真,并输出虚拟现实动画

目录 1.课题概述 2.系统仿真结果 3.核心程序与模型 4.系统原理简介 4.1四旋翼无人机的动力学模型 4.2 PID控制器设计 4.3 姿态控制实现 4.4 VR虚拟现实动画展示 5.完整工程文件 1.课题概述 基于PID控制器的四旋翼无人机控制系统的simulink建模与仿真,并输出vr虚拟现实…

CI/CD环境搭建

服务简介 Gitlab 官网&#xff1a;https://about.gitlab.com/ GitLab 是一个用于仓库管理系统的开源项目&#xff0c;使用Git作为代码管理工具&#xff0c;并在此基础上搭建起来的Web服务。安装方法是参考GitLab在GitHub上的Wiki页面。Gitlab是被广泛使用的基于git的开源代码管…

每日一题——LeetCode1720.解码异或后的数组

方法一 异或运算的性质 encoded[i−1]arr[i−1]⊕arr[i] 在等式两边同时异或arr[i−1] 由于&#xff1a; 一个数异或它自己&#xff0c;结果总是0。 0异或任何数&#xff0c;结果都是那个数本身。 所以等式可以转化为&#xff1a; arr[i]arr[i−1]⊕encoded[i−1] 由于 a…

智慧工业园区的物联网解决方案

智慧工业园区的物联网解决方案 智慧工业园区的物联网解决方案&#xff0c;是一种深度融合物联网、大数据、云计算及人工智能等前沿技术&#xff0c;以实现工业园区全方位、智能化管理与服务的综合体系。该方案旨在通过高效采集和分析园区内的各类实时数据&#xff0c;构建出一…

什么是PLC物联网关?PLC物联网关有哪些功能?

在数字化浪潮的推动下&#xff0c;工业物联网&#xff08;IIoT&#xff09;正逐步成为推动制造业智能化转型的关键力量。而在这一变革中&#xff0c;PLC物联网关扮演着至关重要的角色。今天&#xff0c;就让我们一起走进PLC物联网关的世界&#xff0c;了解它的定义、功能&#…

直播行业网络安全建设

一、引言 直播行业近年来蓬勃发展&#xff0c;吸引了大量用户和资本的关注。然而&#xff0c;随着行业的壮大&#xff0c;网络安全问题也日益凸显。构建一个安全、稳定的直播行业网络对于保障用户权益、维护行业秩序具有重要意义。本文将详细探讨直播行业安全网络的构建与保障…

【算法刷题 | 二叉树 02】3.21 二叉树的层序遍历01(5题:二叉树的层序遍历、层序遍历||、右视图、层平均值,以及N叉树的层序遍历)

文章目录 5.二叉树的层序遍历5.1 102_二叉树的层序遍历5.1.1问题5.1.2解法&#xff1a;队列 5.2 107_二叉树的层序遍历||5.2.1问题5.2.2解法&#xff1a;队列 5.3 199_二叉树的右视图5.3.1问题5.3.2解决&#xff1a;队列 5.4 637_二叉树的层平均值5.4.1问题5.4.2解决&#xff1…

VScode通过ssh连接github

通过ssh连接github 1.生成公钥和私钥2.设置config文件3.配置ssh免密登录4.远程仓库初始化 1.生成公钥和私钥 首先选择一个文件夹&#xff0c;右击 git bash here&#xff0c;在命令行输入命令&#xff0c;按下三次回车生成一个**.ssh文件夹**&#xff0c;一般在用户的user根目…