python3基础知识复习 --TKinter GUI的终极选择(2)_tkinter state

事件绑定

一个 Tkinter 应用程序大部分时间花费在事件循环中（通过 mainloop() 方法进入）。事件可以有各种来源：包括用户触发的鼠标和键盘操作和窗口管理器触发的重绘事件（在多数情况下是由用户间接引起的）。Tkinter 提供一个强大的机制可以让你自由地处理事件，对于每个组件来说，你可以通过 bind() 方法将函数或方法绑定到具体的事件上

widget.bind(event, handler)

当被触发的事件满足该组件绑定的事件时，Tkinter 就会带着事件对象（Event）去调用 handler() 方法。

eg: 我们使用 Frame 组件的 bind() 方法将鼠标点击事件（<Button-1>）和我们自定义的 callback() 方法绑定起来。那么运行后的结果是——当你在点击鼠标左键的时候，IDLE 会相应的将鼠标的位置显示出来(event.x, event.y)

只有当组件获得焦点的时候才能接收键盘事件（Key），下边例子中我们用 focus_set() 获得焦点，当你你可以设置 Frame 的 takefocus 选项为 True，然后使用 Tab 将焦点转移上来。(敲击位置 repr(event.char))

下方主要内容：

• *事件序列
• *type
• *modifier
• *Event 对象
• *Key names

事件序列

Tkinter 使用一种称为事件序列的机制来允许用户定义事件，用户需使用 bind() 方法将具体的事件序列与自定义的方法相绑定。

<modifier-type-detail>

• 事件序列是包含在尖括号（<…>）中
• type 部分的内容是最重要的，它通常用于描述普通的事件类型，例如鼠标点击或键盘按键点击（详见下方）。
• modifier 部分的内容是可选的，它通常用于描述组合键，例如 Ctrl + c，Shift + 鼠标左键点击（详见下方）。
• detail 部分的内容是可选的，它通常用于描述具体的按键，例如 Button-1 表示鼠标左键。
  EG:

type

modifier

在事件序列中，modifier 部分的内容可以是以下这些：

Event 对象

当 Tkinter 去回调你定义的函数的时候，都会带着 Event 对象（作为参数）去调用，Event 对象以下这些属性你可以使用：

Key names

当事件为 <Key>，<KeyPress>，<KeyRelease> 的时候，detail 可以通过设定具体的按键名（keysym）来筛选。例如 <Key-H> 表示按下键盘上的大写字母 H 时候触发事件，<Key-Tab> 表示按下键盘上的 Tab 按键的时候触发事件。

下表列举了键盘所有特殊按键的 keysym 和 keycode：

（下边按键码是对应美国标准 101 键盘的“Latin-1”字符集，键盘标准不同对应的按键码不同，但按键名是一样的）

Message

Label组件变体用于显示多行文本并能自动换行调整文本尺寸使之适应给定尺寸

通常用于显示简单的文本消息，可以用label代替，显示复杂文本建议用text组件。

参数和方法和label差不多。

root = Tk()

w1 = Message(root, text=“This is a pretty long message, you need wrap it”, width=100)

w1.pack()

Spinbox

Entry组件变体，用于从固定值中选择一个，通常用于在限定数字中选取的情况下代替普通的 Entry 组件。

Spinbox 组件跟 Entry 组件用法非常相似，主要区别是使用 Spinbox 组件，你可以通过范围或者元组指定允许用户输入的内容。

PanedWindow

和Frame组件类似的空间管理组件， 但是可以自定义布局允许让用户调整应用程序的空间划分。该组件会为每一个子组件生成一个独立地窗格，用户可以自由调整窗格的大小。

不需要创建root窗口，采用add()方法将其他组件放进去

m = PanedWindow(orient=VERTICAL)

m.pack(fill=BOTH, expand=1)

Toplevel

类似root窗口,属于顶级窗口拥有标题，边框等组件，通常用在显示额外的窗口、对话框和其他弹出窗口上。

EG:

	from tkinter import *
	 
	root = Tk()
	 
	# Message组件
	m = Message(root, text='This is a very important message, so sit down and listen to me!', width=100)
	m.pack()
	 
	# Spinbox组件
	Spinbox(root, from_=0, to=10, wrap=True, increment=2).pack(side='left') # 允许内容循环
	Spinbox(root, from_=0, to=10, values=('East', 'West', 'South', 'North')).pack(side='right')
	 
	# PanedWindow组件
	p1 = PanedWindow(showhandle=True, sashrelief=SUNKEN) # 显示句柄和轮廓线
	p1.pack(fill=BOTH, expand=1)
	left = Label(p1, text='left side')
	p1.add(left)
	 
	p2 = PanedWindow(orient=VERTICAL, showhandle=True, sashrelief=SUNKEN)
	p1.add(p2)
	 
	top = Label(p2, text='TOP RIGHT')
	bottom = Label(p2, text='BOTTOM RIGHT')
	p2.add(top)
	p2.add(bottom)
	 
	# Toplevel组件
	def create_tl():
	    tl = Toplevel()
	    tl.attributes('-alpha', 0.5) # 设置透明度50%
	    tl.title('Toplevel Demo')
	    Message(tl, text='This is a prompt by toplevel').pack()
	    
	Button(root, text='Create Toplevel', command=create_tl).pack()
	 
	mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

下边这一系列方法用于与窗口管理器进行交互。他们可以被 Tk（根窗口）进行调用，同样也适用于 Toplevel（顶级窗口）。

注：并非所有操作系统均完全支持下方所有方法的实现。

*aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)

– 控制该窗口的宽高比（width:height）

– 宽高比限制在：minNumer / minDenom ~ maxNumer / maxDenom

– 如果忽略参数，则返回一个 4 元组表示当前的限制（如果有的话）

*attributes(*args)

– 设置和获取窗口属性

– 如果你只给出选项名，将返回当前窗口该选项的值

– 注意：以下选项不支持关键字参数，*你需要在选项前添加横杠（-）并用字符串的方式表示，用逗号（,）隔开选项和值。

– 例如你希望设置窗口的透明度为 50%，你应该使用 **attribute(“-alpha”, 0.5)代替 attribute(alpha=0.5)

– 下方表格列举了 args 可以使用各个选项的具体含义及用法：

lient(name=None)

– 设置和获取 WM_CLIENT_MACHINE 属性

– 如果要删除 WM_CLIENT_MACHINE 属性，赋值为空字符串即可

– 该属性仅支持 X 窗口系统的窗口管理器，其他系统均忽略

olormapwindows(*wlist)

– 设置和获取 WM_COLORMAP_WINDOWS 属性

– 该属性仅支持 X 窗口系统的窗口管理器，其他系统均忽略

ommand(value=None)

– 设置和获取 WM_COMMAND 属性

– 该属性仅支持 X 窗口系统的窗口管理器，其他系统均忽略

deiconify()

– 显示窗口

– 默认情况下新创建的窗口都会显示在屏幕上，但使用 iconify() 或 withdraw() 方法可以在屏幕上移除窗口

*focusmodel(model=None)

– 设置和获取焦点模式

*frame()

– 返回一个字符串表示当前系统特征

– 对于类 Unix 系统，返回值是 X 窗口标识符

– 对于 Windows 系统，返回值是 HWND 强制转换为长整形的结果

*geometry(geometry=None)

– 设置和获取窗口的尺寸

– geometry 参数的格式为：“%dx%d+%d+%d” % (width, height, xoffset, yoffset)

*grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)

– 通知窗口管理器该窗口将以网格的形式重新调整尺寸

– baseWidth 和 baseHeight 指定 Tk_GeometryRequest 要求的网格单元数

– widthInc 和 heightInc 指定网格单元的宽度和高度（像素）

*group(window=None)

– 将窗口添加到窗口群中

– window 参数指定控制窗口群的主窗口

– 如果忽略该参数，将返回当前窗口群的主窗口

*iconbitmap(bitmap=None, default=None)

– 设置和获取窗口的图标

– 例如 root.iconbitmap(bitmap=“FishC.ico”)

– default 参数可以用于指定由该窗口创建的子窗口的默认图标

*iconify()

– 将窗口图标化（最小化）

– 需要重新显示窗口，使用 deiconify() 方法

– 该方法会使得 state() 返回 “iconic”

*iconmask(bitmap=None)

– 设置和获取位图掩码

*iconname(newName=None)

– 设置和获取当窗口图标化（最小化）时的图标名字

*iconposition(x=None, y=None)

– 设置和获取当窗口图标化（最小化）时的图标位置

*iconwindow(pathName=None)

– 设置和获取当窗口图标化（最小化）时的组件窗口

– 该方法会使得 state() 返回 “icon”

*maxsize(width=None, height=None)

– 设置和获取该窗口的最大尺寸

*minsize(width=None, height=None)

– 设置和获取该窗口的最小尺寸

*overrideredirect(boolean=None)

– 如果参数为 True，该窗口忽略所有的小部件（也就是说该窗口将没有传统的标题栏、边框等部件）

positionfrom(who=None)

– 指定窗口位置由“谁”决定

– 如果 who 参数是 “user”，窗口位置由用户决定

– 如果 who 参数是 “program”，窗口位置由系统决定

protocol(name=None, func=None)

– 将回调函数 func 与相应的规则 name 绑定

– name 参数可以是 “WM_DELETE_WINDOW”：窗口被关闭的时候

– name 参数可以是 “WM_SAVE_YOURSELF”：窗口被保存的时候

– name 参数可以是 “WM_TAKE_FOCUS”：窗口获得焦点的时候

*resizable(width=None, height=None)

– 指定是否可以改变该窗口的尺寸

– width 为 True 说明允许调整窗口的水平尺寸

– height 为 True 说明允许调整窗口的垂直尺寸

*sizefrom(who=None)

– 指定窗口尺寸由“谁”决定

– 如果 who 参数是 “user”，窗口位置由用户决定

– 如果 who 参数是 “program”，窗口位置由系统决定

*state(newstate=None)

– 设置和获得当前窗口的状态

– newstate 的值可以是 “normal”，“iconic”（见 iconify），“withdrawn”（见 withdraw），“icon”（见 iconwindow）和 “zoomed”（放大，Windows 特有）

*title(string=None)

– 设置窗口的标题

*transient(master=None)

– 指定为 master 的临时窗口

*withdraw()

– 将窗口从屏幕上移除（并没有销毁）

– 需要重新显示窗口，使用 deiconify() 方法

– 该方法会使得 state() 返回 “withdrawn”

Tkinter布局管理

pack, grid, place 均用于管理同在一个父组件下的所有组件的布局，其中：

• pack 是按添加顺序排列组件
• grid 是按行/列形式排列组件
• place 则允许程序员指定组件的大小和位置

Pack:

pack 更适用于少量组件的排列, 使用上比较简单，构建复杂布局可以添加Frame组件或者直接使用grid组件。

注意：不要在同一个父组件中混合使用 pack 和 grid，因为 Tkinter 会很认真地在那儿计算到底先使用那个布局管理器…以至于你等了半个小时，Tkinter 还在那儿纠结不出结果！

pack(**options)

– 下方表格详细列举了各个选项的具体含义和用法：

EG:

Label(root, text='RED', bg='red', fg='white').pack(fill=X, expand=True)
Label(root, text='GREEN', bg='green', fg='black').pack(fill=X, expand=True)
Label(root, text='BLUE', bg='blue', fg='white').pack(fill=X, expand=True)

Label(root, text='RED', bg='red', fg='white').pack(side=LEFT, expand=True)
Label(root, text='GREEN', bg='green', fg='black').pack(side=LEFT, expand=True)
Label(root, text='BLUE', bg='blue', fg='white').pack(side=LEFT, expand=True)
1
2
3
4
5
6
7

---

Grid:

最灵活最值得学习的布局组件，设计对话框so easy!

使用 grid 排列组件，只需告诉它你想要将组件放置的位置（行/列，row 选项指定行，cloumn 选项指定列）。此外，你并不用提前指出网格（grid 分布给组件的位置称为网格）的尺寸，因为管理器会自动计算。

默认情况下组件会居中显示在对应的网格里，你可以使用 sticky 选项来修改这一特性。eg: sticky=W 左对齐

rowspan 和 columnspan 就可以实现跨行和跨列的功能，是的几个网格只放一个组件

– 下方表格详细列举了各个选项的具体含义和用法：

*grid_bbox(column=None, row=None, col2=None, row2=None)

– 返回一个 4 元组描述该组件所在的限定矩形-- 如果指定 column 和 cow 参数，则返回该位置（column, cow）的组件的限定矩形描述

– 如果指定 4 个参数，则返回从（column, cow）到（col2, row2）所有组件的限定矩形描述

– 例如 grid_bbox(0, 0, 1, 1) 返回的是 4 个组件所在的限定矩形

*grid_columnconfigure(index, **options)

– 设置列的属性

– 注意：设置的是该组件所拥有的 grid 的列

– 可以设置的选项及含义如下：

*grid_forget()

– 将组件从屏幕中“删除”

– 并没有销毁该组件，只是看不到了

– 可以通过 grid 或其他布局管理器显示已“删除”的组件，但该组件所在网格的选项设置不会恢复

*grid_info()

– 以字典的形式返回当前 grid 的选项

*grid_location(x, y)

– 返回位于（或接近）给定坐标（x, y）的网格位置

– 返回值是一个 2 元组表示网格对应的（列，行）

*grid_propagate(flag)

– 如果开启，父组件会自动调节尺寸以容纳所有子组件

– 默认值是开启（flag = True）

– 该方法仅适用于父组件

*grid_remove()

– 跟 grid_forget() 一样，但恢复的时候会记住该组件所在网格的选项设置

*grid_rowconfigure(index, **options)

– 设置行的属性

– 注意：设置的是该组件所拥有的 grid 的行

– 可以设置的选项及含义如下：

*grid_size()

– 返回该组件所拥有的 grid 的尺寸

– 返回值是一个 2 元组，表示（列, 行）分别的网格数

*grid_slaves(row=None, column=None)

– 以列表的形式返回该组件的所有子组件

– 该方法仅适用于父组件

EG:

Label(root, text='ACCOUNT',).grid(row=0, column=0,sticky=W)
Label(root, text='PASSWORD').grid(row=1, column=0,sticky=W)
Entry(root).grid(row=0, column=1)
Entry(root, show='*').grid(row=1, column=1)
Button(root, text='SUBMIT').grid(columnspan=2)
1
2
3
4
5

---

Place

一般不用，特殊情况有妙用, eg:子组件显示在父组件中间，一个组件覆盖另一个组件

EG:

Label(root, bg='red').place(relx=0.5, rely=0.5, relheight=0.75, relwidth=0.75, anchor=CENTER)

Label(root, bg='yellow').place(relx=0.5, rely=0.5, relheight=0.5, relwidth=0.5, anchor=CENTER)

Label(root, bg='blue').place(relx=0.5, rely=0.5, relheight=0.25, relwidth=0.25, anchor=CENTER)
1
2
3
4
5

上图无论你如何拉伸改变窗口，三个 Label 的尺寸均会跟着改变（神同步~）。x 和 y 选项用于设置偏移（像素），如果同时设置 relx（rely）和 x（y），那 place 将优先计算 relx 和 rely，然后再实现 x 和 y 指定的偏移值。

– 下方表格详细列举了各个选项的具体含义和用法：

place_forget()

– 将组件从屏幕中“删除”

– 并没有销毁该组件，只是看不到了

– 可以通过 place 或其他布局管理器显示已“删除”的组件

place_info()

– 以字典的形式返回当前 place 的选项

place_slaves()

– 以列表的形式返回该组件的所有子组件

– 该方法仅适用于父组件

17）标准对话框

Tkinter 为了提供了三种标准对话框模块，它们分别是(以前是独立模块，现在全在tkinter下面了)：

• messagebox
• filedialog
• colorchooser
  使用时依然要使用from tkinter import messagebox, filedialog, colorchooser

messagebox（消息对话框）

下表为你列出了使用 messagebox 可以创建的所有标准对话框样式：

参数

所有的这些函数都有相同的参数：

• title 参数毋庸置疑是设置标题栏的文本
• message 参数是设置对话框的主要文本内容，你可以用 ‘\n’ 来实现换行
• options 参数可以设置的选项和含义如下表所示

返回值

askokcancel()，askretrycancel() 和 askyesno() 返回布尔类型的值：

• 返回 True 表示用户点击了“确定”或“是”按钮
• 返回 False 表示用户点击了“取消”或“否”按钮

askquestion() 返回“yes”或“no”字符串表示用户点击了“是”或“否”按钮

showerror()，showinfo() 和 showwarning() 返回“ok”表示用户按下了“是”按钮

filedialog（文件对话框）

当你的应用程序需要使用打开文件或保存文件的功能时，文件对话框显得尤为重要。

实现起来就是这样：

from tkinter import *
root = Tk()
def callback():
    fileName = filedialog.askopenfilename()
    print(fileName)
Button(root, text="Open File", command=callback).pack()
mainloop()
1
2
3
4
5
6
7

filedialog 模块提供了两个函数：askopenfilename(**option) 和 asksaveasfilename(**option)，分别用于打开文件和保存文件。

参数

两个函数可供设置的选项是一样的，下边列举了可用的选项及含义：

返回值

1. 如果用户选择了一个文件，那么返回值是该文件的完整路径

2. 如果用户点击了取消按钮，那么返回值是空字符串

olorchooser（颜色选择对话框）*

颜色选择对话框提供一个友善的界面让用户选择需要的颜色，大家看下例子：

from tkinter import 
root = Tk()
def callback():
  fileName = colorchooser.askcolor()
  print(fileName)

Button(root, text="choose color", command=callback).pack()
mainloop()
1
2
3
4
5
6
7
8

参数

askcolor(color, **option) 函数的 color 参数用于指定初始化的颜色，默认是浅灰色；

option 参数可以指定的选项及含义如下：

返回值

1. 如果用户选择一个颜色并按下“确定”按钮后，返回值是一个 2 元祖，第 1 个元素是选择的 RGB 颜色值，第 2 个元素是对应的 16 进制颜色值

2. 如果用户按下“取消”按钮，那么返回值是 (None, None)

Tkinter使用多线程

为什么要使用多线程 ==> python之Tkinter使用详解_檬柠wan的博客-CSDN博客_python tkinter

• 以下为单线程运行

      def interface(self):
          """"界面编写位置"""
          self.Button0 = tk.Button(self.root, text="确定", command=self.event)
          self.Button0.grid(row=0, column=0)
  
          self.w1 = tk.Text(self.root, width=80, height=10)
          self.w1.grid(row=1, column=0)
  
      def event(self):
          '''按钮事件，一直循环'''
          a = 0
          while True:
              a += 1
              self.w1.insert(1.0, str(a)+'\n')
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

  单线程下，主线程需要运行窗口，如果这个时候点击“确定”按钮，主线程就会去执行event方法，那界面就会出现“无响应”状态，如果要界面正常显示，那我们就需要用到多线程(threading)

  

• 多线程，完整代码

  import tkinter as tk
  import threading  # 导入多线程模块
  
  
  class GUI:
  
      def __init__(self):
          self.root = tk.Tk()
          self.root.title('演示窗口')
          self.root.geometry("500x200+1100+150")
          self.interface()
  
      def interface(self):
          """"界面编写位置"""
          self.Button0 = tk.Button(self.root, text="确定", command=self.start)
          self.Button0.grid(row=0, column=0)
  
          self.w1 = tk.Text(self.root, width=80, height=10)
          self.w1.grid(row=1, column=0)
  
      def event(self):
          '''按钮事件，一直循环'''
          a = 0
          while True:
              a += 1
              self.w1.insert(1.0, str(a)+'\n')
  
      def start(self):
          self.T = threading.Thread(target=self.event)  # 多线程
          self.T.setDaemon(True)  # 线程守护，即主进程结束后，此线程也结束。否则主进程结束子进程不结束
          self.T.start()  # 启动
  
  
  if __name__ == '__main__':
      a = GUI()
      a.root.mainloop()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36

  Tkinter多线程暂停和继续

  import tkinter as tk
  import threading
  from time import sleep
  
  event = threading.Event()
  
  
  class GUI:
  
      def __init__(self):
          self.root = tk.Tk()
          self.root.title('演示窗口')
          self.root.geometry("500x200+1100+150")
          self.interface()
  
      def interface(self):
          """"界面编写位置"""
          self.Button0 = tk.Button(self.root, text="启动", command=self.start)
          self.Button0.grid(row=0, column=0)
  
          self.Button0 = tk.Button(self.root, text="暂停", command=self.stop)
          self.Button0.grid(row=0, column=1)
  
          self.Button0 = tk.Button(self.root, text="继续", command=self.conti)
          self.Button0.grid(row=0, column=2)
  
          self.w1 = tk.Text(self.root, width=70, height=10)
          self.w1.grid(row=1, column=0, columnspan=3)
  
      def event(self):
          '''按钮事件，一直循环'''
          while True:
              sleep(1)
              event.wait()
              self.w1.insert(1.0, '运行中'+'\n')
  
      def start(self):
          event.set()
          self.T = threading.Thread(target=self.event)
          self.T.setDaemon(True)
          self.T.start()
  
      def stop(self):
          event.clear()
          self.w1.insert(1.0, '暂停'+'\n')
  
      def conti(self):
          event.set()
          self.w1.insert(1.0, '继续'+'\n')
  
  
  if __name__ == '__main__':
      a = GUI()
      a.root.mainloop()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54

Tkinter文件之间的调用

• 准备工作

  • a.py文件 - -界面逻辑+线程
  • b.py 文件 - -业务逻辑
  • 以上文件在同一个目录下

• 方法

  # a.py 文件
  import tkinter as tk
  import threading
  from b import logic  # 调用b文件中的logic类
  
  
  class GUI:
      def __init__(self):
          self.root = tk.Tk()
          self.root.title('演示窗口')
          self.root.geometry("500x260+1100+150")
          self.interface()
  
      def interface(self):
          """"界面编写位置"""
          self.Button0 = tk.Button(self.root, text="确定执行", command=self.start, bg="#7bbfea")
          self.Button0.grid(row=0, column=1, pady=10)
  
          self.entry00 = tk.StringVar()
          self.entry00.set("")
  
          self.entry0 = tk.Entry(self.root, textvariable=self.entry00)
          self.entry0.grid(row=1, column=1, pady=15)
  
          self.w1 = tk.Text(self.root, width=50, height=8)
          self.w1.grid(row=2, column=0, columnspan=3, padx=60)
  
      def seal(self):
          '''把b文件的类单独写一个方法'''
          a = self.entry00.get()
          w1 = self.w1
          logic().event(a, w1)
  
      def start(self):
          '''子线程无法直接执行b的类，需要把b文件单独写一个方法，然后执行'''
          self.T = threading.Thread(target=self.seal)
          self.T.setDaemon(True)
          self.T.start()
  
  
  if __name__ == '__main__':
      a = GUI()
      a.root.mainloop()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43

  # b.py 文件
  import time
  
  
  class logic():
      def __init__(self):
          pass
  
      def main(self, a, x):
          while True:
              y = int(a)+int(x)
              self.w1.insert(1.0, str(y)+'\n')
              time.sleep(1)
              x += 1
  
      def event(self, a, w1):
          '''调用main的方法'''
          self.w1 = w1
          x = 1
          self.main(a, x)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20