精华内容
下载资源
问答
  • 基本概念GUI - Graphical User Interface. 中文叫图形用户接口。...tkinter 是python自带的模块,在安装python的同时,tkinter模块就已经在系统里了。只需import导入,即可使用。tkinter模块并没有网...

    基本概念

    GUI - Graphical User Interface. 中文叫图形用户接口。图像用户接口可以看做为人与计算机之间的沟通媒介。

    如果想为自己写的程序做一个易于操作的界面,那么,tkinter应该是最容易上手的图形接口开发工具。

    tkinter 是python自带的模块,在安装python的同时,tkinter模块就已经在系统里了。只需import导入,即可使用。tkinter模块并没有网上说的那么差,只是官方编写的tkinter的文档很差劲。之后的一段时间,我会将tkinter模块的使用做一个详细的介绍。

    导入tkinter模块

    from tkinter import * 或者是 import tkinter as tk

    这是两种最常见的导入写法。

    from X import * 和 import X 的区别

    在导入python 模块的时候,很多时候我们都面临上述两种导入的选择。下面我将说明这两种方法的区别。

    import X

    import X 意味着创建了一个模块 X的引用。假设模块X里有一个函数方法 func(),如果想调用func,就需要使用完整的路径,例如 X.func();

    from X import *

    from X import * 意味着对模块X里的所有对象创建了引用。此时,如果想调用func,只需要使用func()即可。同时,由于你并没有创建X的引用,你将无法通过X.func()调用func方法。

    举个例子,模块X相当于姓氏,模块X里的对象相当于名。如果一个班两个 ’天天‘,一个叫陶天天,一个叫欧天天。那么,老师就需要加上姓去区分两个’天天‘。但是,如果班里只有一个孩子叫’天天‘,就只需要喊’天天‘就好。

    导入tkinter模块之后,可以使用TkVersion去查看tkinter模块的版本。

    import tkinter as tkprint(tk.TkVersion)Out[2]: 8.6

    创建窗口

    tkinter中的Tk() 方法可以创建一个根窗口,之后添加的控件将会被放进这个创建的窗口里。

    import tkinter as tkwindow = tk.Tk()window.mainloop()
    4b4cd50c4b5df39e799d571b0c18d536.png

    创建的窗口,取名window

    window.mainloop() 会启动创建的window GUI。

    窗口建立好,就需要进行一些相关的设置。比如窗口标题,图标,大小,底色等等。

    添加图标

    默认的图标是一片树叶,如上图左上角。自己建的窗口,自然想换上漂亮、大气的图标。tkinter提供了iconbitmap 方法来更换图标。如果想使用下图作为图标,我们只需要如下设置。

    967e7d1f7a42accc5c55eb50f504be4d.png

    图标

    import tkinter as tkwindow = tk.Tk()window.iconbitmap('palm-tree-icon.ico')window.mainloop()

    'palm-tree-icon.ico' 是图标存储的路径,如果图标在程序所在的文件夹里,可以直接调用。不然就得使用完整的路径。

    b1af824d5ba8bd0534dce23fcdbda463.png

    图标更改后的窗口

    设置标题

    默认的窗口标题是左上角的tk,通过title()可以设置窗口的标题。

    import tkinter as tkwindow = tk.Tk()window.title('逃学联盟')window.iconbitmap('palm-tree-icon.ico')window.mainloop()
    54fff8d2a44543bf2870bb501114cbe0.png

    标题更改后的窗口

    设置背景颜色

    使用configure()设置背景颜色,window.configure(bg='#008CBA')

    import tkinter as tkwindow = tk.Tk()window.title('逃学联盟')window.configure(bg='#008CBA')window.iconbitmap('palm-tree-icon.ico')window.mainloop()
    58b0c4aea563e1dca4effd4b4f32a7b2.png

    背景色设置后的窗口

    设置窗口大小和屏幕的相对位置

    geometry()可以用来设置初始窗口的大小以及窗口于屏幕的相对位置。注意,代码中的x不是乘法,是字母xy的x。具体方法如下:

    .geometry("窗口宽 x 窗口高 + 屏幕左边框相对距离 + 屏幕上边框相对距离")。

    import tkinter as tkwindow = tk.Tk()window.title('逃学联盟')window.configure(bg='#008CBA')window.geometry("500x100+300+300")window.iconbitmap('palm-tree-icon.ico')window.mainloop()

    上述代码创建了一个500 * 100 px大小的窗口,窗口左上角坐标是(300,300)。

    9f00e669b4a51c8b3b4b06b09bdf52fb.png

    图片来源网络

    如果需要将窗口放在屏幕的正中,可以通过一些简单的计算和geometry()方法。

    通过.winfo_screenwidth() 和 .winfo_screenheight() 方法可以得到屏幕的宽和高。如果我们需要将窗口放在屏幕正中,窗口的左边框距离屏幕的左边框为 (屏幕宽 - 窗口宽)/ 2

    import tkinter as tkwindow = tk.Tk()window.title('逃学联盟')window.configure(bg='#008CBA')window_width = 500window_height = 100screen_width = window.winfo_screenwidth()screen_height = window.winfo_screenheight()x = int((screen_width - window_width)/2)y = int((screen_height - window_height)/2)window.geometry(f"{window_width}x{window_height}+{x}+{y}")window.iconbitmap('palm-tree-icon.ico')window.mainloop()

    设置窗口的最小的宽高,最大的宽高,全屏显示和窗口是否可以拖拽大小

    .resizable(True, True)方法设置窗口的宽和长是否可以拖拽调整大小;

    .minsize(宽, 高)方法设置窗口的最小宽高

    .maxsize(宽, 高)方法设置窗口的最大宽高

    .state('zoomed')方法设置窗口全屏显示

    .maxsize(宽, 高)方法 和 .state('zoomed')方法不要同时使用。

    import tkinter as tkwindow = tk.Tk()window.title('逃学联盟')window.configure(bg='#008CBA')window.resizable(True, True)window.minsize(100, 100)# window.maxsize(1000, 500)window.state('zoomed')window_width = 500window_height = 100screen_width = window.winfo_screenwidth()screen_height = window.winfo_screenheight()x = int((screen_width - window_width)/2)y = int((screen_height - window_height)/2)window.geometry(f"{window_width}x{window_height}+{x}+{y}")window.iconbitmap('palm-tree-icon.ico')window.mainloop()

    实例1

    鉴于还没有开始其他的tkinter组件,第一个实例借助after方法实现窗口背景色的更换还有窗口的关闭。

    after(delay_ms, callback=None, *args)

    after()方法会每隔delay_ms (毫秒)调用callback的函数。

    window.destroy()方法会关闭window窗口。

    import tkinter as tkimport randomwindow = tk.Tk()window.title('逃学联盟')window.configure(bg='#008CBA')window.resizable(True, True)window.minsize(100, 100)# window.maxsize(1000, 500)window.state('zoomed')window_width = 500window_height = 100screen_width = window.winfo_screenwidth()screen_height = window.winfo_screenheight()x = int((screen_width - window_width)/2)y = int((screen_height - window_height)/2)window.geometry(f"{window_width}x{window_height}+{x}+{y}")window.iconbitmap('palm-tree-icon.ico')bg_color_list = ['#008CBA', '#FFA500', '#4CAF50', '#f44336']def adjust_bg_color():     if bg_color_list:          rand = random.choice(bg_color_list)          window.configure(bg=rand)          window.after(2000, adjust_bg_color)          bg_color_list.remove(rand)     else:          window.destroy()window.after(0, adjust_bg_color)window.mainloop()
    • 定义一个列表 bg_color_list 含有四种不同的颜色代号;
    • 定义callback函数 adjust_bg_color, 如果adjust_bg_color里有值,则随机挑选一个颜色,并更改窗口的bg属性;
    • 每隔2000毫秒调用一次adjust_bg_color;
    • 列表 bg_color_list 中移除被选中的颜色代号;
    • 如果列表 bg_color_list 为空,则关闭窗口;

    感兴趣的同学可以自行运行例子,后面会逐一介绍tkinter的组件。谢谢大家!

    展开全文
  • Tkinter简明教程.pdf,该pdf中详细讲述了tkinter的用法和介绍。
  • tkinter教程

    2018-12-19 19:30:12
    超级详细的tkinker教程Tkinter 是使用 python 进行窗口视窗设计的模块. 简单的构造, 多平台, 多系统的兼容性, 能让它成为让你快速入门定制窗口文件的好助手. 它在 python 窗口视窗模块中是一款简单型的. 所以用来...
  • Tkinter教程

    2016-02-16 15:31:29
    非常详细的python图形界面组件开发教程,以代码的形式解析讲解,且所有代码都可直接运行,非常容易上手。 这系列教程完全以代码的形式来写的,目标是:读者看代码和注释就可以理解代码的意思。但这里的读者需要具备...
  • Python-Tkinter图形化界面设计(详细教程

    万次阅读 多人点赞 2019-08-05 23:07:41
    Python 图形化界面设计 ... 1、图形化界面设计的基本理解 当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单、按钮等图形化...Python自带了tkinter 模块,实质上...

    声明:本篇文章为转载自https://www.jianshu.com/p/91844c5bca78,在原作者的基础上添加目录导航,旨在帮助大家以更高效率进行学习和开发。

    Python-Tkinter 图形化界面设计(详细教程)

    本文目录

    一.图形化界面设计的基本理解

    当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单、按钮等图形化元素触发指令,并从标签、对话框等图型化显示容器中获取人机对话信息。
    Python自带了tkinter 模块,实质上是一种流行的面向对象的GUI工具包 TK 的Python编程接口,提供了快速便利地创建GUI应用程序的方法。其图像化编程的基本步骤通常包括:

    ○ 导入 tkinter 模块
    ○ 创建 GUI 根窗体
    ○ 添加人机交互控件并编写相应的函数。
    ○ 在主事件循环中等待用户触发事件响应。

    二.窗体控件布局

    2.1. 数据集导入

    根窗体是图像化应用程序的根控制器,是tkinter的底层控件的实例。当导入tkinter模块后,调用 Tk()方法可初始化一个根窗体实例 root ,用 title() 方法可设置其标题文字,用geometry()方法可以设置窗体的大小(以像素为单位)。将其置于主循环中,除非用户关闭,否则程序始终处于运行状态。执行该程序,一个窗体就呈现出来了。在这个主循环的根窗体中,可持续呈现中的其他可视化控件实例,监测事件的发生并执行相应的处理程序。下面是根窗体呈现示例:

    from tkinter import *
    root= Tk()
    root.title('我的第一个Python窗体')
    root.geometry('240x240') # 这里的乘号不是 * ,而是小写英文字母 x
    root.mainloop()
    

    在这里插入图片描述

    2.2. tkinter 常用控件

    返回目录

    常用控件:常用的10 多种,如下:
    在这里插入图片描述

    2.2.1 控件的共同属性

    返回目录

    在窗体上呈现的可视化控件,通常包括尺寸、颜色、字体、相对位置、浮雕样式、图标样式和悬停光标形状等共同属性。不同的控件由于形状和功能不同,又有其特征属性。在初始化根窗体和根窗体主循环之间,可实例化窗体控件,并设置其属性。父容器可为根窗体或其他容器控件实例。常见的控件共同属性如下表:
    在这里插入图片描述
    标签及常见属性示例:

    from  tkinter import *
    root = Tk()
    lb = Label(root,text='我是第一个标签',\
            bg='#d3fbfb',\
            fg='red',\
            font=('华文新魏',32),\
            width=20,\
            height=2,\
            relief=SUNKEN)
    lb.pack()
    root.mainloop()
    

    在这里插入图片描述
    其中,标签实例lb 在父容器root中实例化,具有代码中所示的text(文本)、bg(背景色)、fg(前景色)、font(字体)、width(宽,默认以字符为单位)、height(高,默认以字符为单位)和 relief(浮雕样式)等一系列属性。
    在实例化控件时,实例的属性可以“属性=属性值”的形式枚举列出,不区分先后次序。例如:“ text=‘我是第一个标签’ ”显示标签的文本内容,“bg=’#d3fbfb’”设置背景色为十六进制数RGB色 #d3fbfb等等。属性值通常用文本形式表示。
    当然如果这个控件实例只需要一次性呈现,也可以不必命名,直接实例化并布局呈现出来,例如:

    Label(root,text='我是第一个标签',font='华文新魏').pack()
    

    属性 relief 为控件呈现出来的3D浮雕样式,有 FLAT(平的)、RAISED(凸起的)、SUNKEN(凹陷的)、GROOVE(沟槽状边缘)和 RIDGE(脊状边缘) 5种。
    在这里插入图片描述

    2.3 控件布局

    返回目录

    控件的布局通常有pack()、grid() 和 place() 三种方法。
    pack和grid请参考:https://www.jianshu.com/p/91844c5bca78

    2.3.1 place()方法

    返回目录

    根据控件实例在父容器中的绝对或相对位置参数进行布局。其常用布局参数如下:
    x,y:控件实例在根窗体中水平和垂直方向上的其实位置(单位为像素)。注意,根窗体左上角为0,0,水平向右,垂直向下为正方向。
    relx,rely:控件实例在根窗体中水平和垂直方向上起始布局的相对位置。即相对于根窗体宽和高的比例位置,取值在0.0~1.0之间。
    height,width:控件实例本身的高度和宽度(单位为像素)。
    relheight,relwidth:控件实例相对于根窗体的高度和宽度比例,取值在0.0~1.0之间。

    利用place()方法配合relx,rely和relheight,relwidth参数所得的到的界面可自适应根窗体尺寸的大小。place()方法与grid()方法可以混合使用。如下例子:利用place()方法排列消息(多行标签)。
    在这里插入图片描述

    from tkinter import *
    root = Tk()
    root.geometry('320x240')
    
    msg1 = Message(root,text='''我的水平起始位置相对窗体 0.2,垂直起始位置为绝对位置 80 像素,我的高度是窗体高度的0.4,宽度是200像素''',relief=GROOVE)
    msg1.place(relx=0.2,y=80,relheight=0.4,width=200)
    root.mainloop()
    

    三、tkinter常见控件的特征属性

    3.1、文本输入和输出相关控件

    文本的输入与输出控件通常包括:标签(Label)、消息(Message)、输入框(Entry)、文本框(Text)。他们除了前述共同属性外,都具有一些特征属性和功能。

    ○ 3.1.1 标签(Label)和 消息(Message)

    返回目录

    除了单行与多行的不同外,属性和用法基本一致,用于呈现文本信息。值得注意的是:属性text通常用于实例在第一次呈现时的固定文本,而如果需要在程序执行后发生变化,则可以使用下列方法之一实现:1、用控件实例的configure()方法来改变属性text的值,可使显示的文本发生变化;2、先定义一个tkinter的内部类型变量var=StringVar() 的值也可以使显示文本发生变化。
    看下面的一个例子:制作一个电子时钟,用root的after()方法每隔1秒time模块以获取系统当前时间,并在标签中显示出来。
    方法一:利用configure()方法或config()来实现文本变化
    在这里插入图片描述

    import tkinter
    import time
    
    def gettime():
          timestr = time.strftime("%H:%M:%S") # 获取当前的时间并转化为字符串
          lb.configure(text=timestr)   # 重新设置标签文本
          root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间
    
    root = tkinter.Tk()
    root.title('时钟')
    
    lb = tkinter.Label(root,text='',fg='blue',font=("黑体",80))
    lb.pack()
    gettime()
    root.mainloop()
    

    方法二:利用textvariable变量属性来实现文本变化

    import tkinter
    import time
    
    def gettime():
          var.set(time.strftime("%H:%M:%S"))   # 获取当前时间
          root.after(1000,gettime)   # 每隔1s调用函数 gettime 自身获取时间
    
    root = tkinter.Tk()
    root.title('时钟')
    var=tkinter.StringVar()
    
    lb = tkinter.Label(root,textvariable=var,fg='blue',font=("黑体",80))
    lb.pack()
    gettime()
    root.mainloop()
    

    ○ 3.1.2 文本框(Text)

    文本框的常用方法如下:
    在这里插入图片描述
    上表位置的取值可为整数,浮点数或END(末尾),例如0.0表示第0列第0行
    如下一个例子: 每隔1秒获取一次当前日期的时间,并写入文本框中,如下:本例中调用 datetime.now()获取当前日期时间,用insert()方法每次从文本框txt的尾部(END)开始追加文本。
    在这里插入图片描述

    from tkinter import *
    import time
    import datetime
    
    def gettime():
           s=str(datetime.datetime.now())+'\n'
           txt.insert(END,s)
           root.after(1000,gettime)  # 每隔1s调用函数 gettime 自身获取时间
    
    root=Tk()
    root.geometry('320x240')
    txt=Text(root)
    txt.pack()
    gettime()
    root.mainloop()
    

    ○ 3.1.3 输入框(Entry)

    返回目录

    通常作为功能比较单一的接收单行文本输入的控件,虽然也有许多对其中文本进行操作的方法,但通常用的只有取值方法get()和用于删除文本的delete(起始位置,终止位置),例如:清空输入框为delete(0,END)

    3.2 按钮(Button)

    返回目录

    主要是为响应鼠标单击事件触发运行程序所设的,故其除控件共有属性外,属性command是最为重要的属性。通常,将按钮要触发执行的程序以函数形式预先定义,然后可以用一下两种方法调用函数。Button按钮的状态有:'normal','active','disabled'

    ○ 直接调用函数。参数表达式为“command=函数名”,注意函数名后面不要加括号,也不能传递参数。如下面的command=run1:
    ○ 利用匿名函数调用函数和传递参数。参数的表达式为“command=lambda”:函数名(参数列表)。例如下面的:"command=lambda:run2(inp1.get(),inp2.get())"。

    ○ 看下面的例子:1.从两个输入框去的输入文本后转为浮点数值进行加法运算,要求每次单击按钮产生的算是结果以文本的形式追加到文本框中,将原输入框清空。2.按钮方法一不传参数调用函数run1()实现,按钮“方法二”用lambda调用函数run2(x,y)同时传递参数实现。
    在这里插入图片描述

    from tkinter import *
    
    def run1():
         a = float(inp1.get())
         b = float(inp2.get())
         s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)
         txt.insert(END, s)   # 追加显示运算结果
         inp1.delete(0, END)  # 清空输入
         inp2.delete(0, END)  # 清空输入
    
    def run2(x, y):
         a = float(x)
         b = float(y)
         s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)
         txt.insert(END, s)   # 追加显示运算结果
         inp1.delete(0, END)  # 清空输入
         inp2.delete(0, END)  # 清空输入
    
    root = Tk()
    root.geometry('460x240')
    root.title('简单加法器')
    
    lb1 = Label(root, text='请输入两个数,按下面两个按钮之一进行加法计算')
    lb1.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)
    inp1 = Entry(root)
    inp1.place(relx=0.1, rely=0.2, relwidth=0.3, relheight=0.1)
    inp2 = Entry(root)
    inp2.place(relx=0.6, rely=0.2, relwidth=0.3, relheight=0.1)
    
    # 方法-直接调用 run1()
    btn1 = Button(root, text='方法一', command=run1)
    btn1.place(relx=0.1, rely=0.4, relwidth=0.3, relheight=0.1)
    
    # 方法二利用 lambda 传参数调用run2()
    btn2 = Button(root, text='方法二', command=lambda: run2(inp1.get(), inp2.get()))
    btn2.place(relx=0.6, rely=0.4, relwidth=0.3, relheight=0.1)
    
    # 在窗体垂直自上而下位置60%处起,布局相对窗体高度40%高的文本框
    txt = Text(root)
    txt.place(rely=0.6, relheight=0.4)
    
    root.mainloop()
    

    3.3 单选按钮

    返回目录

    (Radiobutton)是为了响应故乡排斥的若干单选项的单击事件以触发运行自定义函数所设的,该控件排除具有共有属性外,还具有显示文本(text)、返回变量(variable)、返回值(value)、响应函数名(command)等重要属性。响应函数名“command=函数名”的用法与Button相同,函数名最后也要加括号。返回变量variable=var通常应预先声明变量的类型var=IntVar()或var=StringVar(),在所调用的函数中方可用var.get()方法获取被选中实例的value值。例如下面:
    在这里插入图片描述

    from tkinter import *
    def Mysel():
          dic = {0:'甲',1:'乙',2:'丙'}
          s = "您选了" + dic.get(var.get()) + "项"
          lb.config(text = s)
    
    root = Tk()
    root.title('单选按钮')
    lb = Label(root)
    lb.pack()
    
    var = IntVar()
    rd1 = Radiobutton(root,text="甲",variable=var,value=0,command=Mysel)
    rd1.pack()
    
    rd2 = Radiobutton(root,text="乙",variable=var,value=1,command=Mysel)
    rd2.pack()
    
    rd3 = Radiobutton(root,text="丙",variable=var,value=2,command=Mysel)
    rd3.pack()
    
    root.mainloop()
    

    3.4 复选框

    返回目录

    (Checkbutton) 是为了返回多个选项值的交互控件,通常不直接触发函数的执行。该控件除具有共有属性外,还具有显示文本(text)、返回变量(variable)、选中返回值(onvalue)和未选中默认返回值(offvalue)等重要属性。返回变量variable=var 通常可以预先逐项分别声明变量的类型var=IntVar() (默认)或 var=StringVar(), 在所调用的函数中方可分别调用 var.get()方法 取得被选中实例的 onvalue或offvalue值。复选框实例通常还可分别利用 select()、deselect()和 toggle() 方法对其进行选中、清除选中和反选操作。

    ○ 如下的例子: 利用复选框实现,单击OK,可以将选中的结果显示在标签上。效果如下:

    在这里插入图片描述
    ○ 方法:利用函数中的 if-else 分支实现多项显示

    from tkinter import *
    import tkinter
    
    def run():
         if(CheckVar1.get()==0 and CheckVar2.get()==0 and CheckVar3.get()==0 and CheckVar4.get()==0):
             s = '您还没选择任何爱好项目'
         else:
             s1 = "足球" if CheckVar1.get()==1 else ""
             s2 = "篮球" if CheckVar2.get() == 1 else ""
             s3 = "游泳" if CheckVar3.get() == 1 else ""
             s4 = "田径" if CheckVar4.get() == 1 else ""
             s = "您选择了%s %s %s %s" % (s1,s2,s3,s4)
         lb2.config(text=s)
    
    root = tkinter.Tk()
    root.title('复选框')
    lb1=Label(root,text='请选择您的爱好项目')
    lb1.pack()
    
    CheckVar1 = IntVar()
    CheckVar2 = IntVar()
    CheckVar3 = IntVar()
    CheckVar4 = IntVar()
    
    ch1 = Checkbutton(root,text='足球',variable = CheckVar1,onvalue=1,offvalue=0)
    ch2 = Checkbutton(root,text='篮球',variable = CheckVar2,onvalue=1,offvalue=0)
    ch3 = Checkbutton(root,text='游泳',variable = CheckVar3,onvalue=1,offvalue=0)
    ch4 = Checkbutton(root,text='田径',variable = CheckVar4,onvalue=1,offvalue=0)
    
    ch1.pack()
    ch2.pack()
    ch3.pack()
    ch4.pack()
    
    btn = Button(root,text="OK",command=run)
    btn.pack()
    
    lb2 = Label(root,text='')
    lb2.pack()
    root.mainloop()
    

    3.5 列表框 与 组合框

    3.5.1 列表框

    返回目录

    (Listbox) 可供用户单选或多选所列条目以形成人机交互。列表框控件的主要方法见下面的表:
    在这里插入图片描述
    执行自定义函数时,通常使用“实例名.surselection()” 或 “selected” 来获取选中项的位置索引。由于列表框实质上就是将Python 的列表类型数据可视化呈现,在程序实现时,也可直接对相关列表数据进行操作,然后再通过列表框展示出来,而不必拘泥于可视化控件的方法。看下面的一个例子:实现列表框的初始化、添加、插入、修改、删除和清空操作,如下:
    在这里插入图片描述

    from tkinter import *
    def ini():
          Lstbox1.delete(0,END)
          list_items = ["数学","物理","化学","语文","外语"]
          for item in list_items:
               Lstbox1.insert(END,item)
    
    def clear():
          Lstbox1.delete(0,END)
    
    def ins():
          if entry.get() != '':
              if Lstbox1.curselection() == ():
                  Lstbox1.insert(Lstbox1.size(),entry.get())
              else:
                  Lstbox1.insert(Lstbox1.curselection(),entry.get())
    
    def updt():
          if entry.get() != '' and Lstbox1.curselection() != ():
               selected=Lstbox1.curselection()[0]
               Lstbox1.delete(selected)
               Lstbox1.insert(selected,entry.get())
    
    def delt():
          if Lstbox1.curselection() != ():
               Lstbox1.delete(Lstbox1.curselection())
    
    root = Tk()
    root.title('列表框实验')
    root.geometry('320x240')
    
    frame1 = Frame(root,relief=RAISED)
    frame1.place(relx=0.0)
    
    frame2 = Frame(root,relief=GROOVE)
    frame2.place(relx=0.5)
    
    Lstbox1 = Listbox(frame1)
    Lstbox1.pack()
    
    entry = Entry(frame2)
    entry.pack()
    
    btn1 = Button(frame2,text='初始化',command=ini)
    btn1.pack(fill=X)
    
    btn2 = Button(frame2,text='添加',command=ins)
    btn2.pack(fill=X)
    
    btn3 = Button(frame2,text='插入',command=ins) # 添加和插入功能实质上是一样的
    btn3.pack(fill=X)
    
    btn4 = Button(frame2,text='修改',command=updt)
    btn4.pack(fill=X)
    
    btn5 = Button(frame2,text='删除',command=delt)
    btn5.pack(fill=X)
    
    btn6 = Button(frame2,text='清空',command=clear)
    btn6.pack(fill=X)
    
    root.mainloop()
    

    3.5.2 组合框

    返回目录

    (Combobox) 实质上是带文本框的上拉列表框,其功能也将是Python 的列表类型数据可视化呈现,并提供用户单选或多选所列条目以形成人机交互。在图形化界面设计时,由于其具有灵活的界面,因此往往比列表框更受喜爱。但该控件并不包含在 tkinter 模块中,而是与 TreeView、Progressbar、Separator等控件一同包含在tkinter 的子模块ttk中。如果使用该控件,应先与from tkinter import ttk 语句引用ttk子模块,然后创建组合框实例: 实例名=Combobox(根对象,[属性列表])
    指定变量var=StringVar(),并设置实例属性 textvariable = var,values=[列表…]。组合框控件常用方法有:获得所选中的选项值get()和获得所选中的选项索引current()。
    看下面的一个例子:实现四则运算计算器,将两个操作数分别填入两个文本框后,通过选择组合框中的算法触发运算,如下:
    在这里插入图片描述

    from tkinter.ttk import *
    
    def calc(event):
           a = float(t1.get())
           b = float(t2.get())
           dic = {0:a+b,1:a-b,2:a*b,3:a/b}
           c = dic[comb.current()]
           lbl.config(text=str(c))
    
    root = Tk()
    root.title('四则运算')
    root.geometry('320x240')
    
    t1 = Entry(root)
    t1.place(relx=0.1,rely=0.1,relwidth=0.2,relheight=0.1)
    
    t2 = Entry(root)
    t2.place(relx=0.5,rely=0.1,relwidth=0.2,relheight=0.1)
    
    var = StringVar()
    
    comb = Combobox(root,textvariable=var,values=['加','减','乘','除',])
    comb.place(relx=0.1,rely=0.5,relwidth=0.2)
    comb.bind('<<ComboboxSelected>>',calc)
    
    lbl=Label(root,text='结果')
    lbl.place(relx=0.5,rely=0.7,relwidth=0.2,relheight=0.3)
    
    root.mainloop()
    

    3.6 滑块

    返回目录

    (Scale) 是一种 直观地进行数值输入的交互控件,其主要属性见下表:
    在这里插入图片描述
    滑块控件实例的主要方法比较简单,有 get()set(值),分别为取值和将滑块设在某特定值上。滑块实例也可绑定鼠标左键释放事件<ButtoonRelease-1>,并在执行函数中添加参数event来实现事件响应。
    例如:在一个窗体上设计一个200像素宽的水平滑块,取值范围为1.0~5.0,分辨精度为0.05,刻度间隔为 1,用鼠标拖动滑块后释放鼠标可读取滑块值并显示在标签上。效果如下:
    在这里插入图片描述

    from tkinter  import  *
    
    def show(event):
          s = '滑块的取值为' + str(var.get())
          lb.config(text=s)
    
    root = Tk()
    root.title('滑块实验')
    root.geometry('320x180')
    var=DoubleVar()
    scl = Scale(root,orient=HORIZONTAL,length=200,from_=1.0,to=5.0,label='请拖动滑块',tickinterval=1,resolution=0.05,variable=var)
    scl.bind('<ButtonRelease-1>',show)
    scl.pack()
    
    lb = Label(root,text='')
    lb.pack()
    
    root.mainloop()
    

    3.7 菜单

    返回目录

    (Menu)用于可视化地为一系列的命令分组,从而方便用户找到和触发执行这些命令。这里Menu所实例化别的主要是菜单,其通式为:

    菜单实例名=Menu(根窗体)
    菜单分组1=Menu(菜单实例名)
    菜单实例名.add_cascade(<label=菜单分组1 显示文本>,<menu=菜单分组1>)
    菜单分组1.add_command(<label=命令1文本>,<command=命令1函数名>)
    

    其中较为常见的方法有:add_cascade()add_command()add_separator(),分别用于添加一个菜单分组、添加一条菜单命令和添加一条分割线。
    利用Menu控件也可以创建快捷菜单(又称为上下文菜单)。通常需要右击弹出的控件实例绑定鼠标右击响应事件,并指向一个捕获event参数的自定义函数,在该自定义函数中,将鼠标的触发位置event.x_root 和 event.y_root以post()方法传给菜单。
    例子: 仿照window自带的“记事本”中的文件和编辑 菜单,实现在主菜单个快捷菜单上触发菜单命令,并相应改变窗体上的标签的文本内容。效果如下:
    在这里插入图片描述

    from tkinter import *
    
    def new():
         s = '新建'
         lb1.config(text=s)
    
    def ope():
         s = '打开'
         lb1.config(text=s)
    
    def sav():
         s = '保存'
         lb1.config(text=s)
    
    def cut():
         s = '剪切'
         lb1.config(text=s)
    
    def cop():
         s = '复制'
         lb1.config(text=s)
    
    def pas():
         s = '粘贴'
         lb1.config(text=s)
    
    def popupmenu(event):
         mainmenu.post(event.x_root,event.y_root)
    
    root = Tk()
    root.title('菜单实验')
    root.geometry('320x240')
    
    lb1 = Label(root,text='显示信息',font=('黑体',32,'bold'))
    lb1.place(relx=0.2,rely=0.2)
    
    mainmenu = Menu(root)
    menuFile = Menu(mainmenu)  # 菜单分组 menuFile
    mainmenu.add_cascade(label="文件",menu=menuFile)
    menuFile.add_command(label="新建",command=new)
    menuFile.add_command(label="打开",command=ope)
    menuFile.add_command(label="保存",command=sav)
    menuFile.add_separator()  # 分割线
    menuFile.add_command(label="退出",command=root.destroy)
    
    menuEdit = Menu(mainmenu)  # 菜单分组 menuEdit
    mainmenu.add_cascade(label="编辑",menu=menuEdit)
    menuEdit.add_command(label="剪切",command=cut)
    menuEdit.add_command(label="复制",command=cop())
    menuEdit.add_command(label="粘贴",command=pas())
    
    root.config(menu=mainmenu)
    root.bind('Button-3',popupmenu) # 根窗体绑定鼠标右击响应事件
    root.mainloop()
    

    3.8 子窗体

    返回目录

    用Toplevel可新建一个显示在最前面的子窗体,其通式为: 字体实例名=Toplevel(根窗体),子窗体与根窗体类似,也可设置title、geomerty等属性,并在画布上布局其他控件。如下的例子:在根窗体上创建菜单,触发创建一个新的窗体
    在这里插入图片描述

    from tkinter import *
    
    def newwind():
          winNew = Toplevel(root)
          winNew.geometry('320x240')
          winNew.title('新窗体')
          lb2 = Label(winNew,text='我在新窗体上')
          lb2.place(relx=0.2,rely=0.2)
          btClose=Button(winNew,text='关闭',command=winNew.destroy)
          btClose.place(relx=0.7,rely=0.5)
    
    root = Tk()
    root.title('新建窗体实验')
    root.geometry('320x240')
    
    lb1 = Label(root,text='主窗体',font=('黑体',32,'bold'))
    lb1.place(relx=0.2,rely=0.2)
    
    mainmenu = Menu(root)
    menuFile = Menu(mainmenu)
    mainmenu.add_cascade(label='菜单',menu=menuFile)
    menuFile.add_command(label='新窗体',command=newwind)
    menuFile.add_separator()
    menuFile.add_command(label='退出',command=root.destroy)
    
    root.config(menu=mainmenu)
    root.mainloop()
    

    关闭窗体程序运行的方法通常用 destory(),而不建议用 quit()。用Toplevel 所创建的子窗体是非模式(Modeless)的窗体,虽然初建时子窗体在最前面,但根窗体上的控件实例也是可以被操作的。

    3.9 模式对话框(Modal)

    返回目录

    是相对于前面介绍的非模式窗体而言的,所弹出的对话框必须应答,在关闭之前无法操作其后面的其他窗体。常见的模式对话框有消息对话框、输入对话框、文件选择对话框、颜色选择对话框等。

    3.9.1 交互对话框

    返回目录

    (一)、消息对话框: 引用 tkinter.messagebox 包,可使用消息对话框函数。执行这些函数,可弹出模式消息对话框,并根据用户的响应但会一个布尔值。其通式为:

    消息对话框函数(<title=标题文本>,<message=消息文本>,[其他参数])
    

    看下面的例子:单击按钮,弹出确认取消对话框,并将用户回答显示在标签中。效果如下:
    在这里插入图片描述

    from tkinter import *
    import tkinter.messagebox
    
    def xz():
        answer=tkinter.messagebox.askokcancel('请选择','请选择确定或取消')
        if answer:
            lb.config(text='已确认')
        else:
            lb.config(text='已取消')
    
    root = Tk()
    
    lb = Label(root,text='')
    lb.pack()
    btn=Button(root,text='弹出对话框',command=xz)
    btn.pack()
    root.mainloop()
    

    (二)、输入对话框: 引用tkinter.simpledialog包,可弹出输入对话框,用以接收用户的简单输入。输入对话框常用 askstring()、askfloat()和askfloat() 三种函数,分别用于接收字符串、整数和浮点数类型的输入。
    如下面的例子:单击按钮,弹出输入对话框,接收文本输入显示在窗体的标签上。如下:
    在这里插入图片描述

    from tkinter.simpledialog import *
    
    def xz():
        s=askstring('请输入','请输入一串文字')
        lb.config(text=s)
    
    root = Tk()
    
    lb = Label(root,text='')
    lb.pack()
    btn=Button(root,text='弹出输入对话框',command=xz)
    btn.pack()
    root.mainloop()
    

    3.9.2 文件选择对话框

    返回目录

    引用tkinter.filedialog包,可弹出文件选择对话框,让用户直观地选择一个或一组文件,以供进一步的文件操作。常用的文件选择对话框函数有 askopenfilename()、askopenfilenames()和asksaveasfilename(),分别用于进一步打开一个文件、一组文件和保存文件。其中,askopenfilename()和asksaveasfilenamme()函数的返回值类型为包含文件路径的文件名字符串,而askopenfilenames()函数的返回值类型为元组。
    例如:单击按钮,弹出文件选择对话框(“打开”对话框),并将用户所选择的文件路径和文件名显示在窗体的标签上。如下
    在这里插入图片描述

    from tkinter import *
    import tkinter.filedialog
    
    def xz():
        filename=tkinter.filedialog.askopenfilename()
        if filename != '':
             lb.config(text='您选择的文件是'+filename)
        else:
             lb.config(text='您没有选择任何文件')
    
    root = Tk()
    
    lb = Label(root,text='')
    lb.pack()
    btn=Button(root,text='弹出文件选择对话框',command=xz)
    btn.pack()
    root.mainloop()
    

    3.9.3、颜色选择对话框

    返回目录

    引用tkinter.colorchooser包,可使用 askcolor()函数弹出模式颜色选择对话框,让用户可以个性化地设置颜色属性。该函数的返回形式为包含RGB十进制浮点元组和RGB十六进制字符串的元组类型,例如:“((135.527343.52734375,167.65234375,186.7265625)),’#87a7ba’”。通常,可将其转换为字符串类型后,再截取以十六进制数表示的RGB颜色字符串用于为属性赋值。
    举例:单击按钮,弹出颜色选择对话框,并将用户所选择的颜色设置为窗体上标签的背景颜色,如下:
    在这里插入图片描述

    from tkinter import *
    import tkinter.colorchooser
    
    def xz():
        color=tkinter.colorchooser.askcolor()
        colorstr=str(color)
        print('打印字符串%s 切掉后=%s' % (colorstr,colorstr[-9:-2]))
        lb.config(text=colorstr[-9:-2],background=colorstr[-9:-2])
    
    root = Tk()
    
    lb = Label(root,text='请关注颜色的变化')
    lb.pack()
    btn=Button(root,text='弹出颜色选择对话框',command=xz)
    btn.pack()
    root.mainloop()
    

    四、事件响应

    返回目录

    用tkinter 可将用户事件与自定义函数绑定,用键盘或鼠标的动作事件来响应触发自定义函数的执行。其通式为:

    控件实例.bind(<事件代码>,<函数名>)
    

    其中,事件代码通常以半角小于号“<”和大于号“>” 界定,包括事件和按键等 2~3个部分,它们之间用减号分隔,常见事件代码见下表:
    在这里插入图片描述
    例如,将框架控件实例frame 绑定鼠标右键单击事件,调用自定义函数 myfunc()可表示为"frame.bind(’’,myfunc)",注意: myfunc后面没有括号。将控件实例绑定到键盘事件和部分光标不落在具体控件实例上的鼠标事件时,还需要设置该实例执行focus_set() 方法获得焦点,才能对事件持续响应。例如: frame.focus_set()。所调用的自定义函数若需要利用鼠标或键盘的响应值,可将event作为参数,通过event的属性获取。event的属性见下表:
    在这里插入图片描述
    在这里插入图片描述

    from tkinter import *
    
    def show(event):
    s=event.keysym
    lb.config(text=s)
    
    root=Tk()
    root.title('按键实验')
    root.geometry('200x200')
    lb=Label(root,text='请按键',font=('黑体',48))
    lb.bind('<Key>',show)
    lb.focus_set()
    lb.pack()
    root.mainloop()
    

    补充:

    五、背景图片

    1、添加背景

    返回目录

    #插入文件图片
    import tkinter as tk
    
    root = tk.Tk()
    
    #创建一个标签类, [justify]:对齐方式
    textLabel = tk.Label(root,text="你在右边会看到一个图片,\n我在换个行",
    justify = tk.LEFT)#左对齐
    textLabel.pack(side=tk.LEFT)#自动对齐,side:方位
    
     
    
    #创建一个图片管理类
    photo = tk.PhotoImage(file="18.png")#file:t图片路径
    imgLabel = tk.Label(root,image=photo)#把图片整合到标签类中
    imgLabel.pack(side=tk.RIGHT)#自动对齐
    
    
    tk.mainloop()
    

    在这里插入图片描述

    返回目录

    import tkinter as tk
    
    root = tk.Tk()
    
    
    #增加背景图片
    photo = tk.PhotoImage(file="背景.png")
    theLabel = tk.Label(root,
             text="我是内容,\n请你阅读",#内容
             justify=tk.LEFT,#对齐方式
             image=photo,#加入图片
             compound = tk.CENTER,#关键:设置为背景图片
             font=("华文行楷",20),#字体和字号
             fg = "white")#前景色
    theLabel.pack()
    
     
    
    tk.mainloop()
    

    在这里插入图片描述

    返回目录

    #插入文件图片
    import tkinter as tk
    
    root = tk.Tk()
    
    frame1 = tk.Frame(root)#这是上面的框架
    frame2 = tk.Frame(root)#这是下面的框架
    
    
    var = tk.StringVar()#储存文字的类
    var.set("你在右边会看到一个图片,\n我在换个行")#设置文字
    
    #创建一个标签类, [justify]:对齐方式,[frame]所属框架
    textLabel = tk.Label(frame1,textvariable=var,
             justify = tk.LEFT)#显示文字内容 
    textLabel.pack(side=tk.LEFT)#自动对齐,side:方位
    
     
    
    #创建一个图片管理类
    photo = tk.PhotoImage(file="18.png")#file:t图片路径
    imgLabel = tk.Label(frame1,image=photo)#把图片整合到标签类中
    imgLabel.pack(side=tk.RIGHT)#自动对齐
    
    
    def callback():#触发的函数
      var.set("你还真按了")#设置文字
    
    #[frame]所属框架 ,text 文字内容 command:触发方法
    theButton = tk.Button(frame2,text="我是下面的按钮",command=callback)
    theButton.pack()#自动对齐
    
     
    
    frame1.pack(padx=10,pady=10)#上框架对齐
    frame2.pack(padx=10,pady=10)#下框架对齐
    
    
    tk.mainloop()
    

    在这里插入图片描述
    在这里插入图片描述

    返回目录

    六、打开摄像头,显示

    效果:
    在这里插入图片描述
    代码:

      from tkinter import *
        import cv2
        from PIL import Image,ImageTk
        
        
        def take_snapshot():
            print("有人给你点赞啦!")
        
        def video_loop():
            success, img = camera.read()  # 从摄像头读取照片
            if success:
                cv2.waitKey(100)
                cv2image = cv2.cvtColor(img, cv2.COLOR_BGR2RGBA)#转换颜色从BGR到RGBA
                current_image = Image.fromarray(cv2image)#将图像转换成Image对象
                imgtk = ImageTk.PhotoImage(image=current_image)
                panel.imgtk1 = imgtk
                panel.config(image=imgtk)
                root.after(1, video_loop)
        
        camera = cv2.VideoCapture(0)    #摄像头
        
        root = Tk()
        root.title("opencv + tkinter")
        #root.protocol('WM_DELETE_WINDOW', detector)
        
        
        panel = Label(root)  # initialize image panel
        panel.pack(padx=10, pady=10)
        # root.config(cursor="arrow")
        btn = Button(root, text="点赞!", command=take_snapshot)
        btn.pack(fill="both", expand=True, padx=10, pady=10)
        
        video_loop()
        
        root.mainloop()
        # 当一切都完成后,关闭摄像头并释放所占资源
        camera.release()
        cv2.destroyAllWindows()
    

    感谢前辈:
    https://www.jianshu.com/p/91844c5bca78
    https://www.cnblogs.com/banzhen/p/7427201.html
    https://blog.csdn.net/a1_a1_a/article/details/79981788

    展开全文
  • 主要讲的tkinter的现代会界面,也就是着重于ttk的运用
  • 一、前言  由于本篇文章较长,所以下面... 三、Tkinter 控件详细介绍  1. Tkinter 模块元素简要说明  2. 常用窗口部件及简要说明:  四、动手实践学习  1. 创建主窗口及Label部件(标签)创建使用  2. Butto...

    一、前言

      由于本篇文章较长,所以下面给出内容目录方便跳转阅读,当然也可以用博客页面最右侧的文章目录导航栏进行跳转查阅。

      一、前言

      二、Tkinter 是什么

      三、Tkinter 控件详细介绍

        1. Tkinter 模块元素简要说明

        2. 常用窗口部件及简要说明:

      四、动手实践学习

        1. 创建主窗口及Label部件(标签)创建使用

        2. Button窗口部件

        3. Entry窗口部件

        4. Text窗口部件

        5. Listbox窗口部件

        6. Radiobutton窗口部件

        7. Checkbutton窗口部件 

        8. Scale窗口部件

        9. Canvas窗口部件

        10. Menu窗口部件

        11. Frame 窗口部件

        12. messageBox窗口部件

        13. 窗口部件三种放置方式pack/grid/place

        14. 综合练习,用户登录窗口例子

        15. 其他部件后续再补充...

    二、Tkinter是什么

      Tkinter 是使用 python 进行窗口视窗设计的模块。Tkinter模块("Tk 接口")是Python的标准Tk GUI工具包的接口。作为 python 特定的GUI界面,是一个图像的窗口,tkinter是python 自带的,可以编辑的GUI界面,我们可以用GUI 实现很多直观的功能,比如想开发一个计算器,如果只是一个程序输入,输出窗口的话,是没用用户体验的。所有开发一个图像化的小窗口,就是必要的。

      对于稍有GUI编程经验的人来说,Python的Tkinter界面库是非常简单的。python的GUI库非常多,选择Tkinter,一是最为简单,二是自带库,不需下载安装,随时使用,三则是从需求出发,Python作为一种脚本语言,一种胶水语言,一般不会用它来开发复杂的桌面应用,它并不具备这方面的优势,使用Python,可以把它作为一个灵活的工具,而不是作为主要开发语言,那么在工作中,需要制作一个小工具,肯定是需要有界面的,不仅自己用,也能分享别人使用,在这种需求下,Tkinter是足够胜任的!

      这篇文章主要做一个简单概述和实践编程,对于从没有接触过GUI的新手,在脑中树立一个基本的界面编程概念,同时自己也能学会如何简单的实现一些小的图形窗口功能。

      对于Tkinter编程,可以用两个比喻来理解:

    • 第一个,作画。我们都见过美术生写生的情景,先支一个画架,放上画板,蒙上画布,构思内容,用铅笔画草图,组织结构和比例,调色板调色,最后画笔勾勒。相应的,对应到tkinter编程,那么我们的显示屏就是支起来的画架,根窗体就是画板,在tkinter中则是Toplevel,画布就是tkinter中的容器(Frame),画板上可以放很多张画布(Convas),tkinter中的容器中也可以放很多个容器,绘画中的构图布局则是tkinter中的布局管理器(几何管理器),绘画的内容就是tkinter中的一个个小组件,一幅画由许多元素构成,而我们的GUI界面,就是有一个个组件拼装起来的,它们就是widget。
    • 第二个,我们小时候都玩过积木,只要发挥创意,相同的积木可以堆出各种造型。tkinter的组件也可以看做一个个积木,形状或许不同,其本质都是一样的,就是一个积木,不管它长什么样子,它始终就是积木!所以这些小组件都有许多共性,另外,个人认为,学习界面编程,最重要的不是一开始学习每个积木的样子,不是学习每个组件怎么用,而是这些组件该怎么放。初始学习中,怎么放远远比怎么用重要的多。网上有大量的文章资料,基本全是介绍组件怎么用的,对于怎么放,也就是tkinter中的布局管理器,都是一笔带过,这对初学者有点本末倒置,或许绝大部分是转载的原因吧,极少是自己真正写的。组件怎么用不是最迫切的,用到的时候再去了解也不迟,边用边学反而更好。因此我将专门写一章,详细介绍布局管理器的使用。

    三、Tkinter 控件详细介绍

    1. Tkinter 模块元素简要说明

     

    The Button Widget
    The Canvas Widget
    The Checkbutton Widget
    The Entry Widget
    The Frame Widget
    The Label Widget
    The LabelFrame Widget
    The Listbox Widget
    The Menu Widget
    The Menubutton Widget
    The Message Widget
    The OptionMenu Widget
    The PanedWindow Widget
    The Radiobutton Widget
    The Scale Widget
    The Scrollbar Widget
    The Spinbox Widget
    The Text Widget
    The Toplevel Widget
    Basic Widget Methods
    Toplevel Window Methods

     

    2. 常用窗口部件及简要说明:

      Tkinter支持16个核心的窗口部件,这个16个核心窗口部件类简要描述如下:

    Button:一个简单的按钮,用来执行一个命令或别的操作。

    Canvas:组织图形。这个部件可以用来绘制图表和图,创建图形编辑器,实现定制窗口部件。

    Checkbutton:代表一个变量,它有两个不同的值。点击这个按钮将会在这两个值间切换。

    Entry:文本输入域。

    Frame:一个容器窗口部件。帧可以有边框和背景,当创建一个应用程序或dialog(对话)版面时,帧被用来组织其它的窗口部件。

    Label:显示一个文本或图象。

    Listbox:显示供选方案的一个列表。listbox能够被配置来得到radiobutton或checklist的行为。

    Menu:菜单条。用来实现下拉和弹出式菜单。

    Menubutton:菜单按钮。用来实现下拉式菜单。

    Message:显示一文本。类似label窗口部件,但是能够自动地调整文本到给定的宽度或比率。

    Radiobutton:代表一个变量,它可以有多个值中的一个。点击它将为这个变量设置值,并且清除与这同一变量相关的其它radiobutton。

    Scale:允许你通过滑块来设置一数字值。

    Scrollbar:为配合使用canvas, entry, listbox, and text窗口部件的标准滚动条。

    Text:格式化文本显示。允许你用不同的样式和属性来显示和编辑文本。同时支持内嵌图象和窗口。

    Toplevel:一个容器窗口部件,作为一个单独的、最上面的窗口显示。

    messageBox:消息框,用于显示你应用程序的消息框。(Python2中为tkMessagebox)

    注意在Tkinter中窗口部件类没有分级;所有的窗口部件类在树中都是兄弟关系。

    所有这些窗口部件提供了Misc和几何管理方法、配置管理方法和部件自己定义的另外的方法。此外,Toplevel类也提供窗口管理接口。这意味一个典型的窗口部件类提供了大约150种方法。

    四、动手实践学习

    1. 创建主窗口及Label部件(标签)创建使用

      我们要学习使用上面提到的这些控件首先要创建一个主窗口,就像作画一样,先要架好架子和画板,然后才能在上面放画纸和各种绘画元素,创建好主窗口才能在上面放置各种控件元素。而创建过程是很简单的,如下:

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上设定标签
    l = tk.Label(window, text='你好!this is Tkinter', bg='green', font=('Arial', 12), width=30, height=2)
    # 说明: bg为背景,font为字体,width为长,height为高,这里的长和高是字符的长和高,比如height=2,就是标签有2个字符这么高
    
    # 第5步,放置标签
    l.pack()    # Label内容content区域放置位置,自动调节尺寸
    # 放置lable的方法有:1)l.pack(); 2)l.place();
    
    # 第6步,主窗口循环显示
    window.mainloop()
    # 注意,loop因为是循环的意思,window.mainloop就会让window不断的刷新,如果没有mainloop,就是一个静态的window,传入进去的值就不会有循环,mainloop就相当于一个很大的while循环,有个while,每点击一次就会更新一次,所以我们必须要有循环
    # 所有的窗口文件都必须有类似的mainloop函数,mainloop是窗口文件的关键的关键。
    

      测试效果:

    2. Button窗口部件

      简单说明:

      Button(按钮)部件是一个标准的Tkinter窗口部件,用来实现各种按钮。按钮能够包含文本或图象,并且你能够将按钮与一个Python函数或方法相关联。当这个按钮被按下时,Tkinter自动调用相关联的函数或方法。

    按钮仅能显示一种字体,但是这个文本可以跨行。另外,这个文本中的一个字母可以有下划线,例如标明一个快捷键。默认情况,Tab键用于将焦点移动到一个按钮部件。

      什么时候用按钮部件

      简言之,按钮部件用来让用户说“马上给我执行这个任务”,通常我们用显示在按钮上的文本或图象来提示。按钮通常用在工具条中或应用程序窗口中,并且用来接收或忽略输入在对话框中的数据。关于按钮和输入的数据的配合,可以参看Checkbutton和Radiobutton部件。

      如何创建:

    普通的按钮很容易被创建,仅仅指定按钮的内容(文本、位图、图象)和一个当按钮被按下时的回调函数即可:

    b = tk.Button(window, text="hit me", command=hit_me)

    没有回调函数的按钮是没有用的,当你按下这个按钮时它什么也不做。你可能在开发一个应用程序的时候想实现这种按钮,比如为了不干扰你的beta版的测试者:

    b = tk.Button(window, text="Help", command=DISABLED)

       示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上设定标签
    var = tk.StringVar()    # 将label标签的内容设置为字符类型,用var来接收hit_me函数的传出内容用以显示在标签上
    l = tk.Label(window, textvariable=var, bg='green', fg='white', font=('Arial', 12), width=30, height=2)
    # 说明: bg为背景,fg为字体颜色,font为字体,width为长,height为高,这里的长和高是字符的长和高,比如height=2,就是标签有2个字符这么高
    l.pack()
    
    # 定义一个函数功能(内容自己自由编写),供点击Button按键时调用,调用命令参数command=函数名
    on_hit = False
    def hit_me():
        global on_hit
        if on_hit == False:
            on_hit = True
            var.set('you hit me')
        else:
            on_hit = False
            var.set('')
    
    # 第5步,在窗口界面设置放置Button按键
    b = tk.Button(window, text='hit me', font=('Arial', 12), width=10, height=1, command=hit_me)
    b.pack()
    
    # 第6步,主窗口循环显示
    window.mainloop()
    

      测试效果:

     

    3. Entry窗口部件

      简单说明:  

      Entry是tkinter类中提供的的一个单行文本输入域,用来输入显示一行文本,收集键盘输入(类似 HTML 中的 text)。

      什么时候用:

      需要用户输入用户信息时,比如我们平时使用软件、登录网页时,用户交互界面让我们登录账户信息等时候可以用到。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上设定输入框控件entry并放置控件
    e1 = tk.Entry(window, show='*', font=('Arial', 14))   # 显示成密文形式
    e2 = tk.Entry(window, show=None, font=('Arial', 14))  # 显示成明文形式
    e1.pack()
    e2.pack()
    
    # 第5步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    4. Text窗口部件

      简单说明:  

      Text是tkinter类中提供的的一个多行文本区域,显示多行文本,可用来收集(或显示)用户输入的文字(类似 HTML 中的 textarea),格式化文本显示,允许你用不同的样式和属性来显示和编辑文本,同时支持内嵌图象和窗口。

      什么时候用:

      在需要显示编辑用户、产品多行信息时,比如显示用户详细描述文字,产品简介等等,支持随时编辑。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上设定输入框控件entry框并放置
    e = tk.Entry(window, show = None)#显示成明文形式
    e.pack()
    
    # 第5步,定义两个触发事件时的函数insert_point和insert_end(注意:因为Python的执行顺序是从上往下,所以函数一定要放在按钮的上面)
    def insert_point(): # 在鼠标焦点处插入输入内容
        var = e.get()
        t.insert('insert', var)
    def insert_end():   # 在文本框内容最后接着插入输入内容
        var = e.get()
        t.insert('end', var)
    
    # 第6步,创建并放置两个按钮分别触发两种情况
    b1 = tk.Button(window, text='insert point', width=10,
                   height=2, command=insert_point)
    b1.pack()
    b2 = tk.Button(window, text='insert end', width=10,
                   height=2, command=insert_end)
    b2.pack()
    
    # 第7步,创建并放置一个多行文本框text用以显示,指定height=3为文本框是三个字符高度
    t = tk.Text(window, height=3)
    t.pack()
    
    # 第8步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    5. Listbox窗口部件

      简单说明:  

      Text是tkinter类中提供的的列表框部件,显示供选方案的一个列表。listbox能够被配置来得到radiobutton或checklist的行为。

      什么时候用:

      在有一个很多内容选项组成的列表提供用户选择时会用到。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签label用以显示并放置
    var1 = tk.StringVar()  # 创建变量,用var1用来接收鼠标点击具体选项的内容
    l = tk.Label(window, bg='green', fg='yellow',font=('Arial', 12), width=10, textvariable=var1)
    l.pack()
    
    # 第6步,创建一个方法用于按钮的点击事件
    def print_selection():
        value = lb.get(lb.curselection())   # 获取当前选中的文本
        var1.set(value)  # 为label设置值
    
    # 第5步,创建一个按钮并放置,点击按钮调用print_selection函数
    b1 = tk.Button(window, text='print selection', width=15, height=2, command=print_selection)
    b1.pack()
    
    # 第7步,创建Listbox并为其添加内容
    var2 = tk.StringVar()
    var2.set((1,2,3,4)) # 为变量var2设置值
    # 创建Listbox
    lb = tk.Listbox(window, listvariable=var2)  #将var2的值赋给Listbox
    # 创建一个list并将值循环添加到Listbox控件中
    list_items = [11,22,33,44]
    for item in list_items:
        lb.insert('end', item)  # 从最后一个位置开始加入值
    lb.insert(1, 'first')       # 在第一个位置加入'first'字符
    lb.insert(2, 'second')      # 在第二个位置加入'second'字符
    lb.delete(2)                # 删除第二个位置的字符
    lb.pack()
    
    # 第8步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    6. Radiobutton窗口部件

      简单说明:  

      Radiobutton:代表一个变量,它可以有多个值中的一个。点击它将为这个变量设置值,并且清除与这同一变量相关的其它radiobutton。

      什么时候用:

      在有一个很多内容选项组成的选项列表提供用户选择时会用到,用户一次只能选择其中一个,不能多选。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签label用以显示并放置
    var = tk.StringVar()    # 定义一个var用来将radiobutton的值和Label的值联系在一起.
    l = tk.Label(window, bg='yellow', width=20, text='empty')
    l.pack()
    
    # 第6步,定义选项触发函数功能
    def print_selection():
        l.config(text='you have selected ' + var.get())
    
    # 第5步,创建三个radiobutton选项,其中variable=var, value='A'的意思就是,当我们鼠标选中了其中一个选项,把value的值A放到变量var中,然后赋值给variable
    r1 = tk.Radiobutton(window, text='Option A', variable=var, value='A', command=print_selection)
    r1.pack()
    r2 = tk.Radiobutton(window, text='Option B', variable=var, value='B', command=print_selection)
    r2.pack()
    r3 = tk.Radiobutton(window, text='Option C', variable=var, value='C', command=print_selection)
    r3.pack()
    
    # 第7步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    7. Checkbutton窗口部件

      简单说明:  

      Checkbutton:代表一个变量,它有两个不同的值。点击这个按钮将会在这两个值间切换,选择和取消选择。

      什么时候用:

      在有一个很多内容选项组成的选项列表提供用户选择时会用到,用户一次可以选择多个。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签label用以显示并放置
    l = tk.Label(window, bg='yellow', width=20, text='empty')
    l.pack()
    
    # 第6步,定义触发函数功能
    def print_selection():
        if (var1.get() == 1) & (var2.get() == 0):     # 如果选中第一个选项,未选中第二个选项
            l.config(text='I love only Python ')
        elif (var1.get() == 0) & (var2.get() == 1):   # 如果选中第二个选项,未选中第一个选项
            l.config(text='I love only C++')
        elif (var1.get() == 0) & (var2.get() == 0):   # 如果两个选项都未选中
            l.config(text='I do not love either')
        else:
            l.config(text='I love both')             # 如果两个选项都选中
    
    # 第5步,定义两个Checkbutton选项并放置
    var1 = tk.IntVar()  # 定义var1和var2整型变量用来存放选择行为返回值
    var2 = tk.IntVar()
    c1 = tk.Checkbutton(window, text='Python',variable=var1, onvalue=1, offvalue=0, command=print_selection)    # 传值原理类似于radiobutton部件
    c1.pack()
    c2 = tk.Checkbutton(window, text='C++',variable=var2, onvalue=1, offvalue=0, command=print_selection)
    c2.pack()
    
    # 第7步,主窗口循环显示
    window.mainloop()
    

      测试效果:

      

    8. Scale窗口部件

      简单说明:  

      Scale: 尺度(拉动条),允许你通过滑块来设置一数字值。

      什么时候用:

      在需要用户给出评价等级,或者给出一个评价分数,或者拉动滑动条提供一个具体的数值等等。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签label用以显示并放置
    l = tk.Label(window, bg='green', fg='white', width=20, text='empty')
    l.pack()
    
    # 第6步,定义一个触发函数功能
    def print_selection(v):
        l.config(text='you have selected ' + v)
    # 第5步,创建一个尺度滑条,长度200字符,从0开始10结束,以2为刻度,精度为0.01,触发调用print_selection函数 s = tk.Scale(window, label='try me', from_=0, to=10, orient=tk.HORIZONTAL, length=200, showvalue=0,tickinterval=2, resolution=0.01, command=print_selection) s.pack() # 第7步,主窗口循环显示 window.mainloop()

      测试效果:

    9. Canvas窗口部件

      简单说明:  

      Canvas:画布,提供绘图功能(直线、椭圆、多边形、矩形) 可以包含图形或位图,用来绘制图表和图,创建图形编辑器,实现定制窗口部件。

      什么时候用:

      在比如像用户交互界面等,需要提供设计的图标、图形、logo等信息是可以用到画布。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建 500 * 200 大小的画布并放置各种元素
    canvas = tk.Canvas(window, bg='green', height=200, width=500)
    # 说明图片位置,并导入图片到画布上
    image_file = tk.PhotoImage(file='pic.gif')  # 图片位置(相对路径,与.py文件同一文件夹下,也可以用绝对路径,需要给定图片具体绝对路径)
    image = canvas.create_image(250, 0, anchor='n',image=image_file)        # 图片锚定点(n图片顶端的中间点位置)放在画布(250,0)坐标处
    # 定义多边形参数,然后在画布上画出指定图形
    x0, y0, x1, y1 = 100, 100, 150, 150
    line = canvas.create_line(x0-50, y0-50, x1-50, y1-50)                   # 画直线
    oval = canvas.create_oval(x0+120, y0+50, x1+120, y1+50, fill='yellow')  # 画圆 用黄色填充
    arc = canvas.create_arc(x0, y0+50, x1, y1+50, start=0, extent=180)      # 画扇形 从0度打开收到180度结束
    rect = canvas.create_rectangle(330, 30, 330+20, 30+20)                  # 画矩形正方形
    canvas.pack()
    
    # 第6步,触发函数,用来一定指定图形
    def moveit():
        canvas.move(rect, 2, 2) # 移动正方形rect(也可以改成其他图形名字用以移动一起图形、元素),按每次(x=2, y=2)步长进行移动
    
    # 第5步,定义一个按钮用来移动指定图形的在画布上的位置
    b = tk.Button(window, text='move item',command=moveit).pack()
    
    # 第7步,主窗口循环显示
    window.mainloop()
    

      所用图片:

      当然你可以随意用你的一张图片导入画布试一试效果,图片可以用画图工具改一下像素大小,以免图片太大,导入画布显示不全,当然你也可以用我提供的素材,下面是链接:https://files.cnblogs.com/files/shwee/pic.gif

     

      图片锚定点位置参数图:

      测试效果:

    10. Menu窗口部件

      简单说明:  

      Menu:菜单条,用来实现下拉和弹出式菜单,点下菜单后弹出的一个选项列表,用户可以从中选择

      什么时候用:

      在比如像软件或网页交互界面等,需要提供菜单选项功能提供用户选择菜单选项功能时用到。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签用以显示内容并放置
    l = tk.Label(window, text='      ', bg='green')
    l.pack()
    
    # 第10步,定义一个函数功能,用来代表菜单选项的功能,这里为了操作简单,定义的功能比较简单
    counter = 0
    def do_job():
        global counter
        l.config(text='do '+ str(counter))
        counter += 1
    
    # 第5步,创建一个菜单栏,这里我们可以把他理解成一个容器,在窗口的上方
    menubar = tk.Menu(window)
    
    # 第6步,创建一个File菜单项(默认不下拉,下拉内容包括New,Open,Save,Exit功能项)
    filemenu = tk.Menu(menubar, tearoff=0)
    # 将上面定义的空菜单命名为File,放在菜单栏中,就是装入那个容器中
    menubar.add_cascade(label='File', menu=filemenu)
    
    # 在File中加入New、Open、Save等小菜单,即我们平时看到的下拉菜单,每一个小菜单对应命令操作。
    filemenu.add_command(label='New', command=do_job)
    filemenu.add_command(label='Open', command=do_job)
    filemenu.add_command(label='Save', command=do_job)
    filemenu.add_separator()    # 添加一条分隔线
    filemenu.add_command(label='Exit', command=window.quit) # 用tkinter里面自带的quit()函数
    
    # 第7步,创建一个Edit菜单项(默认不下拉,下拉内容包括Cut,Copy,Paste功能项)
    editmenu = tk.Menu(menubar, tearoff=0)
    # 将上面定义的空菜单命名为 Edit,放在菜单栏中,就是装入那个容器中
    menubar.add_cascade(label='Edit', menu=editmenu)
    
    # 同样的在 Edit 中加入Cut、Copy、Paste等小命令功能单元,如果点击这些单元, 就会触发do_job的功能
    editmenu.add_command(label='Cut', command=do_job)
    editmenu.add_command(label='Copy', command=do_job)
    editmenu.add_command(label='Paste', command=do_job)
    
    # 第8步,创建第二级菜单,即菜单项里面的菜单
    submenu = tk.Menu(filemenu) # 和上面定义菜单一样,不过此处实在File上创建一个空的菜单
    filemenu.add_cascade(label='Import', menu=submenu, underline=0) # 给放入的菜单submenu命名为Import
    
    # 第9步,创建第三级菜单命令,即菜单项里面的菜单项里面的菜单命令(有点拗口,笑~~~)
    submenu.add_command(label='Submenu_1', command=do_job)   # 这里和上面创建原理也一样,在Import菜单项中加入一个小菜单命令Submenu_1
    
    # 第11步,创建菜单栏完成后,配置让菜单栏menubar显示出来
    window.config(menu=menubar)
    
    # 第12步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    11. Frame 窗口部件

      简单说明:  

      Frame:框架,用来承载放置其他GUI元素,就是一个容器,是一个在 Windows 上分离小区域的部件, 它能将 Windows 分成不同的区,然后存放不同的其他部件. 同时一个 Frame 上也能再分成两个 Frame, Frame 可以认为是一种容器.

      什么时候用:

      在比如像软件或网页交互界面等,有不同的界面逻辑层级和功能区域划分时可以用到,让交互界面逻辑更加清晰。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,在图形界面上创建一个标签用以显示内容并放置
    tk.Label(window, text='on the window', bg='red', font=('Arial', 16)).pack()   # 和前面部件分开创建和放置不同,其实可以创建和放置一步完成
    
    # 第5步,创建一个主frame,长在主window窗口上
    frame = tk.Frame(window)
    frame.pack()
    
    # 第6步,创建第二层框架frame,长在主框架frame上面
    frame_l = tk.Frame(frame)# 第二层frame,左frame,长在主frame上
    frame_r = tk.Frame(frame)# 第二层frame,右frame,长在主frame上
    frame_l.pack(side='left')
    frame_r.pack(side='right')
    
    # 第7步,创建三组标签,为第二层frame上面的内容,分为左区域和右区域,用不同颜色标识
    tk.Label(frame_l, text='on the frame_l1', bg='green').pack()
    tk.Label(frame_l, text='on the frame_l2', bg='green').pack()
    tk.Label(frame_l, text='on the frame_l3', bg='green').pack()
    tk.Label(frame_r, text='on the frame_r1', bg='yellow').pack()
    tk.Label(frame_r, text='on the frame_r2', bg='yellow').pack()
    tk.Label(frame_r, text='on the frame_r3', bg='yellow').pack()
    
    # 第8步,主窗口循环显示
    window.mainloop()
    

      测试效果:

     

    12. messageBox窗口部件

      简单说明:  

      messageBox:消息框,用于显示你应用程序的消息框。(Python2中为tkMessagebox),其实这里的messageBox就是我们平时看到的弹窗。 我们首先需要定义一个触发功能,来触发这个弹窗,这里我们就放上以前学过的button按钮,通过触发功能,调用messagebox吧,点击button按钮就会弹出提示对话框。下面给出messagebox提示信息的几种形式:

    tkinter.messagebox.showinfo(title='Hi', message='你好!')            # 提示信息对话窗
    tkinter.messagebox.showwarning(title='Hi', message='有警告!')       # 提出警告对话窗
    tkinter.messagebox.showerror(title='Hi', message='出错了!')         # 提出错误对话窗
    print(tkinter.messagebox.askquestion(title='Hi', message='你好!'))  # 询问选择对话窗return 'yes', 'no'
    print(tkinter.messagebox.askyesno(title='Hi', message='你好!'))     # return 'True', 'False'
    print(tkinter.messagebox.askokcancel(title='Hi', message='你好!'))  # return 'True', 'False'

      什么时候用:

      在比如像软件或网页交互界面等,有不同的界面逻辑层级和功能区域划分时可以用到,让交互界面逻辑更加清晰。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    import tkinter.messagebox  # 要使用messagebox先要导入模块
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第5步,定义触发函数功能
    def hit_me():
        tkinter.messagebox.showinfo(title='Hi', message='你好!')              # 提示信息对话窗
        # tkinter.messagebox.showwarning(title='Hi', message='有警告!')       # 提出警告对话窗
        # tkinter.messagebox.showerror(title='Hi', message='出错了!')         # 提出错误对话窗
        # print(tkinter.messagebox.askquestion(title='Hi', message='你好!'))  # 询问选择对话窗return 'yes', 'no'
        # print(tkinter.messagebox.askyesno(title='Hi', message='你好!'))     # return 'True', 'False'
        # print(tkinter.messagebox.askokcancel(title='Hi', message='你好!'))  # return 'True', 'False'
    
    # 第4步,在图形界面上创建一个标签用以显示内容并放置
    tk.Button(window, text='hit me', bg='green', font=('Arial', 14), command=hit_me).pack()
    
    # 第6步,主窗口循环显示
    window.mainloop()
    

      测试效果:

     

    13. 窗口部件三种放置方式pack/grid/place

      参考来源:

    The Grid Geometry Manager
    The Pack Geometry Manager
    The Place Geometry Manager

      1. Grid:The Grid Geometry Manager  

      grid 是方格, 所以所有的内容会被放在这些规律的方格中。例如:

    for i in range(3):
        for j in range(3):
            tk.Label(window, text=1).grid(row=i, column=j, padx=10, pady=10, ipadx=10, ipady=10)

      以上的代码就是创建一个三行三列的表格,其实 grid 就是用表格的形式定位的。这里的参数 row 为行,colum 为列,padx 就是单元格左右间距,pady 就是单元格上下间距,ipadx是单元格内部元素与单元格的左右间距,ipady是单元格内部元素与单元格的上下间距。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,grid 放置方法
    for i in range(3):
        for j in range(3):
            tk.Label(window, text=1).grid(row=i, column=j, padx=10, pady=10, ipadx=10, ipady=10)
    
    # 第5步,主窗口循环显示
    window.mainloop()
    

      测试效果:

     

      2. Pack:The Pack Geometry Manager

       我们常用的pack(), 他会按照上下左右的方式排列.例如:

    tk.Label(window, text='P', fg='red').pack(side='top')    # 上
    tk.Label(window, text='P', fg='red').pack(side='bottom') # 下
    tk.Label(window, text='P', fg='red').pack(side='left')   # 左
    tk.Label(window, text='P', fg='red').pack(side='right')  # 右

       示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,pack 放置方法
    tk.Label(window, text='P', fg='red').pack(side='top')    # 上
    tk.Label(window, text='P', fg='red').pack(side='bottom') # 下
    tk.Label(window, text='P', fg='red').pack(side='left')   # 左
    tk.Label(window, text='P', fg='red').pack(side='right')  # 右
    
    # 第5步,主窗口循环显示
    window.mainloop()
    

      测试效果:

      3. Place:The Place Geometry Manager

       再接下来我们来看place(), 这个比较容易理解,就是给精确的坐标来定位,如此处给的(50, 100),就是将这个部件放在坐标为(x=50, y=100)的这个位置, 后面的参数 anchor='nw',就是前面所讲的锚定点是西北角。例如:

    tk.Label(window, text='Pl', font=('Arial', 20), ).place(x=50, y=100, anchor='nw')
    

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('My Window')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('500x300')  # 这里的乘是小x
    
    # 第4步,place 放置方法(精准的放置到指定坐标点的位置上)
    tk.Label(window, text='Pl', font=('Arial', 20), ).place(x=50, y=100, anchor='nw')
    
    # 第5步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    14. 综合练习,用户登录窗口例子

      编写一个用户登录界面,用户可以登录账户信息,如果账户已经存在,可以直接登录,登录名或者登录密码输入错误会提示,如果账户不存在,提示用户注册,点击注册进去注册页面,输入注册信息,确定后便可以返回登录界面进行登录。

      示例代码:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # author:洪卫
    
    import tkinter as tk  # 使用Tkinter前需要先导入
    import tkinter.messagebox
    import pickle
    
    # 第1步,实例化object,建立窗口window
    window = tk.Tk()
    
    # 第2步,给窗口的可视化起名字
    window.title('Wellcome to Hongwei Website')
    
    # 第3步,设定窗口的大小(长 * 宽)
    window.geometry('400x300')  # 这里的乘是小x
    
    # 第4步,加载 wellcome image
    canvas = tk.Canvas(window, width=400, height=135, bg='green')
    image_file = tk.PhotoImage(file='pic.gif')
    image = canvas.create_image(200, 0, anchor='n', image=image_file)
    canvas.pack(side='top')
    tk.Label(window, text='Wellcome',font=('Arial', 16)).pack()
    
    # 第5步,用户信息
    tk.Label(window, text='User name:', font=('Arial', 14)).place(x=10, y=170)
    tk.Label(window, text='Password:', font=('Arial', 14)).place(x=10, y=210)
    
    # 第6步,用户登录输入框entry
    # 用户名
    var_usr_name = tk.StringVar()
    var_usr_name.set('example@python.com')
    entry_usr_name = tk.Entry(window, textvariable=var_usr_name, font=('Arial', 14))
    entry_usr_name.place(x=120,y=175)
    # 用户密码
    var_usr_pwd = tk.StringVar()
    entry_usr_pwd = tk.Entry(window, textvariable=var_usr_pwd, font=('Arial', 14), show='*')
    entry_usr_pwd.place(x=120,y=215)
    
    # 第8步,定义用户登录功能
    def usr_login():
        # 这两行代码就是获取用户输入的usr_name和usr_pwd
        usr_name = var_usr_name.get()
        usr_pwd = var_usr_pwd.get()
    
        # 这里设置异常捕获,当我们第一次访问用户信息文件时是不存在的,所以这里设置异常捕获。
        # 中间的两行就是我们的匹配,即程序将输入的信息和文件中的信息匹配。
        try:
            with open('usrs_info.pickle', 'rb') as usr_file:
                usrs_info = pickle.load(usr_file)
        except FileNotFoundError:
            # 这里就是我们在没有读取到`usr_file`的时候,程序会创建一个`usr_file`这个文件,并将管理员
            # 的用户和密码写入,即用户名为`admin`密码为`admin`。
            with open('usrs_info.pickle', 'wb') as usr_file:
                usrs_info = {'admin': 'admin'}
                pickle.dump(usrs_info, usr_file)
                usr_file.close()    # 必须先关闭,否则pickle.load()会出现EOFError: Ran out of input
    
        # 如果用户名和密码与文件中的匹配成功,则会登录成功,并跳出弹窗how are you? 加上你的用户名。
        if usr_name in usrs_info:
            if usr_pwd == usrs_info[usr_name]:
                tkinter.messagebox.showinfo(title='Welcome', message='How are you? ' + usr_name)
            # 如果用户名匹配成功,而密码输入错误,则会弹出'Error, your password is wrong, try again.'
            else:
                tkinter.messagebox.showerror(message='Error, your password is wrong, try again.')
        else:  # 如果发现用户名不存在
            is_sign_up = tkinter.messagebox.askyesno('Welcome! ', 'You have not sign up yet. Sign up now?')
            # 提示需不需要注册新用户
            if is_sign_up:
                usr_sign_up()
    
    # 第9步,定义用户注册功能
    def usr_sign_up():
        def sign_to_Hongwei_Website():
            # 以下三行就是获取我们注册时所输入的信息
            np = new_pwd.get()
            npf = new_pwd_confirm.get()
            nn = new_name.get()
    
            # 这里是打开我们记录数据的文件,将注册信息读出
            with open('usrs_info.pickle', 'rb') as usr_file:
                exist_usr_info = pickle.load(usr_file)
            # 这里就是判断,如果两次密码输入不一致,则提示Error, Password and confirm password must be the same!
            if np != npf:
                tkinter.messagebox.showerror('Error', 'Password and confirm password must be the same!')
    
            # 如果用户名已经在我们的数据文件中,则提示Error, The user has already signed up!
            elif nn in exist_usr_info:
                tkinter.messagebox.showerror('Error', 'The user has already signed up!')
    
            # 最后如果输入无以上错误,则将注册输入的信息记录到文件当中,并提示注册成功Welcome!,You have successfully signed up!,然后销毁窗口。
            else:
                exist_usr_info[nn] = np
                with open('usrs_info.pickle', 'wb') as usr_file:
                    pickle.dump(exist_usr_info, usr_file)
                tkinter.messagebox.showinfo('Welcome', 'You have successfully signed up!')
                # 然后销毁窗口。
                window_sign_up.destroy()
    
        # 定义长在窗口上的窗口
        window_sign_up = tk.Toplevel(window)
        window_sign_up.geometry('300x200')
        window_sign_up.title('Sign up window')
    
        new_name = tk.StringVar()  # 将输入的注册名赋值给变量
        new_name.set('example@python.com')  # 将最初显示定为'example@python.com'
        tk.Label(window_sign_up, text='User name: ').place(x=10, y=10)  # 将`User name:`放置在坐标(10,10)。
        entry_new_name = tk.Entry(window_sign_up, textvariable=new_name)  # 创建一个注册名的`entry`,变量为`new_name`
        entry_new_name.place(x=130, y=10)  # `entry`放置在坐标(150,10).
    
        new_pwd = tk.StringVar()
        tk.Label(window_sign_up, text='Password: ').place(x=10, y=50)
        entry_usr_pwd = tk.Entry(window_sign_up, textvariable=new_pwd, show='*')
        entry_usr_pwd.place(x=130, y=50)
    
        new_pwd_confirm = tk.StringVar()
        tk.Label(window_sign_up, text='Confirm password: ').place(x=10, y=90)
        entry_usr_pwd_confirm = tk.Entry(window_sign_up, textvariable=new_pwd_confirm, show='*')
        entry_usr_pwd_confirm.place(x=130, y=90)
    
        # 下面的 sign_to_Hongwei_Website
        btn_comfirm_sign_up = tk.Button(window_sign_up, text='Sign up', command=sign_to_Hongwei_Website)
        btn_comfirm_sign_up.place(x=180, y=120)
    
    # 第7步,login and sign up 按钮
    btn_login = tk.Button(window, text='Login', command=usr_login)
    btn_login.place(x=120, y=240)
    btn_sign_up = tk.Button(window, text='Sign up', command=usr_sign_up)
    btn_sign_up.place(x=200, y=240)
    
    # 第10步,主窗口循环显示
    window.mainloop()
    

      测试效果:

    15. 其他部件后续再补充...

     注:不同电脑可能配置环境略有不同,如有小错误可以自己调试一下。

    展开全文
  • tkinter库入门详细教程(一):简单窗口的设置

    万次阅读 多人点赞 2018-07-30 23:01:08
    更多内容请看tkinter库入门详细教程(二) 1.初始状态 2.点击按钮后 3.再次点击按钮后 源代码: import tkinter as tk # 设置窗口 window = tk.Tk() # 建立一个窗口 window.title('一个最简单的窗口') ...

    本节主要介绍一个最简单的窗口的设置。更多内容请看tkinter库入门详细教程(二)

    1.初始状态

    2.点击按钮后

    3.再次点击按钮后

    源代码:

    import tkinter as tk
    
    
    # 设置窗口
    window = tk.Tk()  # 建立一个窗口
    window.title('一个最简单的窗口')
    window.geometry('300x200')  # 窗口大小为300x200
    
    
    var = tk.StringVar()  # 文字变量储存器
    
    
    # 设置标签
    l = tk.Label(textvar=var, bg='yellow', width=20, height=2)  # 参数textvar不同于text,bg是backgroud
    l.pack()  # 放置标签
    
    
    bon = False
    
    
    def hit_me():  # 该函数实现按一次按钮显示出字,再按一次字消失
        global bon  # bon为全局变量
        if bon == False:
            bon = True
            var.set('惊喜想得美')
        else:
            bon = False
            var.set('')
    
    
    # 设置按钮
    b = tk.Button(text='点击我有惊喜', width=20, height=2, command=hit_me)
    b.pack()
    
    
    window.mainloop()  # 循环,时刻刷新窗口

    更多内容请看tkinter库入门详细教程(二)

    注:题目来源于莫烦python

    展开全文
  • 更多内容请看tkinter库入门详细教程(三) 如上图所示,在输入窗口输入字符串后,选择在‘在光标处插入’或‘在末尾处插入’,文本显示框能显示出相应内容。 源代码: import tkinter as tk # 设置窗口 window...
  • Python-GUI-Tkinter教程

    2015-01-11 11:17:11
    Python的GUI(Tkinter)教程,英文版,简单易学,有很详细的说明,和源代码,适合初学者!
  • Python_Tkinter教程.pdf

    2019-08-14 09:46:41
    本文档详细的介绍了Python的Tkinter图形框架的教程,如果设计图形界面不想安装过多的库和插件,Tkinter再合适不过了,轻量简单,满足GUI设计的基本需求。
  • Python中Tkinter 图形化界面设计(详细教程

    千次阅读 多人点赞 2020-12-08 17:41:41
    Python-Tkinter 图形化界面设计(详细教程)一、图形化界面设计的基本理解二、 窗体控件布局2.1 根窗体呈现示例2.2 tkinter 常用控件2.2.1常用控件2.2.2 控件的共同属性2.3 控件布局2.3.1 place() 使用方法三、...
  • 将Matplotlib绘制的图显示到Tkinter中(详细教程

    万次阅读 多人点赞 2019-06-13 20:56:38
    root = tkinter.Tk() # 创建tkinter的主窗口 root.title("在tkinter中使用matplotlib") f = Figure(figsize=(5, 4), dpi=100) a = f.add_subplot(111) # 添加子图:1行1列第1个 # 生成用于绘sin图的数据 x = np.a...
  • Python GUI之tkinter教程

    2019-06-03 20:50:05
    一、前言  由于本篇文章较长,所以下面给出内容目录... 三、Tkinter 控件详细介绍  1. Tkinter 模块元素简要说明  2. 常用窗口部件及简要说明:  四、动手实践学习  1. 创建主窗口及Label部件(标签)创建使用...
  • 主要介绍了python tkinter事件绑定,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 串口数据读取和动态显示Tkinter+matplotlib+pyqtgraph(详细教程) 注意 :本函数已将pyqtgraph动态绘图隐藏,在main函数中去除隐藏便可以显示,但是没有嵌入到tkinter 运行环境: win10,python3.5.2 效果图1 ...
  • 三、Tkinter 控件详细介绍 1. Tkinter 模块元素简要说明 2. 常用窗口部件及简要说明: 二、Tkinter是什么  Tkinter 是使用 python 进行窗口视窗设计的模块。Tkinter模块(“Tk 接口”)是Python的标准Tk GUI工具包的...
  • Python GUI之tkinter 教程大集合

    千次阅读 2019-05-26 10:39:36
    三、Tkinter 控件详细介绍 1. Tkinter 模块元素简要说明 2. 常用窗口部件及简要说明: 四、动手实践学习 1. 创建主窗口及Label部件(标签)创建使用 2. Button窗口部件 3. Entry窗口部件 4. Text...
  • 三、tkinter常见控件的特征属性 3.1 文本输入和输出相关控件 3.1.1 标签(Label)和 消息(Message) 文本的输入与输出控件通常包括:标签(Label)、消息(Message)、输入框(Entry)、文本框(Text)。他们除了...
  • Python GUI之tkinter窗口视窗教程大集合

    千次阅读 多人点赞 2019-05-13 09:26:29
    Python GUI之tkinter窗口视窗教程大集合一、前言二、Tkinter是什么三、Tkinter 控件详细介绍1. Tkinter 模块元素简要说明2. 常用窗口部件及简要说明:四、动手实践学习1. 创建主窗口及Label部件(标签)创建使用2. ...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

tkinter详细教程