笔记

Tkinter主窗口

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

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

觉得演示

1
2
3
4
5
6
7
8
9
10
11
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720012509192

设置住窗口大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

#设置大小下面有说明
top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

#开启主循环，让窗口处于显示状态
top.mainloop()

xx.geometry('450x400+300+200')设置主窗口的宽度为 450，高度为 400，同时窗口距离左边屏幕的距离为 300（以像素为单位），距离屏幕顶部的距离为 200，这里我们将带“+”的参数值称为“位置参数

adas

图标设置

windows设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

# 程序窗口大小
top.geometry('450x400+300+200')

# 添加程序的ico
top.iconbitmap('C://Users//Machenike//Desktop//picture.ico')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720021844478

linux设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding:utf-8 -*-
import tkinter as tk
from PIL.ImageTk import PhotoImage

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 添加程序的ico
icon = PhotoImage(file="/home/zss/图片/tx.ico")
top.tk.call('wm', 'iconphoto', top._w, icon)

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
#开启主循环，让窗口处于显示状态
top.mainloop()

添加前背景颜色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')



# 设置窗口的背景色为红色，也可以接受 16 进制的颜色值
top.config(background ="red")

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720022019452

关闭窗口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# 添加按钮，以及按钮的文本，并通过command 参数设置关闭窗口的功能
button=tk.Button(layout1,text="关闭",command=top.quit)

# 将按钮放置在主窗口内和iapp的线性布局一样
button.pack(side="bottom")

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720025506436

messagebox提示框详解

image-20220720044534275

三个消息框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()

# 提示框
result=messagebox.showinfo('提示', '这是一个提示框')
print("提示框"+str(result)) # 查看一下返回值

# 警告框
result=messagebox.showwarning('警告', '这是一个警告框')
print("警告框"+str(result)) # 查看一下返回值

# 错误框
result=messagebox.showerror('错误', '这是一个错误框')
print("错误框"+str(result)) # 查看一下返回值

返回值：

1
2
3
提示框ok
警告框ok
错误框ok

效果截图：

image-20220720043306547

五个对话框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()

# 询问确认对话框
result=messagebox.askokcancel('是(Y) | 否(N)', 'yes or no ?')
print("询问确认对话框返回"+str(result)) # 查看一下返回值

# 是/否对话框
result=messagebox.askyesno('是(Y) | 否(N)', 'True or False ?')
print("是/否对话框返回"+str(result)) # 查看一下返回值

# 确认/取消对话框
result=messagebox.askokcancel('确定 | 取消', 'True or False ?')
print("确认/取消对话框返回"+str(result)) # 查看一下返回值

# 重试/取消对话框
result=messagebox.askretrycancel('重试(R) | 取消', 'True or False ?')
print("重试/取消对话框返回"+str(result)) # 查看一下返回值

# 是/否/取消对话框
result=messagebox.askyesnocancel('是(Y) | 否(N) | 取消', 'True or False or None')
print("是/否/取消对话框返回"+str(result)) # 查看一下返回值

全部选择左边第一个返回值

1
2
3
4
5
询问确认对话框返回True
是/否对话框返回True
确认/取消对话框返回True
重试/取消对话框返回True
是/否/取消对话框返回True

效果截图：

image-20220720044151636

Label标签控件

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

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

Label的属性

属性名称 说明
text 用来指定 Lable 显示的文本，注意文本内可以包含换行符
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/pady padx 指定 Label 水平方向上的间距（即内容和边框间），pady 指定 Lable 水平方向上的间距（内容和边框间的距离）
relief 指定边框样式，默认值是 “flat”，其他参数值有 “groove”、”raised”、”ridge”、”solid”或者”sunken”
state 该参数用来指定 Lable 的状态，默认值为”normal”（正常状态），其他可选参数值有”active”和”disabled”
takefocus 默认值为False，如果是 True，表示该标签接受输入焦点
anchor 控制文本（或图像）在 Label 中显示的位置（方位），通过方位的英文字符串缩写（n、ne、e、se、s、sw、w、nw、center）实现定位，默认为居中（center）
underline 给指定的字符添加下划线，默认值为 -1 表示不添加，当设置为 1 时，表示给第二个文本字符添加下划线。
wraplength 将 Label 显示的文本分行，该参数指定了分行后每一行的长度，默认值为 0

text

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------

# text显示的文本
Label_text=tk.Label(layout1,text="赵赛赛aaaa", )

# 在主窗口内显示和iapp的线性布局一样
Label_text.pack()
# -----------------------------------------------------------------
#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720032929470

颜色和大小和字体设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
# Label演示
Label_text=tk.Label(layout1,
                text="赵赛赛aaaa", # text显示的文本
                width=10,# width和height高和宽
                height=3,
                bg="#7CCD7C", # 设置颜色
                font=('宋体',20, 'bold italic') #(字体,大小,样式）
                )
# -----------------------------------------------------------------

# 在主窗口内显示
Label_text.pack()

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720033038547

显示照片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
# 设置图片
img=tk.PhotoImage(file="/home/zss/图片/avatar.png")

Label_img=tk.Label(layout1,
                   image=img, # 使用照片
                   width=1000) # 设置高度

# 在主窗口内显示
Label_img.pack()
# -----------------------------------------------------------------
#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720035424200

多行输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
# Label演示
Label_text=tk.Label(layout1,
                text="aaaa\n bbb\nccc\n ddd", # text显示的文本
                width=10,# width和height高和宽
                height=5,
                bg="#7CCD7C", # 设置颜色
                font=('宋体',10, 'bold italic') #(字体,大小,样式）
                )


# 在主窗口内显示
Label_text.pack()
# -----------------------------------------------------------------
#开启主循环，让窗口处于显示状态
top.mainloop()

我们直接在18行text里面\n就换行了

image-20220720040534660

左对齐右对齐

上面可以看见他是在中间我们可以用justify参数进行设置对齐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# Label演示
Label_text=tk.Label(layout1,
                text="aaaaaaaaaaaaaaaaa\n bbb\nccc\n ddd", # text显示的文本
                width=30,# width和height高和宽
                height=5,
                bg="#7CCD7C", # 设置颜色
                font=('宋体',10, 'bold italic'), #(字体,大小,样式）
                justify='right' # 参数有left(是左对齐)、right(是右对齐)、center(是中对齐)
                )


# 在主窗口内显示
Label_text.pack()

#开启主循环，让窗口处于显示状态
top.mainloop()

代码在23行

image-20220720041105738

Button按钮控件

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

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

Button的属性

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

照片和文本按钮

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()

top.geometry('450x400+300+200')

# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
# 设置回调函数
def callback():
    messagebox.showinfo('登录情况', '登录成功',)

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()

# 设置照片
img=tk.PhotoImage(file="/home/zss/图片/dl.png")
# 使用按钮控件调用函数
button2 = tk.Button(layout1, image=img, command=callback)
# 将按钮放置在主窗口内
button2.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

结果：我设置了两个登录都是一样的只是一个照片一个文本

image-20220720044804910

按钮使用lambda

Entry接收输入控件

更详细可以去：http://c.biancheng.net/tkinter/entry-widget.html

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

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

Entry的属性名称

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

常用方法

除了一些基本的属性之外，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。

StringVar()动态数据类型

StringVar()就是我们在如何地方修改这个他都会变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# -*- coding:utf-8 -*-
import tkinter as tk
import time
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# -----------------------------------------------------------------
# 获取时间的函数
def gettime():
    # 获取当前时间
    dstr.set(time.strftime("%H:%M:%S"))
    # 每隔 1s 调用一次 gettime()函数来获取时间
    layout1.after(1000, gettime)

# 生成动态字符串
dstr = tk.StringVar()

# 利用 textvariable 来实现文本变化
lb = tk.Label(layout1,textvariable=dstr,fg='green',font=("微软雅黑",20))

# 在主窗口内显示
lb.pack()

#调用上面的函数
gettime()
# -----------------------------------------------------------------
#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720051128767

获取我们输入的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# -----------------------------------------------------------------
# 设置回调函数
def callback():
    messagebox.showinfo('你输入的是', dstr.get())

# 生成动态字符串
dstr = tk.StringVar()

# 利用 textvariable 来实现文本变化
lb = tk.Entry(layout1,textvariable=dstr)

# 在主窗口内显示
lb.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720052545377

insert设置默认值

语法

1
insert(index,'字符')  # 将字符插入到 index 指定的索引位置。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()



# 设置回调函数
def callback():
    messagebox.showinfo('你输入的是', dstr.get())

# 生成动态字符串
dstr = tk.StringVar()

# 利用 textvariable 来实现文本变化
lb = tk.Entry(layout1,textvariable=dstr,
								width=30) # 设置宽度

# 在主窗口内显示
lb.pack()

# -----------------------------------------------------------------
lb.insert(0,'这个是默认值')
# -----------------------------------------------------------------

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()


#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720161425685

设置输入框的宽度

输入框不能设置高度，可以设置字体大小来设置高度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()



# 设置回调函数
def callback():
    messagebox.showinfo('你输入的是', dstr.get())

# 生成动态字符串
dstr = tk.StringVar()
# -----------------------------------------------------------------
# 利用 textvariable 来实现文本变化
lb = tk.Entry(layout1,textvariable=dstr,
								width=30) # 设置宽度
# -----------------------------------------------------------------
# 在主窗口内显示
lb.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()


#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720052734185

delete清空输入框的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()



# 设置回调函数
def callback():
# -----------------------------------------------------------------
    # 0是开头，END是最后
    lb.delete(0, tk.END)
# -----------------------------------------------------------------

# 生成动态字符串
dstr = tk.StringVar()

# 利用 textvariable 来实现文本变化
lb = tk.Entry(layout1,textvariable=dstr,
								width=30) # 设置宽度

# 在主窗口内显示
lb.pack()

# 设置默认值
lb.insert(0,'这个是默认值')


# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="点击删除框里面的内容", command=callback)
# 将按钮放置在主窗口内messagebox
button1.pack()


#开启主循环，让窗口处于显示状态
top.mainloop()

Entry控件验证功能

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

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

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

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

下面看一组具体的运行示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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)
# 创建验证函数
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 entry控件
图4：tkinter Entry控件

Spinbox 高级输入框

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

增加数字的方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()



# 设置回调函数
def callback():
    messagebox.showinfo('你输入的是', dstr.get())

# 生成动态字符串
dstr = tk.StringVar()
# -----------------------------------------------------------------
# 利用 textvariable 来实现文本变化
lb = tk.Spinbox(layout1,textvariable=dstr,
								width=30, # 设置宽度
                                from_=0, # 范围 0-20
                                to=20,
                                increment=2, # 并且与2步长递增或递减
                                bg='#9BCD9B') #设置颜色
# -----------------------------------------------------------------
# 在主窗口内显示
lb.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()


#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720053652080

使用 values 参数以元组的形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x150+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()



# 设置回调函数
def callback():
    messagebox.showinfo('你输入的是', dstr.get())

# 生成动态字符串
dstr = tk.StringVar()

# -----------------------------------------------------------------
# 利用 textvariable 来实现文本变化
lb = tk.Spinbox(layout1,textvariable=dstr,
								width=30, # 设置宽度
                                values=('php', 'jsp', 'asp'),
                                increment=2, # 并且与2步长递增或递减
                                bg='#9BCD9B') #设置颜色
# -----------------------------------------------------------------
# 在主窗口内显示
lb.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="登录", command=callback)
# 将按钮放置在主窗口内
button1.pack()


#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720053929019

Text文本框控件

详细查看：http://c.biancheng.net/tkinter/text-widget.html

视频教程：https://www.bilibili.com/video/BV1zE411g7LY?p=9

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

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

文本控件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import messagebox
from tkinter import Text

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# -----------------------------------------------------------------
# 创建一个文本控件
# width 一行可见的字符数；height 显示的行数
text = Text(layout1, width=50, # 高宽设置
                     height=10,
                     undo=True, # 该参数默认为 False，表示关闭 Text 控件的“撤销”功能，若为 True 则表示开启
                    autoseparators=False) # 默认为 True，表示执行撤销操作时是否自动插入一个“分隔符”（其作用是用于分隔操作记录）
text.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720054928247

Index文本索引

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

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

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

演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Text
from tkinter import INSERT

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# 设置文本框控件
text = Text(layout1, width=20, height=8, undo=True, autoseparators=False)

# 在主窗口内显示
text.pack()
# -----------------------------------------------------------------
# 设置默认值
text.insert(INSERT,'aaaaaaaaaa') # 第一行
text.insert(1.3,'12') # 表示第1行第3列的一个位置输出
text.insert(1.7,'34') # 表示第1行第7列的一个位置输出
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720164631168

删除和恢复

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Text
from tkinter import INSERT
# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# -----------------------------------------------------------------
# 设置回调函数
def backout():
    # 删除文本域的全部内容
    text.edit_undo()

# 设置回调函数
def regain():
    # 恢复文本域的全部内容
    text.edit_redo()
# -----------------------------------------------------------------
# 创建一个文本控件
text = Text(layout1, width=20, height=8, undo=True, autoseparators=False)

# 在主窗口内显示
text.pack()

# 设置默认值
text.insert(INSERT,'这个是默认值这个是默\n认值这个是默认值这个是默认值这\n个是默认值这个是默认值这个是默认值')


# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="删除里面的全部内容", command=backout)
# 将按钮放置在主窗口内
button1.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="恢复里面的全部内容", command=regain)
# 将按钮放置在主窗口内
button1.pack()

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720163739027

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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Text
from tkinter import INSERT

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# 设置文本框控件
text = Text(layout1, width=20, height=8, undo=True, autoseparators=False)

# 在主窗口内显示
text.pack()
# -----------------------------------------------------------------
# 设置默认值
text.insert (INSERT,  "aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbcccccccccccc")

# 在第一行文字的第0个字符到第6个字符处插入标签，标签名称为"name"
text.tag_add("name", "1.0", "1.6")

#使用 tag_config() 来改变标签"name"的前景与背景颜色,并加下画线，通过标签控制字符的样式
text.tag_config("name", font=('微软雅黑',18,'bold'),
                        background="yellow",
                        foreground= "blue",
                        underline=1)
# -----------------------------------------------------------------
#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720165405591

列表框和组合框控件

详细查看：http://c.biancheng.net/tkinter/listbox.html

Combobox控件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# -----------------------------------------------------------------
# 创建下拉菜单
cbox = ttk.Combobox(layout1)

# 设置下拉菜单中的值
cbox['value'] = ('asp','jsp','php')

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

# 编写回调函数，绑定执行事件,向文本插入选中文本
def func(event):
    messagebox.showinfo('提示', cbox.get())

# 绑定下拉菜单事件
cbox.bind("<<ComboboxSelected>>",func)

cbox.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

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

1
from tkinter import ttk

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

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

image-20220720170445974

获得你选择的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# -----------------------------------------------------------------
# 创建下拉菜单
cbox = ttk.Combobox(layout1)

# 设置下拉菜单中的值
cbox['value'] = ('asp','jsp','php')

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

# 编写回调函数，绑定执行事件,向文本插入选中文本
def func():
    messagebox.showinfo('提示', cbox.get())

# 绑定下拉菜单事件
cbox.bind("<<ComboboxSelected>>")

cbox.pack()

# 使用按钮控件调用函数
button1 = tk.Button(layout1, text="获得你选择的", command=func)
# 将按钮放置在主窗口内
button1.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720171243617

单选框和多选框按钮

Radiobutton

Radiobutton的属性

属性 说明
activebackground 设置当 Radiobutton 处于活动状态（通过 state 选项设置状态）的背景色，默认值由系统指定
activeforeground 设置当 Radiobutton 处于活动状态（通过 state 选项设置状态）的前景色，默认值由系统指定
compound 1. 默认值为 None，控制 Radiobutton 中文本和图像的混合模式，默认情况下，如果有指定位图或图片，则不显示文本 2. 如果该选项设置为 “center”，文本显示在图像上（文本重叠图像） 3. 设置为 “bottom”，”left”，”right” 或 “top”，那么图像显示在文本的旁边，比如如”bottom”，则显示图像在文本的下方。
disabledforeground 指定当 Radiobutton 不可用的时的前景色颜色，默认由系统指定
indicatoron 1. 该参数表示选项前面的小圆圈是否被绘制，默认为 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 控件设置为选中状态 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()

# -----------------------------------------------------------------
# 使用 variable 参数来关联 IntVar() 的变量 v
tk.Radiobutton(layout1, text="php",
                        fg='blue',font=('微软雅黑','12','bold'),
                       value=0).pack(anchor = 'w')
tk.Radiobutton(layout1, text="jsp",
                        value=2).pack(anchor = 'w')
tk.Radiobutton(layout1, text="asp",
                        value=3).pack(anchor = 'w')
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720172241270

上面一行一行的写很费劲

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
site = [('php',1),
        ('jsp',2),
        ('asp',3)]
# IntVar() 用于处理整数类型的变量
v = tk.IntVar()
# 重构后的写法，也非常简单易懂
for name, num in site:
    radio_button = tk.Radiobutton(layout1,text = name,value =num)
    radio_button.pack(anchor ='w')
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720172241270

Checkbutton复选框控件

Checkbutton属性

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

格式

1
Checkbutton(master=None, **options)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Checkbutton
from tkinter import messagebox
from tkinter import IntVar
from tkinter import LEFT
from tkinter import Button

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# -----------------------------------------------------------------
# 定义执行函数
def study():
    print("你选择了")
    if CheckVar1.get():
        print("php")
    if CheckVar2.get():
        print("asp")
    if CheckVar3.get():
        print("jsp")
# 新建整型动态变量
CheckVar1 = IntVar()
CheckVar2 = IntVar()
CheckVar3 = IntVar()
# 设置三个复选框控件，使用variable参数来接收变量
check1 = Checkbutton(layout1, text="php",
                             fg='blue',
                             font=('微软雅黑', 15,'bold'),
                             variable = CheckVar1,
                             onvalue=1,
                             offvalue=0)
check2 = Checkbutton(layout1, text="asp",
                             fg='blue',
                             font=('微软雅黑', 15,'bold'),
                             variable = CheckVar2,
                             onvalue=1,
                             offvalue=0)
check3 = Checkbutton(layout1, text="jsp",
                             fg='blue',
                             font=('微软雅黑', 15,'bold'),
                             variable = CheckVar3,
                             onvalue=1,
                             offvalue=0)

check1.pack ()
check2.pack ()
check3.pack ()

btn = Button(layout1,text="选好了",bg='#BEBEBE',command=study)
btn.pack()
# -----------------------------------------------------------------

#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720174000594

Canvas画布控件

Canvas控件基本属性

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

属性 方法
background(bg) 指定 Canvas 控件的背景颜色
borderwidth(bd) 指定 Canvas 控件的边框宽度
closeenough 1. 指定一个距离，当鼠标与画布对象的距离小于该值时，认为鼠标位于画布对象上 2. 该选项是一个浮点类型的值
confine 1. 指定 Canvas 控件是否允许滚动超出 scrollregion 选项设置的滚动范围，默认值为 True
selectbackground 指定当画布对象（即在 Canvas 画布上绘制的图形）被选中时的背景色，
selectborderwidth 指定当画布对象被选中时的边框宽度（选中边框）
selectforeground 指定当画布对象被选中时的前景色
state 设置 Canvas 的状态：”normal” 或 “disabled”，默认值是 “normal”，注意，该值不会影响画布对象的状态
takefocus 指定使用 Tab 键可以将焦点移动到输入框中，默认为开启，将该选项设置为 False 避免焦点在此输入框中
width 指定 Canvas 的宽度，单位为像素
xscrollcommand 与 scrollbar（滚动条）控件相关联（沿着 x 轴水平方向）
xscrollincrement 1. 该选项指定 Canvas 水平滚动的“步长” 2. 例如 ‘3c’ 表示 3 厘米，还可以选择的单位有 ‘i’（英寸），’m’（毫米）和 ‘p’（DPI，大约是 ‘1i’ 等于 ‘72p’） 3. 默认为 0，表示可以水平滚动到任意位置
yscrollcommand 与 scrollbar 控件（滚动条）相关联（沿着 y 轴垂直方向）
yscrollincrement 1. 该选项指定 Canvas 垂直滚动的“步长” 2. 例如 ‘3c’ 表示 3 厘米，还可以选择的单位有 ‘i’（英寸），’m’（毫米）和 ‘p’（DPI，大约是 ‘1i’ 等于 ‘72p’） 3. 默认值是 0，表示可以垂直方向滚动到任意位置

演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# -*- coding:utf-8 -*-
import tkinter as tk

# 调用Tk()创建主窗口
top =tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()


# 创建画布
canvas = tk.Canvas(layout1,
                   bg='#CDC9A5',
                   height=200,
                   width=300)
# 在主窗口内显示
canvas.pack()
#开启主循环，让窗口处于显示状态
top.mainloop()

image-20220720174504870

Canvas控件绘图常用方法

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

方法 说明
create_line(x0, y0, x1, y1, … , xn, yn, options) 1. 根据给定的坐标创建一条或者多条线段； 2. 参数 x0,y0,x1,y1,…,xn,yn 定义线条的坐标； 3. 参数 options 表示其他可选参数
create_oval(x0, y0, x1, y1, options) 1. 绘制一个圆形或椭圆形； 2. 参数 x0 与 y0 定义绘图区域的左上角坐标；参数 x1 与 y1 定义绘图区域的右下角坐标； 3. 参数 options 表示其他可选参数
create_polygon(x0, y0, x1, y1, … , xn, yn, options) 1. 绘制一个至少三个点的多边形； 2. 参数 x0、y0、x1、y1、…、xn、yn 定义多边形的坐标； 3. 参数 options 表示其他可选参数
create_rectangle(x0, y0, x1, y1, options) 1. 绘制一个矩形； 2. 参数 x0 与 y0 定义矩形的左上角坐标；参数 x 与 y1 定义矩形的右下角坐标； 3. 参数 options 表示其他可选参数
create_text(x0, y0, text, options) 1. 绘制一个文字字符串。其中 2. 参数 x0 与 y0 定义文字字符串的左上角坐标，参数 text 定义文字字符串的文字； 3. 参数 options 表示其他可选参数
create_image(x, y, image) 1. 创建一个图片; 2. 参数 x 与 y 定义图片的左上角坐标； 3. 参数 image 定义图片的来源，必须是 tkinter 模块的 BitmapImage 类或 PhotoImage 类的实例变量。
create_bitmap(x, y, bitmap) 1. 创建一个位图； 2. 参数 x 与 y 定义位图的左上角坐标； 3. 参数 bitmap 定义位图的来源，参数值可以是 gray12、gray25、gray50、gray75、hourglass、error、questhead、info、warning 或 question，或者也可以直接使用 XBM（X Bitmap）类型的文件，此时需要在 XBM 文件名称前添加一个 @ 符号，例如 bitmap=@hello.xbm
create_arc(coord, start, extent, fill) 1. 绘制一个弧形； 2. 参数 coord 定义画弧形区块的左上角与右下角坐标； 3. 参数 start 定义画弧形区块的起始角度（逆时针方向）； 4. 参数 extent 定义画弧形区块的结束角度（逆时针方向）； 5. 参数 fill 定义填充弧形区块的颜色。

Menu菜单控件

建菜单时用到的相关方法

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

方法

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

添加菜单项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Menu

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 创建一个主目录菜单，也被称为顶级菜单
main_menu = Menu(top)

# 新增命令菜单项，使用 add_command() 实现
main_menu.add_command(label="文件")
main_menu.add_command(label="编辑")
main_menu.add_command(label="格式")
main_menu.add_command(label="查看")
main_menu.add_command(label="帮助")

# 显示菜单
top.config(menu=main_menu)
# -----------------------------------------------------------------
top.mainloop()

image-20220720180931671

创建下拉菜单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Menu

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 创建一个主目录菜单，也被称为顶级菜单
main_menu = Menu(top)

#在顶级菜单上新增"文件"菜单的子菜单，同时不添加分割线
filemenu = Menu (main_menu)

# 新增命令菜单项，使用 add_command() 实现
filemenu.add_command(label="文件")
filemenu.add_command(label="编辑")
filemenu.add_command(label="格式")
filemenu.add_command(label=pack"查看")
filemenu.add_command(label="帮助")

#在主目录菜单上新增"文件"选项，并通过menu参数与下拉菜单绑定
main_menu.add_cascade (label="文件",menu=filemenu)

# 显示菜单
top.config(menu=main_menu)
# -----------------------------------------------------------------
top.mainloop()

image-20220720181710831

设置点击事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Menu
from tkinter import messagebox

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
def dj():
    messagebox.showinfo('提示', '这是一个提示框')

# 创建一个主目录菜单，也被称为顶级菜单
main_menu = Menu(top)


# 新增命令菜单项，使用 add_command() 实现
main_menu.add_command(label="文件",command=dj)
main_menu.add_command(label="编辑",command=dj)
main_menu.add_command(label="格式",command=dj)
main_menu.add_command(label="查看",command=dj)
main_menu.add_command(label="帮助",command=dj)

# 显示菜单
top.config(menu=main_menu)
# -----------------------------------------------------------------
top.mainloop()

image-20220720182114423

Scrollbar滚动条控件

Scrollbar的属性

属性 说明
activebackground 指定当鼠标在上方飘过的时候滑块和箭头的背景颜色，默认由系统决定
activerelief 指定当鼠标在滑块上方飘过时滑块的样式，默认值是 “raised”，其他可选值有 “flat”，”sunken”，”groove”，”ridge”
background(bg) 指定背景颜色，默认值由系统指定
borderwidth(bd) 指定边框宽度，默认值是 0
command 当滚动条更新时回调的函数，通常指定对应组件的 xview() 或 yview() 方法
cursor 指定当鼠标在上方飘过的时的鼠标样式，默认值由系统指定
elementborderwidth 1. 指定滚动条和箭头的边框宽度 2. 默认值是 -1（表示使用 borderwidth 选项的值）
jump 1. 指定当用户拖拽滚动条时的行为 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）

创建垂直滚动条

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import RIGHT
from tkinter import Y



# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 创建一个滚动条控件，默认为垂直方向
sbar1= tk.Scrollbar(top)

# 将滚动条放置在右侧，并设置当窗口大小改变时滚动条会沿着垂直方向延展
sbar1.pack(side=RIGHT, fill=Y)
# -----------------------------------------------------------------

top.mainloop()

image-20220720182847066

创建水平滚动条

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import BOTTOM
from tkinter import HORIZONTAL
from tkinter import X


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 创建水平滚动条，默认为水平方向,当拖动窗口时会沿着X轴方向填充
sbar1= tk.Scrollbar(top, orient=HORIZONTAL)

sbar1.pack(side=BOTTOM, fill=X)
# -----------------------------------------------------------------

top.mainloop()

image-20220720183058220

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# -*- coding:utf-8 -*-
import tkinter as tk


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 创建一个滚动条控件，默认为垂直方向
sbar1= tk.Scrollbar(top)

# 将滚动条放置在右侧，并设置当窗口大小改变时滚动条会沿着垂直方向延展
sbar1.pack(side=tk.RIGHT, fill=tk.Y)

# 创建水平滚动条，默认为水平方向,当拖动窗口时会沿着X轴方向填充
sbar2= tk.Scrollbar(top, orient=tk.HORIZONTAL)
sbar2.pack(side=tk.BOTTOM, fill=tk.X)
# 创建列表框控件
mylist = tk.Listbox(top,xscrollcommand = sbar2.set,yscrollcommand = sbar1.set)

for i in range(30):
    mylist.insert(tk.END,'第'+ str(i+1)+'次:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' )

# 当窗口改变大小时会在X与Y方向填满窗口
mylist.pack(side=tk.LEFT,fill = tk.BOTH)

# 使用 command 关联控件的 yview、xview方法
sbar1.config(command =mylist.yview)
sbar2.config(command = mylist.xview)
# -----------------------------------------------------------------

top.mainloop()

image-20220720183810817

事件处理

bind使用说明

格式

1
bind("事件码",要处理函数)
事件码 说明
单击鼠标左键，简写为，后面的数字可以是1/2/3，分别代表左键、中间滑轮、右键
释放鼠标左键，后面数字可以是1/2/3，分别代表释放左键、滑轮、右键
按住鼠标左键移动，和分别表示按住鼠标滑轮移动、右键移动
转动鼠标滑轮
双击鼠标左键
鼠标光标进入控件实例
鼠标光标离开控件实例
按下键盘上的任意键
<KeyPress-字母>/<KeyPress-数字> 按下键盘上的某一个字母或者数字键
释放键盘上的按键
回车键，其他同类型键有///
空格键
/// 方向键
… 常用的功能键
组合键，再比如，表示用户同时点击 Ctrl + Shift + T
当控件获取焦点时候触发，比如鼠标点击输入控件输入内容，可以调用 focus_set() 方法使控件获得焦点
当控件失去焦点时激活，比如当鼠标离开输入框的时候
控件的发生改变的时候触发事件，比如调整了控件的大小等
当控件的状态从“激活”变为“未激活”时触发事件
当控件被销毁的时候触发执行事件的函数
当窗口或组件的某部分不再被覆盖的时候触发事件
当应用程序至少有一部分在屏幕中是可见状态时触发事件

Event事件对象

属性 说明
widget 发生事件的是哪一个控件
x,y 相对于窗口的左上角而言，当前鼠标的坐标位置
x_root,y_root 相对于屏幕的左上角而言，当前鼠标的坐标位置
char 用来显示所按键相对应的字符
keysym 按键名，比如 Control_L 表示左边的 Ctrl 按键
keycode 按键码，一个按键的数字编号，比如 Delete 按键码是107
num 1/2/3中的一个，表示点击了鼠标的哪个按键，按键分为左、中、右
width,height 控件的修改后的尺寸，对应着 事件
type 事件类型

bind监听键盘

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

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

# 添加一个按钮控件
lb=Label(top,text='请按键')

# 给按钮控件绑定事件，按下任意键，然后调用事件处理函数。注意，此处需要在英文状态下进行输入
lb.bind('<Key>',show_key)

# 设置按钮获取焦点
lb.focus_set()
lb.pack()
# -----------------------------------------------------------------

top.mainloop()

我按了一下ctrl

image-20220720185415430

鼠标事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------
# 定义事件函数，必须用event参数
def handleMotion(event):
    print('目前光标位置：x ='+ str(event.x)+';y='+str(event.y))

# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top, relief=tk.RAISED, borderwidth=2, width=300,height=200)
layout1.pack()

# 给鼠标控件绑定事件
layout1.bind('<Motion>',handleMotion)
# -----------------------------------------------------------------

top.mainloop()

image-20220720190130395

布局管理器

三种常用的布局管理器

方法 说明
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’。注意，单词小写时需要使用字符串格式，若为大写单词则不必使用字符串格式 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
# 和iapp的线性布局一样设置第一个布局
layout1=tk.Frame(top)
layout1.pack()
# -----------------------------------------------------------------
lb_red = Label(layout1,text="无敌寂寞",bg="Red",fg='#ffffff',relief=tk.GROOVE)
lb_red.pack(fill=tk.Y , # 参数值为 X/Y/BOTH/NONE，表示允许控件在水平/垂直/同时在两个方向上进行拉伸，比如当 fill = X 时，控件会占满水平方向上的所有剩余的空间
            ipadx='60px', # 设置用于控制组件之间的上下、左右的距离（外边距），单位为像素(p)，或者厘米(c)、英寸(i)
            pady='30px') #设置位置
# -----------------------------------------------------------------

top.mainloop()

image-20220720191939956

grid()

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Button
from tkinter import Label


# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')

# -----------------------------------------------------------------



# 设置一个按钮
li_grid=Button (top, text="无敌寂寞",bg='#D1EEEE')
li_grid.grid(row=1,column=1) # 位置

# 设置二个按钮
li_grid=Button (top, text="无敌寂寞",bg='#D1EEEE')
li_grid.grid(row=2,column=1)# 位置

# -----------------------------------------------------------------

top.mainloop()

image-20220720194611097

sticky对齐

　　sticky=N/S/E//W:顶端对齐/底端对齐/右对齐/左对齐

　　sticky=N+S：拉伸高度，使其在水平方向上顶端和底端都对齐

　　sticky=E+W，拉伸宽度，使其在垂直方向上左边界和右边界都对齐

　　sticky=N+S+E:拉伸高度，使其在水平方向上对齐，并将控件放在右边（当两个控件放在同一行同一列时效果明显）

sticky=W左对齐

登录演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# -*- coding:utf-8 -*-
import tkinter as tk



# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
top.resizable(0,0)


# -----------------------------------------------------------------
def lea():
    if uer.get() == 'admin' and passwd.get() == 'admin' :
        print("登录成功")
    else:
        print("失败")

# 生成动态字符串
passwd = tk.StringVar()
# 生成动态字符串
uer = tk.StringVar()

tk.Label(top,text="用户登录界面").grid(row=1, column=2)

tk.Label(top, text="用户名").grid(row=2,
                                column=1,#　位置
                                sticky="w") # 不设置w默认是在中间

tk.Entry(top,textvariable=uer).grid(row=2, column=2)

tk.Label(top, text="密码").grid(row=2,
                          column=3,#　位置
                          sticky="w") # 不设置w默认是在中间

tk.Entry(top,textvariable=passwd).grid(row=2, column=4)

tk.Button(top,text="点击登录",command=lea).grid(row=3, column=2)

# -----------------------------------------------------------------

top.mainloop()

image-20220720200631583

place()

place()属性

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label
from tkinter import Button

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
top.resizable(0, 0)

# -----------------------------------------------------------------
# 演示1
# 字
Label1 = Label(top, text="无敌寂寞", bg='blue')

# 使用 place,设置第一个标签位于距离窗体左上角的位置（40,40）和其大小（width，height）
Label1.place(x=40,  # 位置
             y=40,  # 位置
             width=60,  # 大小
             height=30)

# 演示2
# 按钮
# 设置一个按钮
li_grid = Button(top, text="无敌寂寞", bg='#D1EEEE')
li_grid.place(x=100,  # 位置
              y=100)  # 位置
# -----------------------------------------------------------------

top.mainloop()

image-20220720202402665

Frame布局管理控件

这个布局就是和iapp是一样的

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 键将焦点转移上来） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label
from tkinter import Button

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
top.resizable(0, 0)

# -----------------------------------------------------------------
# 在主窗口上添加第一个布局
frame1 = tk.Frame(top)
frame1.pack()

# 在第一个布局在添加一个布局
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)
# -----------------------------------------------------------------

top.mainloop()

image-20220720202935839

LabelFrame控件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import Label
from tkinter import Button

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')
top.resizable(0, 0)

# -----------------------------------------------------------------
# 定义第一个容器，使用 labelanchor ='w' 来设置标题的方位
frame_left = tk.LabelFrame(top, 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)
# -----------------------------------------------------------------


top.mainloop()

image-20220720203234276

PanedWindow控件

语法

1
PanedWindow(master=None, **options)
属性 说明
handlepad 1. 调节“手柄”的位置 2. 比如当 orient =’vertical’ 设置垂直时，handlepad 表示“分割线”上的手柄与左端的距离，默认为 8 像素
handlesize 设置“手柄”的尺寸（由于“手柄”必须是一个正方形，所以是设置正方形的边长）默认为 8 像素
opaqueresize 1. 该选项定义了用户调整窗格尺寸的操作，如果该选项的值为 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) 将指定的分割线移动到一个新的位置

filedailog文件选择对话框

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

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

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

获得上传的文件路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
import tkinter as tk
from tkinter import filedialog  # 注意次数要将文件对话框导入

# 调用Tk()创建主窗口
top = tk.Tk()
top.geometry('450x450+100+100')
# 给主窗口起一个名字，也就是窗口的名字
top.title('赵赛赛')


# -----------------------------------------------------------------

# 定义一个处理文件的相关函数
def askfile():

    #从本地选择一个文件，并返回文件的目录
    filename = filedialog.askopenfilename()
    print(filename)

# 添加按钮
btn=tk.Button(top,text='选择文件',relief=tk.RAISED,command=askfile)
btn.grid(row=0,column=0)
# -----------------------------------------------------------------


top.mainloop()

image-20220720210643137