基于tkinter的GUI编程

tkinter：tkinter是绑定了python的tkgui工具集，就是python包装的tcl代码，通过内嵌在python解释器内部的tcl
解释器实现的，它是python标准库的一部分，所以使用它进行gui编程不需要另外安装第三方库的。

tkinter的简单使用：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                       #导入tkinter模块
 3 
 4 root = tkinter.tk()                                  #生成root主窗口
 5 label = tkinter.label(root,text = "hello,tkinter!")  #生成标签
 6 label.pack()                                         #将标签添加到root主窗口
 7 button1 = tkinter.button(root,text = "button1")      #生成button1
 8 button1.pack(side = tkinter.left)                    #将button1添加到root主窗口
 9 button2 = tkinter.button(root,text = "button2")      #生成button2
10 button2.pack(side = tkinter.right)                   #将button2添加到root主窗口
11 root.mainloop()                                      #进入信息循环

tkinter组件：

布局组件：
组件pack方法参数设置组件的位置：
before：将组件置于其他之间之前；
after：将组件置于其他组件之后；
side：组件在主窗口的位置，可以为“top”、“bottom”、“left”、“right”；
anchor：组件的对齐方式，顶对齐“n”、底对齐“s”、左对齐“w”、右对齐“e”；

组件anchor方法参数通过行列的方法设置组件的位置：
column：组件所在的列起始位置；
columspam：组件的列宽；
row：组件所在的行起始位置；
rowspam：组件的行宽；

组件place方法参数通过坐标来设置组件的位置：

常用tkinter组件：
按钮：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                       #导入tkinter模块
 3 
 4 root = tkinter.tk()                                  #生成root主窗口
 5 label = tkinter.label(root,text = "hello,tkinter!")  #生成标签
 6 label.pack()                                         #将标签添加到root主窗口
 7 button1 = tkinter.button(root,
 8                          anchor = tkinter.e,         #指定文本对齐方式
 9                          text = "button1",           #指定按钮上的文本
10                          width = 40,                 #指定按钮的宽度，相当于40个字符
11                          height = 5)                 #指定按钮的高度，相当于5行字符
12 button1.pack()                                       #将按钮添加到窗口
13 button2 = tkinter.button(root,
14                          text = "button2",
15                          bg = "blue")                #指定按钮的背景颜色
16 button2.pack()   
17 button3 = tkinter.button(root,
18                          text = "button1",
19                          width = 60,
20                          height = 5,
21                          state = tkinter.disabled)   #指定按钮为禁用状态
22 button3.pack()
23 root.mainloop()                                      #进入信息循环

文本框：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                       #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 entry1 = tkinter.entry(root,                         #生成单行文本框组件
 6                        show = '*')                   #输入文本框中的字符被显示为“*”
 7 entry1.pack()                                        #将文本框添加到窗口中
 8 entry2 = tkinter.entry(root,
 9                        show = '#',                   #输入文本框中的字符被显示为“#”
10                        width = 50)                   #将文本框的宽度设置为50
11 entry2.pack()
12 entry3 = tkinter.entry(root,
13                        bg = 'red',                   #将文本框的背景色设置为红色
14                        fg = 'blue')                  #将文本框的前景色设置为蓝色
15 entry3.pack()
16 entry4 = tkinter.entry(root,
17                        selectbackground = 'red',     #将选中文本的背景色设置为红色
18                        selectforeground = 'gray')    #将选中文本的前景色设置为灰色
19 entry4.pack()
20 entry5 = tkinter.entry(root,
21                        state = tkinter.disabled)     #将文本框设置为禁用
22 entry5.pack()
23 edit1 = tkinter.text(root,                           #生成多行文本框组件
24                      selectbackground='red',         #将选中文本的背景色设置为红色
25                      selectforeground='gray')        #将选中文本的前景色设置为灰色
26 edit1.pack()
27 root.mainloop()                                      #进入信息循环

标签：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                        #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 label1 = tkinter.label(root,
 6                        anchor = tkinter.e,            #设置文本的位置
 7                        bg = 'blue',                   #设置标签背景色
 8                        fg = 'red',                    #设置标签前景色
 9                        text = 'python',               #设置标签中的文本
10                        width = 30,                    #设置标签的宽度为30
11                        height = 5)                    #设置标签的高度为5
12 label1.pack()
13 label2 = tkinter.label(root,
14                        text = 'python gui\ntkinter',  #设置标签中的文本，在字符串中使用换行符
15                        justify = tkinter.left,        #设置多行文本为左对齐
16                        width = 30,
17                        height = 5)
18 label2.pack()
19 label3 = tkinter.label(root,
20                        text = 'python gui\ntkinter',
21                        justify = tkinter.right,       #设置多行文本为右对齐
22                        width = 30,
23                        height = 5)
24 label3.pack()
25 label4 = tkinter.label(root,
26                        text = 'python gui\ntkinter',
27                        justify = tkinter.center,      #设置多行文本为居中对齐
28                        width = 30,
29                        height = 5)
30 label4.pack()
31 root.mainloop()

菜单：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                        #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 menu = tkinter.menu(root)                             #生成菜单
 6 submenu = tkinter.menu(menu,tearoff = 0)              #生成下拉菜单
 7 submenu.add_command(label = 'open')                   #向下拉菜单中添加open命令
 8 submenu.add_command(label = 'save')                   #向下拉菜单中添加save命令
 9 submenu.add_command(label = 'close')                  #向下拉菜单中添加close命令
10 menu.add_cascade(label = 'file',menu = submenu)       #将下拉菜单添加到菜单中
11 submenu = tkinter.menu(menu,tearoff = 0)              #生成下拉菜单
12 submenu.add_command(label = 'copy')                   #向下拉菜单中添加copy命令
13 submenu.add_command(label = 'paste')                  #向下拉菜单中添加paste命令
14 submenu.add_separator()                               #向下拉菜单中添加分隔符
15 submenu.add_command(label = 'cut')                    #向下拉菜单中添加cut命令
16 menu.add_cascade(label = 'edit',menu = submenu)       #将下拉菜单添加到菜单中
17 submenu = tkinter.menu(menu,tearoff = 0)              #生成下拉菜单
18 submenu.add_command(label = 'about')                  #向下拉菜单中添加about命令
19 menu.add_cascade(label = 'help',menu = submenu)       #将下拉菜单添加到菜单中
20 root.config(menu = menu)
21 root.mainloop()

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                            #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 menu = tkinter.menu(root,tearoff = 0)     #创建菜单
 6 menu.add_command(label = 'copy')          #向弹出式菜单中添加copy命令
 7 menu.add_command(label = 'paste')         #向弹出式菜单中添加paste命令
 8 menu.add_separator()                      #向弹出式菜单中添加分隔符
 9 menu.add_command(label = 'cut')           #向弹出式菜单中添加cut命令
10 def popupmenu(event):                     #定义右键事件处理函数
11     menu.post(event.x_root,event.y_root)  #显示菜单
12 root.bind('<button-3>',popupmenu)         #在主窗口中绑定右键事件
13 root.mainloop()

单选框和复选框：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                 #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 r = tkinter.stringvar()                        #使用stringvar生成字符串变量用于单选框组件
 6 r.set('1')                                     #初始化变量
 7 radio = tkinter.radiobutton(root,              #生成单选框组件
 8                             variable = r,      #设置单选框关联的变量
 9                             value = '1',       #设置选中单选框时其所关联的变量的值，即r的值
10                             indicatoron = 0,   #将单选框绘制成按钮样式
11                             text = 'radio1')   #设置单选框显示的文本
12 radio.pack()
13 radio = tkinter.radiobutton(root,
14                             variable = r,
15                             value = '2',
16                             indicatoron = 0,
17                             text = 'radio2')
18 radio.pack()
19 radio = tkinter.radiobutton(root,
20                             variable = r,
21                             value = '3',
22                             indicatoron = 0,
23                             text = 'radio3')
24 radio.pack()
25 radio = tkinter.radiobutton(root,
26                             variable = r,
27                             value = '4',
28                             indicatoron = 0,
29                             text = 'radio4')
30 radio.pack()
31 c = tkinter.intvar()                              #使用invar生成整型变量用于复选框
32 c.set(1)
33 check = tkinter.checkbutton(root,
34                             text = 'checkbutton', #设置复选框的文本
35                             variable = c,         #设置复选框关联的变量
36                             indicatoron = 0,      #将单选框绘制成按钮样式，不加为单选按钮
37                             onvalue = 1,          #当选中复选框时，c的值为1
38                             offvalue = 2)         #当未选中复选框时，c的值为2
39 check.pack()
40 root.mainloop()
41 print(r.get())                                    #输出r的值
42 print(c.get())                                    #输出c的值

绘图：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter                                    #导入tkinter模块
 3 
 4 root = tkinter.tk()
 5 canvas = tkinter.canvas(root,
 6                         width = 600,              #指定canvas组件的宽度为600
 7                         height = 480,             #指定canvas组件的高度为480
 8                         bg = 'white')             #指定canvas组件背景色为白色
 9 im = tkinter.photoimage(file = 'python.gif')      #使用photoimage打开图片
10 canvas.create_image(300,50,image = im)            #使用create_image将图片添加到canvas组件中
11 canvas.create_text(302,77,                        #使用create_text方法绘制文字
12                    text = 'use canvas',           #所绘制文字的内容
13                    fill = 'gray')                 #所绘制文字的颜色为灰色
14 canvas.create_text(300,75,
15                    text = 'use canvas',
16                    fill = 'blue')
17 canvas.create_polygon(290,114,316,114,330,130,    #使用create_polygon方法绘制六边形
18                       310,146,284,146,270,130)
19 canvas.create_oval(280,120,320,140,               #使用create_oval方法绘制椭圆形
20                    fill = 'white')                #设置椭圆用白色填充
21 canvas.create_line(250,130,350,130)               #使用create_line绘制直线
22 canvas.create_line(300,100,300,160)
23 canvas.create_rectangle(90,190,510,410,           #使用create_rectangle绘制一个矩形
24                         width = 5)                #设置矩形线宽为5像素
25 canvas.create_arc(100,200,500,400,                #使用create_arc绘制圆弧
26                   start = 0,extent = 240,         #设置圆弧的起止角度
27                   fill = 'pink')                  #设置圆弧填充颜色为粉丝
28 canvas.create_arc(103,203,500,400,
29                   start = 241,extent = 118,
30                   fill = 'red')
31 canvas.pack()                                     #将canvas添加到主窗口
32 root.mainloop()

事件：
鼠标事件、键盘事件、窗口事件，绑定事件的组件：
bind(sequence,func,add)
bind_class(classname,sequence,func,add)
bind_all(sequence,func,add)
参数含义：
sequence：所绑定的事件，必须以“<>”包围的字符串
func：所绑定的事件处理函数
add：可选参数，为空字符或者“+”
classname：所绑定的类
备注：鼠标事件数字1表示鼠标左键、2表示鼠标中键、3表示鼠标右键

键盘事件：

备注：keypress可以用keyrelease替换，表示当按键释放时触发事件。需要注意的是，输入的字母要区分大小写

窗口事件：

相应事件：
事件绑定到函数后，触发时系统将向该函数传递一个event对象的参数，event对象属性：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 
 4 class mybutton:                                                #定义按钮类
 5     def __init__(self,root,canvas,label,type):                 #类初始化
 6         self.root = root                                       #保存引用值
 7         self.cancas = canvas
 8         self.label = label
 9         if type == 0:                                          #根据类型创建按钮
10             button = tkinter.button(root,text = 'drawline',
11                                     command = self.drawline)
12         elif type == 1:
13             button = tkinter.button(root, text='drawarc',
14                                     command=self.drawarc)
15         elif type == 2:
16             button = tkinter.button(root, text='drawrec',
17                                     command=self.drawrec)
18         else:
19             button = tkinter.button(root, text='drawoval',
20                                     command=self.drawoval)
21         button.pack(side = 'left')
22     def drawline(self):                                       #drawline按钮事件处理函数
23         self.label.text.set('draw line')
24         self.cancas.setstatus(0)
25     def drawarc(self):                                        #drawarc按钮事件处理函数
26         self.label.text.set('draw arc')
27         self.cancas.setstatus(1)
28     def drawrec(self):                                        #drawrec按钮事件处理函数
29         self.label.text.set('draw rectangle')
30         self.cancas.setstatus(2)
31     def drawoval(self):                                       #drawoval按钮事件处理函数
32         self.label.text.set('draw oval')
33         self.cancas.setstatus(3)
34 class mycanvas:                                               #定义mycanvas类
35     def __init__(self,root):                                  #保存引用值
36         self.status = 0
37         self.draw = 0
38         self.root = root
39         self.canvas = tkinter.canvas(root,bg = 'white',       #生成canvas组件
40                                      width = 600,
41                                      height = 480)
42         self.canvas.pack()
43         self.canvas.bind('<buttonrelease-1>',self.draw)       #绑定事件到左键
44         self.canvas.bind('<button-2>',self.exit)              #绑定事件到中键
45         self.canvas.bind('<button-3>',self.del)               #绑定事件到右键
46         self.canvas.bind_all('<delete>',self.del)             #绑定事件到delete键
47         self.canvas.bind_all('<keypress-d>',self.del)         #绑定事件到d键
48         self.canvas.bind_all('<keypress-e>',self.exit)        #绑定事件到e键
49     def draw(self,event):                                     #绘制事件处理函数
50         if self.draw == 0:                                    #判断是否绘图
51             self.x = event.x
52             self.y = event.y
53             self.draw = 1
54         else:                                                 #根据self.status绘制不同的图形
55             if self.status == 0:
56                 self.canvas.create_line(self.x,self.y,
57                                         event.x,event.y)
58                 self.draw = 0
59             elif self.status == 1:
60                 self.canvas.create_arc(self.x, self.y,
61                                         event.x, event.y)
62                 self.draw = 0
63             elif self.status == 2:
64                 self.canvas.create_rectangle(self.x, self.y,
65                                         event.x, event.y)
66                 self.draw = 0
67             else:
68                 self.canvas.create_oval(self.x, self.y,
69                                         event.x, event.y)
70                 self.draw = 0
71     def del(self,event):                                     #按下右键或d键则删除图形
72         items = self.canvas.find_all()
73         for item in items:
74             self.canvas.delete(item)
75     def exit(self,event):                                    #按下中键或e键则退出
76         self.root.quit()
77     def setstatus(self,status):                              #设置绘制的图形
78         self.status = status
79 class mylabel:                                               #定义标签类
80     def __init__(self,root,canvas):                          #类初始化
81         self.root = root                                     #保存引用值
82         self.canvas = canvas
83         self.text = tkinter.stringvar()                      #生成标签引用变量
84         self.text.set('draw line')
85         self.label = tkinter.label(root,textvariable = self.text,  #生成标签
86                                    fg = 'red',width = 50)
87         self.label.pack(side = 'left')
88 root = tkinter.tk()                                          #生成主窗口
89 canvas = mycanvas(root)                                      #生成绘图组件
90 label = mylabel(root,canvas)                                 #生成标签
91 mybutton(root,canvas,label,0)                                #生成按钮
92 mybutton(root,canvas,label,1)
93 mybutton(root,canvas,label,2)
94 mybutton(root,canvas,label,3)
95 root.mainloop()                                              #进入信息循环

信息框：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 import tkinter.messagebox
 4 def cmd():                             #按钮信息处理
 5     global n                           #使用全局变量n
 6     global buttontext
 7     n = n + 1
 8     if n == 1:                         #判断n的值，显示不同的消息框
 9         tkinter.messagebox.askokcancel('python tkinter','askokcancel')
10         buttontext.set('skquestion')   #更改按钮上的文字
11     elif n == 2:
12         tkinter.messagebox.askquestion('python tkinter','askquestion')
13         buttontext.set('askyesno')
14     elif n == 3:
15         tkinter.messagebox.askyesno('python tkinter','askyesno')
16         buttontext.set('showerror')
17     elif n == 4:
18         tkinter.messagebox.showerror('python tkinter','showerror')
19         buttontext.set('showinfo')
20     elif n == 5:
21         tkinter.messagebox.showinfo('python tkinter','shoeinfo')
22         buttontext.set('showwarning')
23     else:
24         n = 0                        #将n赋值为0重新开始循环
25         tkinter.messagebox.showwarning('python tkinter','showwarning')
26         buttontext.set('askokcancel')
27 n = 0                                #为n赋初始值
28 root = tkinter.tk()
29 buttontext = tkinter.stringvar()     #生成关联按钮文字的变量
30 buttontext.set('askokcancel')        #设置buttontext值
31 button = tkinter.button(root,        #生成按钮
32         textvariable = buttontext,   #设置关联变量
33                     command = cmd)   #设置事件处理函数
34 button.pack()
35 root.mainloop()                      #进入信息循环

除了5种信息框，还可以使用tkinter.messagebox._show函数创建其他类型的信息框
tkinter.messagebox._show函数的控制参数：
default：指定信息框的按钮
icon：指定信息框的图标
message：指定信息框所显示的信息
parent：指定信息框的父组件
title：指定信息框的标题
type：指定信息框的类型

对话框：

tkinter.simpledialog模块可以创建标准的输入对话框
tkinter.simpledialog模块可以创建3中类型的对话框：
输入字符串、输入整数和输入浮点数的对话框，对应的函数为askstring、askinteger、和askfloat函数，可选参数有：
title：指定对话框标题
prompt：指定对话框中显示的文字
initiavalue：指定输入框的初始值
使用tkinter.simpledialog模块中的函数创建对话框后，将返回对话框中文本框的值

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 import tkinter.simpledialog
 4 def instr():                                                      #按钮事件处理函数
 5     r = tkinter.simpledialog.askstring('python tkinter',          #创建字符串输入对话框
 6                                        'input string',            #指定提示字符
 7                                        initialvalue = 'tkinter')  #指定初始化文本
 8     print(r)                                                      #输出返回值
 9 def inint():
10     r = tkinter.simpledialog.askinteger('python tkinter',
11                                        'input integer')
12     print(r)
13 def inflo():
14     r = tkinter.simpledialog.askfloat('python tkinter',
15                                        'input float')
16     print(r)
17 root = tkinter.tk()                                               #生成主窗口
18 button1 = tkinter.button(root,text = 'input string',              #创建按钮
19                          command = instr)                         #指定按钮事件处理函数
20 button1.pack(side = 'left')
21 button2 = tkinter.button(root,text = 'input integer',
22                          command = inint)
23 button2.pack(side = 'left')
24 button3 = tkinter.button(root,text = 'input float',
25                          command = inflo)
26 button3.pack(side = 'left')
27 root.mainloop()                                                   #进入信息循环

tkinter.filedialog模块可以创建文件打开与保存文件对话框
tkinter.filedialog模块中的askopenfilename函数可以创建打开文件对话框
tkinter.filedialog模块中的asksaveasfilename函数可以创建保存文件对话框，具有相同可先参数：
filetypes：指定文件类型
initialdir：指定默认目录
initialfile：指定默认文件
title：指定对话框标题
使用tkfiledialog模块中的函数创建对话框后，将返回文件的完整路径

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 import tkinter.filedialog
 4 def fileopen():                                                           #按钮事件处理函数
 5     r = tkinter.filedialog.askopenfilename(title = 'python tkinter',      #创建打开文件对话框
 6                 filetypes = [('python','*.py *.pyw'),('all files','*')])  #指定文件类型为python程序
 7     print(r)                                                              #输出返回值
 8 def filesave():                                                           #按钮事件处理函数
 9     r = tkinter.filedialog.asksaveasfilename(title = 'python tkinter',    #创建保存文件对话框
10                                              initialdir = r'f:\python',   #指定初始化目录
11                                              initialfile = 'test.py')     #指定初始化文件
12     print(r)
13 root = tkinter.tk()
14 button1 = tkinter.button(root,text = 'file open',                         #创建按钮
15                          command = fileopen)                              #指定按钮事件处理函数
16 button1.pack(side = 'left')
17 button2 = tkinter.button(root,text = 'file save',
18                          command = filesave)
19 button2.pack(side = 'left')
20 root.mainloop()                                                           #进入信息循环

tkinter.colorchooser模块可以创建颜色选择对话框
tkinter.colorchooser模块中的askcolor函数可以创建颜色选择对话框，可选参数：
initialcolor：指定初始化颜色
title：指定对话框标题
使用tkinter.colorchooser模块中的函数创建对话框后，将返回颜色的rgb值以及可以在python tkinter中使用的颜色字符值

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 import tkinter.colorchooser
 4 def choosecolor():                                                    #按钮事件处理函数
 5     r = tkinter.colorchooser.askcolor(title = 'python tkinter')       #创建颜色选择对话框
 6     print(r)                                                          #输出返回值
 7 root = tkinter.tk()                                                   #生成主窗口
 8 button = tkinter.button(root,text = 'choose color',                   #创建按钮
 9                         command = choosecolor)                        #指定按钮事件处理函数
10 button.pack()
11 root.mainloop()                                                       #进入信息循环

自定义对话框：
toplevel组件：

 1 #_*_ coding:utf-8 _*_
 2 import tkinter
 3 import tkinter.messagebox
 4 class mydialog:                                                    #定义对话框类
 5     def __init__(self,root):                                       #对话框初始化
 6         self.top = tkinter.toplevel(root)                          #生成toplevel组件
 7         label = tkinter.label(self.top,text = 'please input')      #生成标签组件
 8         label.pack()
 9         self.entry = tkinter.entry(self.top)                       #生成文本框组件
10         self.entry.pack()
11         self.entry.focus()                                         #让文本框获得焦点
12         button = tkinter.button(self.top,text = 'ok',              #生成按钮
13                                 command = self.ok)                 #设置按钮事件处理函数
14         button.pack()
15     def ok(self):                                                  #定义按钮事件处理函数
16         self.input = self.entry.get()                              #获取文本框中的内容，保存为input
17         self.top .destroy()                                        #销毁对话框
18     def get(self):                                                 #返回在文本框输入的内容
19         return self.input
20 class mybutton():                                                  #定义按钮类
21     def __init__(self,root,type):                                  #按钮初始化
22         self.root = root                                           #保存父窗口引用
23         if type == 0:                                              #根据类型创建不同按钮
24             self.button = tkinter.button(root,
25                                          text = 'create',
26                                          command = self.create)    #设置create按钮事件处理函数
27         else:
28             self.button = tkinter.button(root,
29                                          text = 'quit',
30                                          command = self.quit)      #设置quit按钮事件处理函数
31         self.button.pack()
32     def create(self):                                              #create按钮的事件处理函数
33         d = mydialog(self.root)                                    #生成对话框
34         self.button.wait_window(d.top)                             #等待对话框结束
35         tkinter.messagebox.showinfo('python','you input:\n' + d.get())  #获取对话框中输入值，并输出
36     def quit(self):                                                #quit按钮的事件处理函数
37         self.root.quit()                                           #退出主窗口
38 root = tkinter.tk()                                                #生成主窗口
39 mybutton(root,0)                                                   #生成create
40 mybutton(root,1)                                                   #生成quit按钮
41 root.mainloop()                                                    #进入信息循环