精华内容
下载资源
问答
  • 简介对于想学Python图形化编程的小伙伴来说,easygui是一个很好图形入门编程模块!函数介绍ccbox()——双项选择cc表示continue 还是 cancel他返回的是1和0,但是不代表True和False,但是在if里面还是可以用1和0,...

    简介

    对于想学Python图形化编程的小伙伴来说,easygui是一个很好图形化入门编程模块!

    函数介绍

    ccbox()——双项选择

    cc表示continue 还是 cancel

    他返回的是1和0,但是不代表True和False,但是在if里面还是可以用1和0,另外,选项后面还可以加,自己随意。

    msgbox()——消息弹窗

    msgbox(msg=' ', title=' ', ok_button=' ', image=None, root=None)

    该函数一般调用前三个关键字即可,加载图片的话给image赋值需要下载其他库,否则只能加载GIF。

    环境安装

    案例:编写界面选择小游戏

    代码如下:

    import easygui as eg

    import sys

    while True:

    eg.msgbox(" 嗨,欢迎进入第一个界面小游戏^_^",'主界面')

    #消息主体

    msg =" 请问你平时的爱好是啥?"

    #对话框标题

    title = "小游戏互动"

    #选项

    choices = ["书法", "篮球", "乒乓球", "游戏"]

    choice = eg.choicebox(msg, title, choices)

    # 注意,msgbox的参数是一个字符串

    # 如果用户选择Cancel,该函数返回None

    eg.msgbox(" 你的选择是: " + str(choice)+ ' !', "结果")

    msg = " 你希望重新开始小游戏吗?"

    title = " 请选择"

    # 弹出一个Continue/Cancel对话框

    if eg.ccbox(msg, title):

    pass # 如果用户选择Continue

    else:

    sys.exit(0) # 如果用户选择Cancel

    运行效果

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    选择返回主界面或退出

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    退出游戏

    watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=

    展开全文
  • Python 图形化界面设计

    万次阅读 多人点赞 2019-05-30 21:40:24
    1、图形化界面设计的基本理解 当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单、按钮等图形化元素触发指令,并从标签、对话框等图型显示容器中获取人机对话...

    1、图形化界面设计的基本理解

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

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

    2、窗体控件布局

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

       
      1. from tkinter import *

      2. root= Tk()

      3. root.title('我的第一个Python窗体')

      4. root.geometry('240x240') # 这里的乘号不是 * ,而是小写英文字母 x

      5. root.mainloop()

      根窗体呈现示例

    • 2.2、tkinter 常用控件

      控件名称作用
      Button按钮单击触发事件
      Canvas画布绘制图形或绘制特殊控件
      Checkbutton复选框多项选择
      Entry输入框接收单行文本输入
      Frame框架用于控件分组
      Label标签单行文本显示
      Lisbox列表框显示文本列表
      Menu菜单创建菜单命令
      Message消息多行文本标签,与Label 用法类似
      Radiobutton单选按钮从互斥的多个选项中做单项选择
      Scale滑块默认垂直方向,鼠标拖动改变数值形成可视化交互
      Scrollbar滑动条默认垂直方向,课鼠标拖动改变数值,可与 Text、Lisbox、Canvas等控件配合移动可视化空间
      Text文本框接收或输出显示多行文本
      Toplevel新建窗体容器在顶层创建新窗体
      • 常用控件:常用的10 多种,如下:
      • 控件的共同属性:在窗体上呈现的可视化控件,通常包括尺寸、颜色、字体、相对位置、浮雕样式、图标样式和悬停光标形状等共同属性。不同的控件由于形状和功能不同,又有其特征属性。在初始化根窗体和根窗体主循环之间,可实例化窗体控件,并设置其属性。父容器可为根窗体或其他容器控件实例。常见的控件共同属性如下表:

        属性说明取值
        anchor文本起始位置CENTER(默认),E,S,W,N,NE,SE,SW,NW
        bg背景色
        bd加粗(默认 2 像素)
        bitmap黑白二值图标网上查找
        cursor鼠标悬停光标网上查找
        font字体
        fg前景色
        height高(文本控件的单位为行,不是像素)
        image显示图像
        justify多行文本的对其方式CENTER(默认),LEFT,RIGHT,TOP,BOTTOM
        padx水平扩展像素
        pady垂直扩展像素
        relief3D浮雕样式FLAT,RAISED,SUNKEN,GROOVE,RIDGE
        state控件实例状态是否可用NORMAL(默认),DISABLED
        width宽(文本控件的单位为行,不是像素)

        标签及常见属性示例:

         
        1. from tkinter import *

        2. root = Tk()

        3. lb = Label(root,text='我是第一个标签',\

        4. bg='#d3fbfb',\

        5. fg='red',\

        6. font=('华文新魏',32),\

        7. width=20,\

        8. height=2,\

        9. relief=SUNKEN)

        10. lb.pack()

        11. 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种。

     

    控件呈现的5种浮雕样式

    • 2.2、控件布局
      控件的布局通常有pack()grid() 和 place() 三种方法。

      • 2.2.1、pack()方法:是一种简单的布局方法,如果不加参数的默认方式,将按布局语句的先后,以最小占用空间的方式自上而下地排列控件实例,并且保持控件本身的最小尺寸。如下的例子:

        •  

           

          用pack() 方法不加参数排列标签。为看清楚各控件所占用的空间大小,文本用了不同长度的中英文,并设置relief=GROOVE的凹陷边缘属性。如下所示:

           
          1. from tkinter import *

          2. root = Tk()

          3.  
          4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

          5. lbred.pack()

          6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

          7. lbgreen.pack()

          8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

          9. lbblue.pack()

          10. root.mainloop()

        • 使用pack()方法可设置 fill、side 等属性参数。其中,参数fill 可取值:fill=X,fill=Y或fill=BOTH,分别表示允许控件向水平方向、垂直方向或二维伸展填充未被占用控件。参数 side 可取值:side=TOP(默认),side=LEFT,side=RIGHT,side=BOTTOM,分别表示本控件实例的布局相对于下一个控件实例的方位。如下例子:

           

          用pack()方法加参数排列标签

           
          1. from tkinter import *

          2. root = Tk()

          3.  
          4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

          5. lbred.pack()

          6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

          7. lbgreen.pack(side=RIGHT)

          8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

          9. lbblue.pack(fill=X)

          10. root.mainloop()

      • 2.2.2、grid()方法:是基于网格的布局。先虚拟一个二维表格,再在该表格中布局控件实例。由于在虚拟表格的单元中所布局的控件实例大小不一,单元格也没有固定或均一的大小,因此其仅用于布局的定位。pack()方法与grid()方法不能混合使用。
        grid()方法常用布局参数如下:

        看下面的例子:用grid()方法排列标签,设想有一个3x4的表格,起始行、列序号均为0.将标签lbred 至于第2列第0行;将标签lbgreen置于第0列第1行;将标签lbblue置于第1列起跨2列第2行,占20像素宽。

         

        pack()方法排列标签

         
        1. from tkinter import *

        2. root = Tk()

        3.  
        4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

        5. lbred.grid(column=2,row=0)

        6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

        7. lbgreen.grid(column=0,row=1)

        8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

        9. lbblue.grid(column=1,columnspan=2,ipadx=20,row=2)

        10. root.mainloop()

        • column: 控件实例的起始列,最左边为第0列。
        • columnspan: 控件实例所跨越的列数,默认为1列。
        • ipadx,ipady: 控件实例所呈现区域内部的像素数,用来设置控件实例的大小。
        • padx,pady: 控件实例所占据空间像素数,用来设置实例所在单元格的大小。
        • row: 控件实例的起始行,最上面为第0行。
        • rowspan: 控件实例的起始行数,默认为1行。
      • 2.2.3、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()方法排列消息(多行标签)。

           

          place()方法排列消息

           
          1. from tkinter import *

          2. root = Tk()

          3. root.geometry('320x240')

          4.  
          5. msg1 = Message(root,text='''我的水平起始位置相对窗体 0.2,垂直起始位置为绝对位置 80 像素,我的高度是窗体高度的0.4,宽度是200像素''',relief=GROOVE)

          6. msg1.place(relx=0.2,y=80,relheight=0.4,width=200)

          7. root.mainloop()

    • 3、tkinter常见控件的特征属性

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

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

          • 方法一:利用configure()方法或config()来实现文本变化。

             

             
            1. import tkinter

            2. import time

            3.  
            4. def gettime():

            5. timestr = time.strftime("%H:%M:%S") # 获取当前的时间并转化为字符串

            6. lb.configure(text=timestr) # 重新设置标签文本

            7. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

            8.  
            9. root = tkinter.Tk()

            10. root.title('时钟')

            11.  
            12. lb = tkinter.Label(root,text='',fg='blue',font=("黑体",80))

            13. lb.pack()

            14. gettime()

            15. root.mainloop()

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

             
            1. import tkinter

            2. import time

            3.  
            4. def gettime():

            5. var.set(time.strftime("%H:%M:%S")) # 获取当前时间

            6. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

            7.  
            8. root = tkinter.Tk()

            9. root.title('时钟')

            10. var=tkinter.StringVar()

            11.  
            12. lb = tkinter.Label(root,textvariable=var,fg='blue',font=("黑体",80))

            13. lb.pack()

            14. gettime()

            15. root.mainloop()

        • 文本框(Text)

          文本框的常用方法如下:

          方法功能
          delete(起始位置,[,终止位置])删除指定区域文本
          get(起始位置,[,终止位置])获取指定区域文本
          insert(位置,[,字符串]...)将文本插入到指定位置
          see(位置)在指定位置是否可见文本,返回布尔值
          index(标记)返回标记所在的行和列
          mark_names()返回所有标记名称
          mark_set(标记,位置)在指定位置设置标记
          mark_unset(标记)去除标记

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

          获取当前日期的时间并写入文本中

           

           
          1. from tkinter import *

          2. import time

          3. import datetime

          4.  
          5. def gettime():

          6. s=str(datetime.datetime.now())+'\n'

          7. txt.insert(END,s)

          8. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

          9.  
          10. root=Tk()

          11. root.geometry('320x240')

          12. txt=Text(root)

          13. txt.pack()

          14. gettime()

          15. root.mainloop()

        • 输入框(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)同时传递参数实现。

           

          简单加法器

           
          1. from tkinter import *

          2.  
          3. def run1():

          4. a = float(inp1.get())

          5. b = float(inp2.get())

          6. s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)

          7. txt.insert(END, s) # 追加显示运算结果

          8. inp1.delete(0, END) # 清空输入

          9. inp2.delete(0, END) # 清空输入

          10.  
          11. def run2(x, y):

          12. a = float(x)

          13. b = float(y)

          14. s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)

          15. txt.insert(END, s) # 追加显示运算结果

          16. inp1.delete(0, END) # 清空输入

          17. inp2.delete(0, END) # 清空输入

          18.  
          19. root = Tk()

          20. root.geometry('460x240')

          21. root.title('简单加法器')

          22.  
          23. lb1 = Label(root, text='请输入两个数,按下面两个按钮之一进行加法计算')

          24. lb1.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)

          25. inp1 = Entry(root)

          26. inp1.place(relx=0.1, rely=0.2, relwidth=0.3, relheight=0.1)

          27. inp2 = Entry(root)

          28. inp2.place(relx=0.6, rely=0.2, relwidth=0.3, relheight=0.1)

          29.  
          30. # 方法-直接调用 run1()

          31. btn1 = Button(root, text='方法一', command=run1)

          32. btn1.place(relx=0.1, rely=0.4, relwidth=0.3, relheight=0.1)

          33.  
          34. # 方法二利用 lambda 传参数调用run2()

          35. btn2 = Button(root, text='方法二', command=lambda: run2(inp1.get(), inp2.get()))

          36. btn2.place(relx=0.6, rely=0.4, relwidth=0.3, relheight=0.1)

          37.  
          38. # 在窗体垂直自上而下位置60%处起,布局相对窗体高度40%高的文本框

          39. txt = Text(root)

          40. txt.place(rely=0.6, relheight=0.4)

          41.  
          42. root.mainloop()

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

        单选按钮

         

         
        1. from tkinter import *

        2. def Mysel():

        3. dic = {0:'甲',1:'乙',2:'丙'}

        4. s = "您选了" + dic.get(var.get()) + "项"

        5. lb.config(text = s)

        6.  
        7. root = Tk()

        8. root.title('单选按钮')

        9. lb = Label(root)

        10. lb.pack()

        11.  
        12. var = IntVar()

        13. rd1 = Radiobutton(root,text="甲",variable=var,value=0,command=Mysel)

        14. rd1.pack()

        15.  
        16. rd2 = Radiobutton(root,text="乙",variable=var,value=1,command=Mysel)

        17. rd2.pack()

        18.  
        19. rd3 = Radiobutton(root,text="丙",variable=var,value=2,command=Mysel)

        20. rd3.pack()

        21.  
        22. 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 分支实现多项显示

             
            1. from tkinter import *

            2. import tkinter

            3.  
            4. def run():

            5. if(CheckVar1.get()==0 and CheckVar2.get()==0 and CheckVar3.get()==0 and CheckVar4.get()==0):

            6. s = '您还没选择任何爱好项目'

            7. else:

            8. s1 = "足球" if CheckVar1.get()==1 else ""

            9. s2 = "篮球" if CheckVar2.get() == 1 else ""

            10. s3 = "游泳" if CheckVar3.get() == 1 else ""

            11. s4 = "田径" if CheckVar4.get() == 1 else ""

            12. s = "您选择了%s %s %s %s" % (s1,s2,s3,s4)

            13. lb2.config(text=s)

            14.  
            15. root = tkinter.Tk()

            16. root.title('复选框')

            17. lb1=Label(root,text='请选择您的爱好项目')

            18. lb1.pack()

            19.  
            20. CheckVar1 = IntVar()

            21. CheckVar2 = IntVar()

            22. CheckVar3 = IntVar()

            23. CheckVar4 = IntVar()

            24.  
            25. ch1 = Checkbutton(root,text='足球',variable = CheckVar1,onvalue=1,offvalue=0)

            26. ch2 = Checkbutton(root,text='篮球',variable = CheckVar2,onvalue=1,offvalue=0)

            27. ch3 = Checkbutton(root,text='游泳',variable = CheckVar3,onvalue=1,offvalue=0)

            28. ch4 = Checkbutton(root,text='田径',variable = CheckVar4,onvalue=1,offvalue=0)

            29.  
            30. ch1.pack()

            31. ch2.pack()

            32. ch3.pack()

            33. ch4.pack()

            34.  
            35. btn = Button(root,text="OK",command=run)

            36. btn.pack()

            37.  
            38. lb2 = Label(root,text='')

            39. lb2.pack()

            40. root.mainloop()

      • 3.5、列表框 与 组合框

        方法功能描述
        curselection()返回光标选中项目编号的元组,注意并不是单个的整数
        delete(起始位置,终止位置)删除项目,终止位置可省略,全部清空为delete(0,END)
        get(起始位置,终止位)返回范围所含项目文本的元组,终止位置可忽略
        insert(位置,项目元素)插入项目元素(若有多项,可用列表或元组类型赋值),若位置为END,则将项目元素添加在最后
        size()返回列表框行数

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

        列表框的应用

         

         
        1. from tkinter import *

        2. def ini():

        3. Lstbox1.delete(0,END)

        4. list_items = ["数学","物理","化学","语文","外语"]

        5. for item in list_items:

        6. Lstbox1.insert(END,item)

        7.  
        8. def clear():

        9. Lstbox1.delete(0,END)

        10.  
        11. def ins():

        12. if entry.get() != '':

        13. if Lstbox1.curselection() == ():

        14. Lstbox1.insert(Lstbox1.size(),entry.get())

        15. else:

        16. Lstbox1.insert(Lstbox1.curselection(),entry.get())

        17.  
        18. def updt():

        19. if entry.get() != '' and Lstbox1.curselection() != ():

        20. selected=Lstbox1.curselection()[0]

        21. Lstbox1.delete(selected)

        22. Lstbox1.insert(selected,entry.get())

        23.  
        24. def delt():

        25. if Lstbox1.curselection() != ():

        26. Lstbox1.delete(Lstbox1.curselection())

        27.  
        28. root = Tk()

        29. root.title('列表框实验')

        30. root.geometry('320x240')

        31.  
        32. frame1 = Frame(root,relief=RAISED)

        33. frame1.place(relx=0.0)

        34.  
        35. frame2 = Frame(root,relief=GROOVE)

        36. frame2.place(relx=0.5)

        37.  
        38. Lstbox1 = Listbox(frame1)

        39. Lstbox1.pack()

        40.  
        41. entry = Entry(frame2)

        42. entry.pack()

        43.  
        44. btn1 = Button(frame2,text='初始化',command=ini)

        45. btn1.pack(fill=X)

        46.  
        47. btn2 = Button(frame2,text='添加',command=ins)

        48. btn2.pack(fill=X)

        49.  
        50. btn3 = Button(frame2,text='插入',command=ins) # 添加和插入功能实质上是一样的

        51. btn3.pack(fill=X)

        52.  
        53. btn4 = Button(frame2,text='修改',command=updt)

        54. btn4.pack(fill=X)

        55.  
        56. btn5 = Button(frame2,text='删除',command=delt)

        57. btn5.pack(fill=X)

        58.  
        59. btn6 = Button(frame2,text='清空',command=clear)

        60. btn6.pack(fill=X)

        61.  
        62. root.mainloop()

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

          组合框的应用

           

           
          1. from tkinter.ttk import *

          2.  
          3. def calc(event):

          4. a = float(t1.get())

          5. b = float(t2.get())

          6. dic = {0:a+b,1:a-b,2:a*b,3:a/b}

          7. c = dic[comb.current()]

          8. lbl.config(text=str(c))

          9.  
          10. root = Tk()

          11. root.title('四则运算')

          12. root.geometry('320x240')

          13.  
          14. t1 = Entry(root)

          15. t1.place(relx=0.1,rely=0.1,relwidth=0.2,relheight=0.1)

          16.  
          17. t2 = Entry(root)

          18. t2.place(relx=0.5,rely=0.1,relwidth=0.2,relheight=0.1)

          19.  
          20. var = StringVar()

          21.  
          22. comb = Combobox(root,textvariable=var,values=['加','减','乘','除',])

          23. comb.place(relx=0.1,rely=0.5,relwidth=0.2)

          24. comb.bind('<<ComboboxSelected>>',calc)

          25.  
          26. lbl=Label(root,text='结果')

          27. lbl.place(relx=0.5,rely=0.7,relwidth=0.2,relheight=0.3)

          28.  
          29. root.mainloop()

      • 3.6、滑块:(Scale) 是一种 直观地进行数值输入的交互控件,其主要属性见下表:

        属性功能描述
        from_起始值(最小可取值)
        lable标签文字,默认为无
        length滑块控件实例宽(水平方向)或 高(垂直方向),默认为100像素
        orient滑块控件实例呈现方向,VERTCAL或HORIZONTAL(默认)
        repeatdelay鼠标响应延时,默认为 300ms
        resolution分辨精度,即最小值间隔
        sliderlength滑块宽度,默认为30 像素
        state状态,若设置 state=DISABLED,则滑块控件实例不可用
        tickinterval标尺间隔,默认为0,若设置过小,则会重叠
        to终止值(最大可取值)
        variable返回数值类型,可为IntVar(整数)、DoubleVar(浮点数)、或 StringVar(字符串)
        width控件实例本身的宽度,默认为15像素

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

         

        滑块控件的应用

         
        1. from tkinter import *

        2.  
        3. def show(event):

        4. s = '滑块的取值为' + str(var.get())

        5. lb.config(text=s)

        6.  
        7. root = Tk()

        8. root.title('滑块实验')

        9. root.geometry('320x180')

        10. var=DoubleVar()

        11. scl = Scale(root,orient=HORIZONTAL,length=200,from_=1.0,to=5.0,label='请拖动滑块',tickinterval=1,resolution=0.05,variable=var)

        12. scl.bind('<ButtonRelease-1>',show)

        13. scl.pack()

        14.  
        15. lb = Label(root,text='')

        16. lb.pack()

        17.  
        18. root.mainloop()

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

         
        1. 菜单实例名=Menu(根窗体)

        2. 菜单分组1=Menu(菜单实例名)

        3. 菜单实例名.add_cascade(<label=菜单分组1 显示文本>,<menu=菜单分组1>)

        4. 菜单分组1.add_command(<label=命令1文本>,<command=命令1函数名>)

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

        菜单和快捷菜单

         

         
        1. from tkinter import *

        2.  
        3. def new():

        4. s = '新建'

        5. lb1.config(text=s)

        6.  
        7. def ope():

        8. s = '打开'

        9. lb1.config(text=s)

        10.  
        11. def sav():

        12. s = '保存'

        13. lb1.config(text=s)

        14.  
        15. def cut():

        16. s = '剪切'

        17. lb1.config(text=s)

        18.  
        19. def cop():

        20. s = '复制'

        21. lb1.config(text=s)

        22.  
        23. def pas():

        24. s = '粘贴'

        25. lb1.config(text=s)

        26.  
        27. def popupmenu(event):

        28. mainmenu.post(event.x_root,event.y_root)

        29.  
        30. root = Tk()

        31. root.title('菜单实验')

        32. root.geometry('320x240')

        33.  
        34. lb1 = Label(root,text='显示信息',font=('黑体',32,'bold'))

        35. lb1.place(relx=0.2,rely=0.2)

        36.  
        37. mainmenu = Menu(root)

        38. menuFile = Menu(mainmenu) # 菜单分组 menuFile

        39. mainmenu.add_cascade(label="文件",menu=menuFile)

        40. menuFile.add_command(label="新建",command=new)

        41. menuFile.add_command(label="打开",command=ope)

        42. menuFile.add_command(label="保存",command=sav)

        43. menuFile.add_separator() # 分割线

        44. menuFile.add_command(label="退出",command=root.destroy)

        45.  
        46. menuEdit = Menu(mainmenu) # 菜单分组 menuEdit

        47. mainmenu.add_cascade(label="编辑",menu=menuEdit)

        48. menuEdit.add_command(label="剪切",command=cut)

        49. menuEdit.add_command(label="复制",command=cop())

        50. menuEdit.add_command(label="粘贴",command=pas())

        51.  
        52. root.config(menu=mainmenu)

        53. root.bind('Button-3',popupmenu) # 根窗体绑定鼠标右击响应事件

        54. root.mainloop()

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

        根窗体与子窗体

         

         
        1. from tkinter import *

        2.  
        3. def newwind():

        4. winNew = Toplevel(root)

        5. winNew.geometry('320x240')

        6. winNew.title('新窗体')

        7. lb2 = Label(winNew,text='我在新窗体上')

        8. lb2.place(relx=0.2,rely=0.2)

        9. btClose=Button(winNew,text='关闭',command=winNew.destroy)

        10. btClose.place(relx=0.7,rely=0.5)

        11.  
        12. root = Tk()

        13. root.title('新建窗体实验')

        14. root.geometry('320x240')

        15.  
        16. lb1 = Label(root,text='主窗体',font=('黑体',32,'bold'))

        17. lb1.place(relx=0.2,rely=0.2)

        18.  
        19. mainmenu = Menu(root)

        20. menuFile = Menu(mainmenu)

        21. mainmenu.add_cascade(label='菜单',menu=menuFile)

        22. menuFile.add_command(label='新窗体',command=newwind)

        23. menuFile.add_separator()

        24. menuFile.add_command(label='退出',command=root.destroy)

        25.  
        26. root.config(menu=mainmenu)

        27. root.mainloop()

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

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

        • 3.9.1、交互对话框

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

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

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

           

          确定取消对话框

           
          1. from tkinter import *

          2. import tkinter.messagebox

          3.  
          4. def xz():

          5. answer=tkinter.messagebox.askokcancel('请选择','请选择确定或取消')

          6. if answer:

          7. lb.config(text='已确认')

          8. else:

          9. lb.config(text='已取消')

          10.  
          11. root = Tk()

          12.  
          13. lb = Label(root,text='')

          14. lb.pack()

          15. btn=Button(root,text='弹出对话框',command=xz)

          16. btn.pack()

          17. root.mainloop()

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

          输入对话框

           

           
          1. from tkinter.simpledialog import *

          2.  
          3. def xz():

          4. s=askstring('请输入','请输入一串文字')

          5. lb.config(text=s)

          6.  
          7. root = Tk()

          8.  
          9. lb = Label(root,text='')

          10. lb.pack()

          11. btn=Button(root,text='弹出输入对话框',command=xz)

          12. btn.pack()

          13. root.mainloop()

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

          文件选择对话框

           

           
          1. from tkinter import *

          2. import tkinter.filedialog

          3.  
          4. def xz():

          5. filename=tkinter.filedialog.askopenfilename()

          6. if filename != '':

          7. lb.config(text='您选择的文件是'+filename)

          8. else:

          9. lb.config(text='您没有选择任何文件')

          10.  
          11. root = Tk()

          12.  
          13. lb = Label(root,text='')

          14. lb.pack()

          15. btn=Button(root,text='弹出文件选择对话框',command=xz)

          16. btn.pack()

          17. root.mainloop()

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

          颜色选择对话框

           

           
          1. from tkinter import *

          2. import tkinter.colorchooser

          3.  
          4. def xz():

          5. color=tkinter.colorchooser.askcolor()

          6. colorstr=str(color)

          7. print('打印字符串%s 切掉后=%s' % (colorstr,colorstr[-9:-2]))

          8. lb.config(text=colorstr[-9:-2],background=colorstr[-9:-2])

          9.  
          10. root = Tk()

          11.  
          12. lb = Label(root,text='请关注颜色的变化')

          13. lb.pack()

          14. btn=Button(root,text='弹出颜色选择对话框',command=xz)

          15. btn.pack()

          16. root.mainloop()

    4、事件响应

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

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

    2.  

    其中,事件代码通常以半角小于号“<”和大于号“>” 界定,包括事件和按键等 2~3个部分,它们之间用减号分隔,常见事件代码见下表:

    事件事件代码备注
    单击鼠标左键<ButtonPress-1>可简写为<Button-1> 或 <1>
    单击鼠标中键<ButtonPress-2>可简写为<Button-2> 或 <2>
    单击鼠标右键<ButtonPress-3>可简写为<Button-3> 或 <3>
    释放鼠标左键<ButtonRelease-1>---
    释放鼠标中键<ButtonRelease-2>---
    释放鼠标右键<ButtonRelease-3>---
    按住鼠标左键移动<B1-Motion>---
    按住鼠标中键移动<B2-Motion>---
    按住鼠标右键移动<B3-Motion>---
    转动鼠标滚轮<MouseWheel>---
    双击鼠标左键<Double-Button-1>---
    鼠标进入控件实例<Enter>注意与回车事件的区别
    鼠标离开控件实例<Leave>---
    键盘任意键<Key>---
    字母和数字< Key-字母>,例如<key-a>、<Key-A>简写不带小于和大于号,例如:a,A和1等
    回车<Return><Tab>,<Shift>,<Control>(注意不能用<Ctrl>),<Alt>等类同
    空格<Space>---
    方向键<Up> ,<Down>,<Left>,<Right>---
    功能键<Fn>例如:<F1>等---
    组合键键名之间以减号链接,例如<Control-k>,<Shift-6>,<Alt-Up>等注意大小写

    例如,将框架控件实例frame 绑定鼠标右键单击事件,调用自定义函数 myfunc()可表示为"frame.bind('<Button-3>',myfunc)",注意: myfunc后面没有括号。将控件实例绑定到键盘事件和部分光标不落在具体控件实例上的鼠标事件时,还需要设置该实例执行focus_set() 方法获得焦点,才能对事件持续响应。例如: frame.focus_set()。所调用的自定义函数若需要利用鼠标或键盘的响应值,可将event作为参数,通过event的属性获取。event的属性见下表:

    event属性意义
    x或y(注意是小写)相对于事件绑定控件实例左上角的坐标值(像素)
    root_x或root_y(注意是小写)相对于显示屏幕左上角的坐标值(像素)
    char可显示的字符,若按键不可显示,则返回为空字符串
    keysysm字符或字符型按键名,如:“a”或“Escape”
    keysysm_num按键的十进制 ASCII 码值

    例如:将标签绑定键盘任意键触发事件并获取焦点,并将按键字符显示在标签上

     

    响应键盘事件

     
    1. from tkinter import *

    2.  
    3. def show(event):

    4. s=event.keysym

    5. lb.config(text=s)

    6.  
    7. root=Tk()

    8. root.title('按键实验')

    9. root.geometry('200x200')

    10. lb=Label(root,text='请按键',font=('黑体',48))

    11. lb.bind('<Key>',show)

    12. lb.focus_set()

    13. lb.pack()

    14. root.mainloop()

     

     

    展开全文
  • Python支持多种图形界面的第三方库,包括:TkwxWidgetsQtGTK等等。但是Python自带的库是支持Tk的Tkinter,使用Tkinter,无需安装任何包,就可以直接使用。本章简单介绍如何使用Tkinter进行GUI编程。Tkinter我们来...

    Python支持多种图形界面的第三方库,包括:

    Tk

    wxWidgets

    Qt

    GTK

    等等。

    但是Python自带的库是支持Tk的Tkinter,使用Tkinter,无需安装任何包,就可以直接使用。本章简单介绍如何使用Tkinter进行GUI编程。

    Tkinter

    我们来梳理一下概念:

    我们编写的Python代码会调用内置的Tkinter,Tkinter封装了访问Tk的接口;

    Tk是一个图形库,支持多个操作系统,使用Tcl语言开发;

    Tk会调用操作系统提供的本地GUI接口,完成最终的GUI。

    所以,我们的代码只需要调用Tkinter提供的接口就可以了。

    第一个GUI程序

    使用Tkinter十分简单,我们来编写一个GUI版本的"Hello, world!”。

    第一步是导入Tkinter包的所有内容:

    from Tkinter import *

    第二步是从Frame派生一个Application类,这是所有Widget的父容器:

    class Application(Frame):

    def __init__(self, master=None):

    Frame.__init__(self, master)

    self.pack()

    self.createWidgets()

    def createWidgets(self):

    self.helloLabel = Label(self, text='Hello, world!')

    self.helloLabel.pack()

    self.quitButton = Button(self, text='Quit', command=self.quit)

    self.quitButton.pack()

    在GUI中,每个Button、Label、输入框等,都是一个Widget。Frame则是可以容纳其他Widget的Widget,所有的Widget组合起来就是一棵树。

    pack()方法把Widget加入到父容器中,并实现布局。pack()是最简单的布局,grid()可以实现更复杂的布局。

    在createWidgets()方法中,我们创建一个Label和一个Button,当Button被点击时,触发self.quit()使程序退出。

    第三步,实例化Application,并启动消息循环:

    app = Application()

    # 设置窗口标题:

    app.master.title('Hello World')

    # 主消息循环:

    app.mainloop()

    GUI程序的主线程负责监听来自操作系统的消息,并依次处理每一条消息。因此,如果消息处理非常耗时,就需要在新线程中处理。

    运行这个GUI程序,可以看到下面的窗口:

    2015429101736554.png?201532910183

    点击"Quit”按钮或者窗口的"x”结束程序。

    输入文本

    我们再对这个GUI程序改进一下,加入一个文本框,让用户可以输入文本,然后点按钮后,弹出消息对话框。

    from Tkinter import *

    import tkMessageBox

    class Application(Frame):

    def __init__(self, master=None):

    Frame.__init__(self, master)

    self.pack()

    self.createWidgets()

    def createWidgets(self):

    self.nameInput = Entry(self)

    self.nameInput.pack()

    self.alertButton = Button(self, text='Hello', command=self.hello)

    self.alertButton.pack()

    def hello(self):

    name = self.nameInput.get() or 'world'

    tkMessageBox.showinfo('Message', 'Hello, %s' % name)

    当用户点击按钮时,触发hello(),通过self.nameInput.get()获得用户输入的文本后,使用tkMessageBox.showinfo()可以弹出消息对话框。

    程序运行结果如下:

    2015429101834912.png?2015329101847

    小结

    Python内置的Tkinter可以满足基本的GUI程序的要求,如果是非常复杂的GUI程序,建议用操作系统原生支持的语言和库来编写。

    源码参考:https://github.com/michaelliao/learn-python/tree/master/gui

    本文标题: 为Python程序添加图形化界面的教程

    本文地址: http://www.cppcns.com/jiaoben/python/123802.html

    展开全文
  • Python-Tkinter图形化界面设计(详细教程 )

    万次阅读 多人点赞 2019-08-05 23:07:41
    Python 图形化界面设计 文章参考:https://www.jianshu.com/p/91844c5bca78 1、图形化界面设计的基本理解 当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单...

    声明:本篇文章为转载自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

    展开全文
  • 主要介绍了推荐8款常用的Python GUI图形界面开发框架,需要的朋友可以参考下
  • python图形界面开发

    千次阅读 2019-06-10 22:03:41
    python图形界面开发 #python import tkinter import tkinter.messagebox def main(): flag = True def change_label_text(): nonlocal flag flag = not flag color, msg = ('red', 'hel...
  • python 图形界面开发

    万次阅读 多人点赞 2017-07-27 10:27:45
    python开发图形界面,确实不是很方便,没有c#,Java,甚至VB来得容易。几个控件拖拽,然后响应事件。用python写脚本,或者web service来处理一般工作,绰绰有余。
  • 在本篇文章里小编给大家整理了关于Python图形用户界面和游戏开发知识点以及实例代码,需要的朋友们学习下。
  • Python图形用户界面开发工具包 1.Tkinter 官方提供的图形用户界面开发工具包,对于Tk GUI工具包封装而来,是跨平台的 不需要额外安装软件包 但包含控件比较少,开发复杂图形用户界面时,力不从心 且Tkinter工具包...
  • 作为Python开发者,你迟早都会用到图形用户界面来开发应用。本文将推荐一些 Python ...它主要关注创新型用户界面开发,如:多点触摸应用程序。Kivy还提供一个多点触摸鼠标模拟器。当前支持的平台包括:Linux、Wind...
  • Python 的 UI 开发工具包 Kivy Python 的 GUI 开发工具 Flexx Qt库的Python绑定 PyQt Python图形开发包 wxPython Tk图形用户界面 Tkinter Pywin32 Python图形界面开发包 PyGTK pyui4win
  • python界面-推荐8款常用的Python GUI图形界面开发框架

    万次阅读 多人点赞 2020-10-28 22:00:09
    作为Python开发者,你迟早都会用到图形用户界面来开发应用。本文将推荐一些 Python GUI ...它主要关注创新型用户界面开发,如:多点触摸应用程序。Kivy还提供一个多点触摸鼠标模拟器。当前支持的平台包括:Linux、...
  • 主要介绍了python图形界面开发之wxPython树控件使用方法详解,需要的朋友可以参考下
  • 是官方提供的图形界面开发库,用于封装Tk GUI工具包,跨平台,但是控件少,帮助文档不健全,不便于开发复杂的图形用户界面。 PyQt 非官方提供的图形用户界面开发库,用于封装Qt,跨平台,需要额外安装软件包 ...
  • python写爬虫,老师叫我加界面设计,怎么弄写界面的话可以有两种方式,一种是GUI方式,可以使用tk或者QT之类的还有一种就是使用WEB方式,做一个HTML的界面,可以使用简单的flask来做python怎么使用qtdesigner设计...
  • python图形界面开发用什么

    千次阅读 2019-11-13 02:22:53
    作为Python开发者,你迟早都会用到图形用户界面开发应用。本文将推荐一些 Python GUI 框架,希望对你有所帮助。 Python 的 UI 开发工具包 Kivy Ki...
  • 使用python 开发图形化界面,最初开始看B站莫烦的教程,好久忘了,今天自己想做个界面玩玩,并打包成exe玩一下。 直接上手,再翻到莫烦的教程直接看最后,把代码赋值,然后改改就可以了 很简单的图形化界面,只有...
  • Python图形用户界面和游戏开发

    千次阅读 2019-07-10 15:50:33
    GUI是图形用户界面的缩写,图形化的用户界面对使用过计算机的人来说应该都不陌生,在此也无需进行赘述。Python默认的GUI开发模块是tkinter(在Python 3以前的版本中名为Tkinter),从这个名字就可以看出它是基于Tk的...
  • 作为Python开发者,你迟早都会用到图形用户界面来开发应用。本文将推荐一些 Python GUI ...它主要关注创新型用户界面开发,如:多点触摸应用程序。Kivy还提供一个多点触摸鼠标模拟器。当前支持的平台包括:Linux、...
  • 看了你的问题,几个回答似乎都不...一个界面设计除了服务端交互,还需要本地交互(用JS,flash实现),最重要的还是需要客户端界面(用HTML+CSS+JS实现)。文件上传需要(JQUERY+UPLOADFILE库)从上面的回答看,你似...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,433
精华内容 22,573
关键字:

python图形化界面开发

python 订阅