tkinter 订阅
Tkinter模块("Tk 接口")是Python的标准Tk GUI工具包的接口. [1]  Tk和Tkinter可以在大多数的Unix平台下使用,同样可以应用在Windows和Macintosh系统里.Tk8.0的后续版本可以通过ttk实现本地窗口风格,并良好地运行在绝大多数平台中. [1-2]  此外,tkinter.tix提供了更丰富的窗口组件。 [3] 展开全文
Tkinter模块("Tk 接口")是Python的标准Tk GUI工具包的接口. [1]  Tk和Tkinter可以在大多数的Unix平台下使用,同样可以应用在Windows和Macintosh系统里.Tk8.0的后续版本可以通过ttk实现本地窗口风格,并良好地运行在绝大多数平台中. [1-2]  此外,tkinter.tix提供了更丰富的窗口组件。 [3]
信息
附加模块
Python模块
模    块
Tk 接口
tkinter.ttk
Python_tkinter附加模块(Ttk)
使用平台
Unix、Windows
中文名
Tkinter
Tkinter早期版本
Tkinter包含了若干模块. Tk接口被封装在一个名为 _tkinter 二进制模块里( tkinter 的早期版本). 这个模块包含了Tk的低级接口,因而它不会被程序员直接应用.它通常表现为一个共享库(或DLL文件),但在一些版本中它与Python解释器结合在一起. [1] 
收起全文
精华内容
参与话题
问答
  •  二、Tkinter 是什么  三、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. 其他部件后续再补充...

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

    展开全文
  • Python tkinter入门详解教程

    万次阅读 多人点赞 2019-04-16 18:42:18
    基于tkinter入门资料太少,特录制了这套入门详解课程,希望能帮助初学者快速掌握tkinter的基础知识和实战技巧,对于伸手党和资料收集党,做了一个门槛限制,希望大家理解 本课程涉及到tkinter的高级控件讲解,ttk...

    基于tkinter入门资料太少,特录制了这套入门详解课程,希望能帮助初学者快速掌握tkinter的基础知识和实战技巧,对于伸手党和资料收集党,做了一个门槛限制,希望大家理解

    网易云课堂 视频课程地址

    https://study.163.com/course/courseMain.htm?courseId=1209232809&share=2&shareId=480000001855430

    本课程涉及到tkinter的高级控件讲解,ttk自定义主题样式,tkinter自定义控件,tkinter的异步编程,两个实战项目,自制编辑器,自制播放器

    在这里插入图片描述

    课程基本大纲如下
    1.概述
    2 基础入门
    2.1 基本控件
    2.2 布局详解
    2.3 事件详解
    2.4 面向对象范式
    3 高级用法
    3.1 高级控件学习
    3.2 对话框
    3.3 现代风格ttk
    3.4 扩展包Pmw
    3.5 自定义控件
    4. 项目实战
    4.1 自制编辑器
    4.2 自制播放器
    5. 打包发布

    编辑器项目

    编辑器开发文档

    在这里插入图片描述

    网易云音乐播放器

    python 流媒体详解
    在这里插入图片描述

    欢迎关注我的公众号:编程之路从0到1
    编程之路从0到1

    展开全文
  • Python Tkinter窗体讲解

    千人学习 2019-06-28 11:14:31
    Python作为自立门户的语言,除了学习它的基础编程...当然大家也不用担心,即使没学过,在学习了该教程提供的Python的Tkinter窗体后,也会让你快速的掌握。这样我们就可以使用Python做一些小游戏,或者做一些小系统。
  • Python3中tkinter模块使用方法详解

    万次阅读 多人点赞 2018-07-29 09:53:25
    转载自 覆手为云p 的博客,附上原文网址,感觉非常有用,存下档,...1、使用tkinter.Tk() 生成主窗口(root=tkinter.Tk()); root.title('标题名') 修改框体的名字,也可在创建时使用className参数来命名; root...

    转载自 覆手为云p 的博客,附上原文网址,感觉非常有用,存下档,谢谢帮助~~~

    https://www.cnblogs.com/aland-1415/p/6849193.html

     

    1、使用tkinter.Tk() 生成主窗口(root=tkinter.Tk());
    root.title('标题名')         修改框体的名字,也可在创建时使用className参数来命名;
    root.resizable(0,0)        框体大小可调性,分别表示x,y方向的可变性;
    root.geometry('250x150')  指定主框体大小;
    root.quit()                退出;
    root.update_idletasks()
    root.update()             刷新页面;

    2、初级样例:

    复制代码

    1 import tkinter
    2 root=tkinter.Tk() #生成root主窗口
    3 label=tkinter.Label(root,text='Hello,GUI') #生成标签
    4 label.pack()        #将标签添加到主窗口
    5 button1=tkinter.Button(root,text='Button1') #生成button1
    6 button1.pack(side=tkinter.LEFT)         #将button1添加到root主窗口
    7 button2=tkinter.Button(root,text='Button2')
    8 button2.pack(side=tkinter.RIGHT)
    9 root.mainloop()             #进入消息循环(必需组件)

    复制代码

    3、tkinter中的15种核心组件:

    复制代码

        Button          按钮;
        Canvas          绘图形组件,可以在其中绘制图形;
        Checkbutton      复选框;
        Entry           文本框(单行);
        Text             文本框(多行);
        Frame           框架,将几个组件组成一组
        Label           标签,可以显示文字或图片;
        Listbox         列表框;
        Menu            菜单;
        Menubutton       它的功能完全可以使用Menu替代;
        Message          与Label组件类似,但是可以根据自身大小将文本换行;
        Radiobutton      单选框;
        Scale           滑块;允许通过滑块来设置一数字值
        Scrollbar        滚动条;配合使用canvas, entry, listbox, and text窗口部件的标准滚动条;
        Toplevel         用来创建子窗口窗口组件。
    (在Tkinter中窗口部件类没有分级;所有的窗口部件类在树中都是兄弟。)

    复制代码

    4、组件的放置和排版(pack,grid,place)

    复制代码

    pack组件设置位置属性参数:
        after:        将组件置于其他组件之后;
        before:       将组件置于其他组件之前;
        anchor:        组件的对齐方式,顶对齐'n',底对齐's',左'w',右'e'
        side:        组件在主窗口的位置,可以为'top','bottom','left','right'(使用时tkinter.TOP,tkinter.E);
        fill            填充方式 (Y,垂直,X,水平)
        expand          1可扩展,0不可扩展
    grid组件使用行列的方法放置组件的位置,参数有:
        column:         组件所在的列起始位置;
        columnspam:     组件的列宽;
        row:         组件所在的行起始位置;
        rowspam:      组件的行宽;
    place组件可以直接使用坐标来放置组件,参数有:
        anchor:       组件对齐方式;
        x:            组件左上角的x坐标;
        y:             组件右上角的y坐标;
        relx:          组件相对于窗口的x坐标,应为0-1之间的小数;
        rely:           组件相对于窗口的y坐标,应为0-1之间的小数;
        width:          组件的宽度;
        heitht:        组件的高度;
        relwidth:       组件相对于窗口的宽度,0-1;
        relheight:     组件相对于窗口的高度,0-1;

    复制代码

     5、使用tkinter.Button时控制按钮的参数:

    复制代码

        anchor:            指定按钮上文本的位置;
        background(bg)       指定按钮的背景色;
        bitmap:            指定按钮上显示的位图;
        borderwidth(bd)    指定按钮边框的宽度;
        command:          指定按钮消息的回调函数;
        cursor:            指定鼠标移动到按钮上的指针样式;
        font:               指定按钮上文本的字体;
        foreground(fg)     指定按钮的前景色;
        height:            指定按钮的高度;
        image:             指定按钮上显示的图片;
        state:              指定按钮的状态(disabled);
        text:               指定按钮上显示的文本;
        width:             指定按钮的宽度
        padx               设置文本与按钮边框x的距离,还有pady;
        activeforeground    按下时前景色
        textvariable        可变文本,与StringVar等配合着用

    复制代码

    6、文本框tkinter.Entry,tkinter.Text控制参数:

    复制代码

        background(bg)      文本框背景色;
        foreground(fg)        前景色;
        selectbackground    选定文本背景色;
        selectforeground    选定文本前景色;
        borderwidth(bd)      文本框边框宽度;
        font                 字体;
        show                文本框显示的字符,若为*,表示文本框为密码框;
        state               状态;
        width              文本框宽度
        textvariable        可变文本,与StringVar等配合着用

    复制代码

    7、标签tkinter.Label组件控制参数:

    复制代码

        Anchor            标签中文本的位置;
        background(bg)    背景色;
        foreground(fg)      前景色;
        borderwidth(bd)     边框宽度;
        width             标签宽度;
        height            标签高度;
        bitmap             标签中的位图;
        font               字体;
        image             标签中的图片;
        justify            多行文本的对齐方式;
        text             标签中的文本,可以使用'\n'表示换行
        textvariable       显示文本自动更新,与StringVar等配合着用

    复制代码

    8、单选框和复选框Radiobutton,Checkbutton控制参数:

    复制代码

        anchor           文本位置;
        background(bg)   背景色;
        foreground(fg)    前景色;
        borderwidth       边框宽度;
        width            组件的宽度;
        height           组件高度;
        bitmap           组件中的位图;
        image            组件中的图片;
        font             字体;
        justify          组件中多行文本的对齐方式;
        text             指定组件的文本;
        value            指定组件被选中中关联变量的值;
        variable          指定组件所关联的变量;
        indicatoron        特殊控制参数,当为0时,组件会被绘制成按钮形式;
        textvariable       可变文本显示,与StringVar等配合着用

    复制代码

    9、组图组件Canvas控制参数

    复制代码

        background(bg)      背景色;
        foreground(fg)       前景色;
        borderwidth       组件边框宽度;
        width             组件宽度;
        height             高度;
        bitmap             位图;
        image             图片;
    绘图的方法主要以下几种:
        create_arc          圆弧;
        create_bitmap      绘制位图,支持XBM;
        create_image       绘制图片,支持GIF(x,y,image,anchor);
        create_line         绘制支线;
        create_oval;        绘制椭圆;
        create_polygon     绘制多边形(坐标依次罗列,不用加括号,还有参数,fill,outline);
        create_rectangle   绘制矩形((a,b,c,d),值为左上角和右下角的坐标);
        create_text         绘制文字(字体参数font,);
        create_window      绘制窗口;
        delete              删除绘制的图形;
        itemconfig          修改图形属性,第一个参数为图形的ID,后边为想修改的参数;
        move               移动图像(1,4,0),1为图像对象,4为横移4像素,0为纵移像素,然后用root.update()刷新即可看到图像的移动,为了使多次移动变得可视,最好加上time.sleep()函数;
        只要用create_方法画了一个图形,就会自动返回一个ID,创建一个图形时将它赋值给一个变量,需要ID时就可以使用这个变量名。
        coords(ID)          返回对象的位置的两个坐标(4个数字元组);
    
    对于按钮组件、菜单组件等可以在创建组件时通过command参数指定其事件处理函数。方法为bind;或者用bind_class方法进行类绑定,bind_all方法将所有组件事件绑定到事件响应函数上。

    复制代码

     10、菜单Menu

    复制代码

    参数: 
        tearoff          分窗,0为在原窗,1为点击分为两个窗口
        bg,fg           背景,前景
        borderwidth      边框宽度
        font              字体
        activebackgound   点击时背景,同样有activeforeground,activeborderwidth,disabledforeground
        cursor
        postcommand
        selectcolor      选中时背景
        takefocus
        title       
        type
        relief
       
    方法:
        menu.add_cascade      添加子选项
        menu.add_command      添加命令(label参数为显示内容)
        menu.add_separator    添加分隔线
        menu.add_checkbutton  添加确认按钮
        delete                删除

    复制代码

     11、事件关联

    复制代码

    bind(sequence,func,add)——
    bind_class(className,sequence,func,add)
    bind_all(sequence,func,add)
    事件参数:  
    sequence              所绑定的事件;
    func                   所绑定的事件处理函数;
    add                    可选参数,为空字符或‘+’;
    className             所绑定的类;
    
    鼠标键盘事件
        <Button-1>            鼠标左键按下,2表示中键,3表示右键;
        <ButtonPress-1>        同上;
        <ButtonRelease-1>    鼠标左键释放;
        <B1-Motion>           按住鼠标左键移动;
        <Double-Button-1>     双击左键;
        <Enter>               鼠标指针进入某一组件区域;
        <Leave>               鼠标指针离开某一组件区域;
        <MouseWheel>         滚动滚轮;
        <KeyPress-A>         按下A键,A可用其他键替代;
        <Alt-KeyPress-A>      同时按下alt和A;alt可用ctrl和shift替代;
        <Double-KeyPress-A>    快速按两下A;
        <Lock-KeyPress-A>     大写状态下按A;
       
    窗口事件
        Activate             当组件由不可用转为可用时触发;
        Configure            当组件大小改变时触发;
        Deactivate          当组件由可用转变为不可用时触发;
        Destroy              当组件被销毁时触发;
        Expose              当组件从被遮挡状态中暴露出来时触发;
        Unmap              当组件由显示状态变为隐藏状态时触发;
        Map                  当组件由隐藏状态变为显示状态时触发;
        FocusIn              当组件获得焦点时触发;
        FocusOut            当组件失去焦点时触发;
        Property             当窗体的属性被删除或改变时触发;
        Visibility           当组件变为可视状态时触发;
    
    响应事件
    event对象(def function(event)):
        char                按键字符,仅对键盘事件有效;
        keycode            按键名,仅对键盘事件有效;
        keysym             按键编码,仅对键盘事件有效;
        num                鼠标按键,仅对鼠标事件有效;
        type                 所触发的事件类型;
        widget               引起事件的组件;
        width,heigh        组件改变后的大小,仅Configure有效;
        x,y                鼠标当前位置,相对于窗口;
        x_root,y_root       鼠标当前位置,相对于整个屏幕

    复制代码

    12、弹窗

    复制代码

    messagebox._show函数的控制参数:
        default         指定消息框按钮;
        icon            指定消息框图标;
        message        指定消息框所显示的消息;
        parent          指定消息框的父组件;
        title           标题;
        type            类型;
    
    simpledialog模块参数:
        title           指定对话框的标题;
        prompt         显示的文字;
        initialvalue    指定输入框的初始值;
    
      filedialog    模块参数:
        filetype       指定文件类型;
        initialdir     指定默认目录;
        initialfile    指定默认文件;
        title         指定对话框标题
    
    colorchooser模块参数:
        initialcolor    指定初始化颜色;
        title           指定对话框标题;

    复制代码

    13、字体(font)
    一般格式:
    ('Times -10 bold')
    ('Times',10,'bold','italic')    依次表示字体、字号、加粗、倾斜


    补充:
    config            重新配置
    label.config(font='Arial -%d bold' % scale.get())
    依次为字体,大小(大小可为字号大小),加粗
    tkinter.StringVar    能自动刷新的字符串变量,可用set和get方法进行传值和取值,类似的还有IntVar,DoubleVar...

    sys.stdout.flush()  刷新输出

     

    Python3 从入门到开车

     

    附1:tkinter中的颜色

     

    附2:一个自己用tkinter写的计算器程序

    #filename:Caculater
    
    import tkinter,time,decimal,math,string
    
    root=tkinter.Tk()
    root.title('计算器')
    root.resizable(0,0)
    global cuncu, vartext, result, fuhao
    result = fuhao = None
    vartext = tkinter.StringVar()
    cuncu = []
    
    class anjianzhi:
        global cuncu, vartext, result, fuhao
        def __init__(self,anjian):
            self.anjian = anjian
        def jia(self):
            cuncu.append(self.anjian)
            vartext.set( ''.join(cuncu))
        def tui(self):
            cuncu.pop()
            vartext.set(''.join(cuncu))
        def clear(self):
            cuncu.clear()
            vartext.set('')
            result = None
            fuhao = None
        def zhengfu(self):
            if cuncu[0]:
                if cuncu[0] == '-':
                    cuncu[0] = '+'
                elif cuncu[0] == '+':
                    cuncu[0] = '-'
                else:
                    cuncu.insert(0, '-')
            vartext.set(''.join(cuncu))
        def xiaoshudian(self):
            if cuncu.count('.') >= 1:
                pass
            else:
                if cuncu == [] :
                    cuncu.append('0')
                cuncu.append('.')
                vartext.set(''.join(cuncu))
        def yunshuan(self):
            global cuncu, vartext, result, fuhao
            if vartext.get() == '':
                pass
            else:
                get1 = decimal.Decimal(vartext.get())
                if self.anjian in ('1/x','sqrt'):
                    if self.anjian == '1/x':
                        result = 1/get1
                    elif self.anjian == 'sqrt':
                        result = math.sqrt(get1)
                elif  self.anjian in ('+','-','*','/','='):
                    if fuhao is not None:
                        get1 = decimal.Decimal(result)
                        get2 = decimal.Decimal(vartext.get())
                        if fuhao == '+':
                            result = get1 + get2
                        elif fuhao == '-':
                            result = get1 - get2
                        elif fuhao == '*':
                            result = get1 * get2
                        elif fuhao == '/':
                            result = get1 / get2
                    else:
                        result = get1
                    if self.anjian == '=':
                        fuhao = None
                    else:
                        fuhao = self.anjian
                print(fuhao)
                print(result)
                vartext.set(str(result))
                cuncu.clear()
    
    def copy1():
        # tkinter.Misc().clipboard_clear()
        tkinter.Misc().clipboard_append(string(vartext.get()))
    
    def buju(root):
        global cuncu, vartext, result, fuhao
        entry1 = tkinter.Label(root, width=30, height=2, bg='white', anchor='se', textvariable=vartext)
        entry1.grid(row=0, columnspan=5)
        buttonMC=tkinter.Button(root,text='MC',width=5)
        buttonMR=tkinter.Button(root,text='MR',width=5)
        buttonMS=tkinter.Button(root,text='MS',width=5)
        buttonM1=tkinter.Button(root,text='M+',width=5)
        buttonM2=tkinter.Button(root,text='M-',width=5)
        buttonMC.grid(row=1,column=0)
        buttonMR.grid(row=1,column=1)
        buttonMS.grid(row=1,column=2)
        buttonM1.grid(row=1,column=3)
        buttonM2.grid(row=1,column=4)
    
    
        buttonJ=tkinter.Button(root,text='←',width=5,command=anjianzhi('c').tui)
        buttonCE=tkinter.Button(root,text='CE',width=5)
        buttonC=tkinter.Button(root,text=' C ',width=5,command=anjianzhi('c').clear)
        button12=tkinter.Button(root,text='±',width=5,command=anjianzhi('c').zhengfu)
        buttonD=tkinter.Button(root,text='√',width=5,command=anjianzhi('sqrt').yunshuan)
        buttonJ.grid(row=2,column=0)
        buttonCE.grid(row=2,column=1)
        buttonC.grid(row=2,column=2)
        button12.grid(row=2,column=3)
        buttonD.grid(row=2,column=4)
    
        button7=tkinter.Button(root,text=' 7 ',width=5,command=anjianzhi('7').jia)
        button8=tkinter.Button(root,text=' 8 ',width=5,command=anjianzhi('8').jia)
        button9=tkinter.Button(root,text=' 9 ',width=5,command=anjianzhi('9').jia)
        buttonc=tkinter.Button(root, text=' / ',width=5,command=anjianzhi('/').yunshuan)
        buttonf= tkinter.Button(root, text=' % ',width=5)
        button7.grid(row=3,column=0)
        button8.grid(row=3,column=1)
        button9.grid(row=3,column=2)
        buttonc.grid(row=3,column=3)
        buttonf.grid(row=3,column=4)
    
        button4=tkinter.Button(root,text=' 4 ',width=5,command=anjianzhi('4').jia)
        button5=tkinter.Button(root,text=' 5 ',width=5,command=anjianzhi('5').jia)
        button6=tkinter.Button(root,text=' 6 ',width=5,command=anjianzhi('6').jia)
        buttonx=tkinter.Button(root,text=' * ',width=5,command=anjianzhi('*').yunshuan)
        buttonfs=tkinter.Button(root,text='1/x',width=5,command=anjianzhi('1/x').yunshuan)
        button4.grid(row=4,column=0)
        button5.grid(row=4,column=1)
        button6.grid(row=4,column=2)
        buttonx.grid(row=4,column=3)
        buttonfs.grid(row=4,column=4)
    
        button1 = tkinter.Button(root, text=' 1 ',width=5,command=anjianzhi('1').jia)
        button2 = tkinter.Button(root, text=' 2 ',width=5,command=anjianzhi('2').jia)
        button3 = tkinter.Button(root, text=' 3 ',width=5,command=anjianzhi('3').jia)
        button_= tkinter.Button(root, text=' - ',width=5,command=anjianzhi('-').yunshuan)
        buttondy= tkinter.Button(root, text=' \n = \n ',width=5,command=anjianzhi('=').yunshuan)
        button1.grid(row=5, column=0)
        button2.grid(row=5, column=1)
        button3.grid(row=5, column=2)
        button_.grid(row=5, column=3)
        buttondy.grid(row=5, column=4,rowspan=2)
    
        button0=tkinter.Button(root,text='   0   ',width=11,command=anjianzhi('0').jia)
        buttonjh = tkinter.Button(root,text=' . ',width=5,command=anjianzhi('c').xiaoshudian)
        buttonjia=tkinter.Button(root,text=' + ',width=5,command=anjianzhi('+').yunshuan)
        button0.grid(row=6,column=0,columnspan=2)
        buttonjh.grid(row=6,column=2)
        buttonjia.grid(row=6,column=3)
    def caidan(root):
    
        menu=tkinter.Menu(root)
        submenu1=tkinter.Menu(menu,tearoff=0)
        menu.add_cascade(label='查看',menu=submenu1)
        submenu2 = tkinter.Menu(menu, tearoff=0)
        submenu2.add_command(label='复制')
        submenu2.add_command(label='粘贴')
        menu.add_cascade(label='编辑',menu=submenu2)
        submenu = tkinter.Menu(menu, tearoff=0)
        submenu.add_command(label='查看帮助')
        submenu.add_separator()
        submenu.add_command(label='关于计算机')
        menu.add_cascade(label='帮助',menu=submenu)
        root.config(menu=menu)
    
    
    buju(root)
    caidan(root)
    root.mainloop()
    

     

    展开全文
  • 本系列课程一共20套,每一套视频课程会深入讲解Python的某一类知识点。本系列课程深入介绍了Python语言的方方面面,也是李宁老师其他课程的基础,如深度学习、科学计算、Web开发(Django Web框架)、全站开发、运维...
  • 关于Tkinter的介绍

    2019-11-29 11:42:26
    本片博客翻译自 Tkinter 的一个英文教程。

    文章更新于:2020-04-25
    注0:原英文教程地址:zetcode.com
    注1:Introduction to Tkinter 参见:关于Tkinter的介绍
    注2:Layout management in Tkinter 参见:Tkinter布局管理器
    注3:Tkinter widgets 参见:Tkinter 控件

    Introduction to Tkinter

    In this part of the Tkinter tutorial, we introduce the Tkinter toolkit and create our first programs.
    The purpose of this tutorial is to get you started with the Tkinter toolkit.

    在 Tkinter 教程的这一部分,我们将介绍 Tkinter 工具集并且创建我们的第一个程序。
    这个教程的目的是让你使用 Tkinter 工具集开始一段新的征程。

    Tkinter

    Tkinter is a Python binding to the Tk GUI toolkit. Tk is the original GUI library for the Tcl language. Tkinter is implemented as a Python wrapper around a complete Tcl interpreter embedded in the Python interpreter. There are several other popular Python GUI toolkits. Most popular are wxPython, PyQt, and PyGTK.

    Tkinter 是 python 内置的 TK GUI 工具集。TK 是 Tcl 语言的原生 GUI 库。作为 python 的图形设计工具,它所使用的 Tcl 语言环境已经完全嵌入到了 python 解释器中。当然还有一些其他比较著名的 python GUI 工具。比如著名的 wxPython,PyQt 和 PyGTK。

    Python

    Python is a general-purpose, dynamic, object-oriented programming language. The design purpose of the Python language emphasizes programmer productivity and code readability. Python was initially developed by Guido van Rossum. It was first released in 1991. Python was inspired by ABC, Haskell, Java, Lisp, Icon, and Perl programming languages. Python is a high-level, general-purpose, multiplatform, interpreted language. Python is a minimalistic language. One of its most visible features is that it does not use semicolons nor brackets; Python uses indentation instead. There are two main branches of Python currently: Python 2.x and Python 3.x. Python 3.x breaks backward compatibility with previous releases of Python. It was created to correct some design flaws of the language and make the language more clean. This tutorial is written in Python 2.x. Most of the code is written in Python 2.x versions. It will take some time till the software base and programmers will migrate to Python 3.x. Today, Python is maintained by a large group of volunteers worldwide. Python is open source software.

    Python is an ideal start for those who want to learn programming.

    python 是一个通用的、动态的和面向对象的编程语言。设计 python 的时候就强调使用 python 程序员的工作效率和 python 代码的易读性。python 编程语言是由 Guido van Rossum 开发并在1991年首次发布。python 在一定程度上受到了ABC,Haskell,Java,Lisp,Icon 和 Perl 等编程语言的启发。python 是一个高级的、通用的、多平台的解释型语言,但是python也很简单。它在视觉上的最大特征就是它使用缩进而不是使用分号和圆括号来分隔语句。现在 python 有两个主要的分支,2.x版本和3.x版本,3.x版本并不向后兼容以前的版本。相比以前版本,它修正了一些设计缺陷以让语言本身更加简洁。这个教程写在2.x时期,教程里的大部分代码都是使用2.x的版本。因为程序员包括程序转向3.x的话还需要一段时间。现在,python主要由一些大型的世界性志愿组织来维护,当然,它也是开源的。
    如果你想学习一门编程语言的话,学python是个很好的主意。

    Python programming language supports several programming styles. It does not force a programmer to a specific paradigm. Python supports object oriented and procedural programming. There is also a limited support for functional programming.

    python语言支持很多编程风格。它不局限于特定的范例。python支持面向对象和面向过程,当然,在功能上有一定的限制。
    python语言的官网是python.org

    Pillow

    Pillow is a Python library for for opening, manipulating, and saving many different image file formats. Some of the examples in this tutorial use Pillow.

    $ sudo apt-get install python-pil.imagetk
    On Debian Linux, we can install Pillow with its package manager.

    $ yum install python-imaging
    On systems using RPM package format, we use the above command to install Pillow.

    $ pip install pillow
    Alternatively, we can use pip to install Pillow

    Pillow是python的一个库,用于打开、操作和保存不同图像格式的文件。本教程一部分例子使用的Pillow。
    $ sudo apt-get install python-pil.imagetk
    在Debian Linux上我们可以使用它自带的包管理器来安装Pillow
    $ yum install python-imaging
    在使用 RPM 包格式的系统上,我们可以使用如上命令来安装Pillow
    $ pip install pillow
    或者,也可以使用 pip 来安装Pillow

    Tkinter simple example

    In our first example, we show a basic window on the screen.

    在我们第一个例子中,我们将在屏幕上显示一个最基本的窗口。

    from tkinter import Tk, BOTH
    from tkinter.ttk import Frame
    
    class Example(Frame):
    
        def __init__(self):
            super().__init__()
    
            self.initUI()
    
    
        def initUI(self):
    
            self.master.title("Simple")
            self.pack(fill=BOTH, expand=1)
    
    
    def main():
    
        root = Tk()
        root.geometry("250x150+300+300")
        app = Example()
        root.mainloop()
    
    
    if __name__ == '__main__':
        main()
    

    While this code is very small, the application window can do quite a lot. It can be resized, maximized, or minimized. All the complexity that comes with it has been hidden from the application programmer.

    虽然这段代码很少,但这个应用窗口能做的并不少。它可以调整大小、最大化、最小化。但它所带来的复杂性已经被程序员隐藏掉了。

    from tkinter import Tk, BOTH
    from tkinter.ttk import Frame
    

    Here we import Tk and Frame classes, and BOTH constant. Tk class is used to create a root window. Frame is a container for other widgets.

    这里我们引入了TK和Frame类和BOTH常量。TK类用于创建根窗口。Frame是一个包含其他小控件的容器。

    class Example(Frame):
    
        def __init__(self):
            super().__init__()
    

    Our example class inherits from the Frame container widget. In the init() constructor method we call the constructor of our inherited class.

    我们的example类继承了Frame容器控件。在__init__()构造方法中,我们调用了父类的构造方法。

    self.initUI()
    

    We delegate the creation of the user interface to the initUI() method.

    我们将用户界面的创造方法交给 initUI() 来处理。

    self.master.title("Simple")
    

    We set the title of the window using the title() method. The master attribute gives access to the root window (Tk).

    我们使用 title() 方法来设置这个窗口的标题。而 master 属性则是提供了访问根窗口的入口。

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

    The pack() method is one of the three geometry managers in Tkinter. It organizes widgets into horizontal and vertical boxes. Here we put the Frame widget, accessed via the self attribute to the Tk root window. It is expanded in both directions. In other words, it takes the whole client space of the root window.

    这个pack()方法是三个几何管理器中的一个。它将控件组织成水平和垂直的框。这里我们放置了一个Frame小控件,由self属性提供访问根窗口的入口。它会在两个方向上进行扩展,换句话说,它可能会占据整个根窗口。

    root = Tk()
    

    The root window is created. The root window is a main application window in our programs. It has a title bar and borders. These are provided by the window manager. It must be created before any other widgets.

    根窗口已经被创建。在我们的程序中,根窗口是主窗口,它有一个标题栏和边框。这些都由窗口管理器来提供。同时,他必须在所有控件之前被创建。

    root.geometry("250x150+300+300")
    

    The geometry() method sets a size for the window and positions it on the screen. The first two parameters are the width and height of the window. The last two parameters are x and y screen coordinates.

    这个geometry()方法给窗口设置了一个大小并将它放在在屏幕上。前两个参数分别是宽和高。后两个参数是屏幕的 x 和 y 轴的坐标。

    app = Example()
    

    Here we create the instance of the application class.

    这里我们实例化了一个应用类。

    root.mainloop()
    

    Finally, we enter the mainloop. The event handling starts from this point. The mainloop receives events from the window system and dispatches them to the application widgets. It is terminated when we click on the close button of the titlebar or call the quit() method.

    最后,我们进入主循环。事件将从这个点开始处理。主循环接收来自窗口系统的事件并交给程序控件处理。当我们点击标题栏上面的关闭按钮或调用quit()方法时,它将会关闭。
    图1

    Tkinter centering window

    This script centers a window on the screen.

    这个脚本将窗口放在屏幕中间。

    from tkinter import Tk, BOTH
    from tkinter.ttk import Frame
    
    class Example(Frame):
    
        def __init__(self):
            super().__init__()
    
            self.initUI()
    
    
        def initUI(self):
    
            self.master.title("Centered window")
            self.pack(fill=BOTH, expand=1)
            self.centerWindow()
    
    
        def centerWindow(self):
    
            w = 290
            h = 150
    
            sw = self.master.winfo_screenwidth()
            sh = self.master.winfo_screenheight()
    
            x = (sw - w)/2
            y = (sh - h)/2
            self.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
    
    
    def main():
    
        root = Tk()
        ex = Example()
        root.mainloop()
    
    
    if __name__ == '__main__':
        main()
    

    We need to have the size of the window and the size of the screen to position the window in the center of the monitor screen.

    我们需要知道窗口的大小和屏幕的大小以让窗口居中。

    w = 290
    h = 150
    

    These are the width and height values of the application window.

    上面是应用窗口的宽和高。

    sw = self.master.winfo_screenwidth()
    sh = self.master.winfo_screenheight()
    

    We determine the width and height of the screen.

    屏幕的大小需要我们进行判断

    x = (sw - w)/2
    y = (sh - h)/2
    

    We calculate the required x and y coordinates.

    我们计算出我们需要的 x 和 y 坐标。

    self.master.geometry('%dx%d+%d+%d' % (w, h, x, y)

    Finally, the geometry() method is used to place the window in the center of the screen.

    最后,geometry() 方法经常被用于设置窗口居中。

    Tkinter Quit button

    In the last example of this chapter, we create an application that has a quit button. When we press the button, the application terminates.

    本章的最后一个例子,我们创建一个有退出按钮的窗口。当我们按下按钮,程序结束。

    from tkinter import Tk, BOTH
    from tkinter.ttk import Frame, Button, Style
    
    class Example(Frame):
    
        def __init__(self):
            super().__init__()
    
            self.initUI()
    
    
        def initUI(self):
    
            self.style = Style()
            self.style.theme_use("default")
    
            self.master.title("Quit button")
            self.pack(fill=BOTH, expand=1)
    
            quitButton = Button(self, text="Quit",
                command=self.quit)
            quitButton.place(x=50, y=50)
    
    
    def main():
    
        root = Tk()
        root.geometry("250x150+300+300")
        app = Example()
        root.mainloop()
    
    
    if __name__ == '__main__':
        main()
    

    We position a Button on the window. Clicking on the button will terminate the application.

    我们在窗口中放了一个按钮。并且点击这个按钮会结束程序。

    from tkinter.ttk import Frame, Button, Style
    

    Tkinter supports theming of widgets. Widgets that are themed can be imported from the ttk module. At the time of this writing, not all widgets are themable. For instance, menus or listboxes are not supported so far.

    Tkinter 支持控件主题,控件的主题可以由 ttk 模块导入。在写下这句话的时候,并不是所有的控件都支持主题。比如说,菜单和列表框就不支持。

    self.style = Style()
    self.style.theme_use("default")
    

    We apply a theme for our widgets. Some of the supported themes are clam, default, alt, or classic.

    我们为我们的控件应用应用主题。一些支持的主题比如clam、default、alt、classic。

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

    We create an instance of the Button widget. The parent of this button is the Frame container. We provide a label for the button and a command. The command specifies a method that is called when we press the button. In our case the quit() method is called, which terminates the application.

    我们创建一个按钮的例子。这个按钮的承载者是Frame容器。我们为按钮提供一个标签和命令。这个命令指定当我们按下按钮时所调用的方法。在我们的例子中,调用的是用于结束程序的 quit() 方法。

    quitButton.place(x=50, y=50)
    

    We use the place geometry manager to position the button in absolute coordinates—50x50 px from the top-left corner of the window.

    我们使用 place 几何布局管理器将按钮放在,距离窗口左上角坐标为50x50的绝对位置上。
    图2

    This section was an introduction to the Tkinter toolkit.

    这一部分是关于 Tkinter 工具集的介绍。

    展开全文
  • 这节课来学学Tkinter,python GUI 中级选择,关于 GUI 详细请看窗口视窗Tkinter 大家回顾一下,到目前为止,几乎我们所有的Python代码都是基于文字交互的界面。Python 的 GUI 工具包有很多,之前我们学过的 EasyGui...
  • tkinter

    2019-10-24 15:41:37
    1-Label &...import tkinter as tk window = tk.Tk() window.title('my window') window.geometry('300x150') var = tk.StringVar() #l = tk.Label(window,text='OMG!this is TK',bg='green',font=(...
  • Tkinter 控件详细介绍

    万次阅读 2015-07-18 12:58:29
    python 界面编程 Tkinter 15种控件简介  2012-02-21 16:23:47| 分类: python代码 | 标签: |字号大中小 订阅 1.Button 按钮。类似标签,但提供额外的功能,例如鼠标掠过、按下、释放以及键盘操作/...
  • Python GUI之tkinter概述

    万次阅读 多人点赞 2017-01-03 00:20:20
    对于稍有GUI编程经验的人来说,Python的Tkinter界面库都是非常简单的。Python的GUI库非常多,之所以选择Tkinter,一是最为简单,二是自带库,不需下载安装,随时使用,三则是从需求出发的,Python作为一种脚本语言,...
  • tkinter界面设计

    2018-05-08 16:49:01
    Tkinter界面设计的图形化设计软件,按钮,下拉菜单,复选框,单选框等实用工具一应俱全!
  • Tkinter登陆界面设计

    千次阅读 2019-05-07 21:51:54
    Tkinter登陆界面设计 程序详细解释可参考莫凡:https://morvanzhou.github.io/tutorials/python-basic/tkinter/3-03-example3/ 注意,可在源程序的基础上进行添加自己的程序。 程序运行结果: 程序代码: # -*- ...
  • Python-Tkinter图形化界面设计

    千次阅读 2019-10-22 09:23:53
    综合了以下的文章: 转载自:...目录一.图形化界面设计的基本理解二.Tkinter是什么三.窗体控件1) 数据集导入2) Tkinter 控件详细介绍1. Tkinter 模块元素简要说明2. 控件的共同属性3. 控件布局3.1...
  • Python-Tkinter图形化界面设计(详细教程 )

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

    千次阅读 2020-05-19 18:54:00
    作为 Python 开发者,图形用户界面(GUI)开发是必备技能之一。目前,市面上支持 Python 的“GUI 工具包”很多,各有特点,虽然大多数工具包的基础类似,但要学习一个新包并掌握其细节还是非常耗时的,因此,在选用...
  • Tkinter创建一个windows窗口的GUI程序 import tkinter win = tkinter.Tk() win.title('我第一个GUI程序') win.geometry("800x600") #设置窗口大小 label = tkinter.Label(win,text='hello,python') label.pack...
  • 不过说实在,使用Python开发GUI界面还是麻烦了一些了,自带的标准库Tkinter使用起来非常简单,不过对于习惯了VB拖放控件完成界面设计的偶来说,还是不够人性化。TK也有一个工具叫GUI Builder,不过它使用Layout布局...
  • python利用tkinter设计界面进阶:ttk

    万次阅读 2017-12-10 10:39:24
    GUI界面设计进阶
  • tkinter.pack设计复杂界面布局

    万次阅读 多人点赞 2018-11-04 12:41:59
    对程序员来说,界面设计的实现,要解决的一个主要问题就是如何根据界面设计的需求,将组件以规定的大小放置在规定的位置。tkinter是python语言中常用的界面实现模块,其中pack()方法,可创建浮动,自动伸缩扩展的...
  • 这是一个VB6的ADDIN(外接程序),用于使用VB6开发工具直接拖放控件,直接可视化完成Python的TKinter的GUI布局和设计,可以在VB界面上设置 控件的一些属性,最终自动生成必要的代码(包括回调函数框架),代码生成...

空空如也

1 2 3 4 5 ... 20
收藏数 34,207
精华内容 13,682
关键字:

tkinter