精华内容
下载资源
问答
  • 包含了数十个图形化界面的Python示例,包括表格、仿微信界面、仿QQ设置、各种图形界面,菜单操作,调用dll等。 pyhton示例 python demo python图形化示例 python Gui示例
  • python图形化界面编写样例,实现了计算器的基本功能,可供参考。
  • 基于python图形化界面的学生成绩管理系统.pdf
  • Python 图形化界面设计

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

    Python 图形化界面设计

     

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

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

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

    2、窗体控件布局

    • 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 常用控件

      控件名称作用
      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宽(文本控件的单位为行,不是像素)

        标签及常见属性示例:

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

     

    控件呈现的5种浮雕样式

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

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

        •  

           

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

          from tkinter import  *
          root = Tk()
          
          lbred = Label(root,text="Red",fg="Red",relief=GROOVE)
          lbred.pack()
          lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)
          lbgreen.pack()
          lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)
          lbblue.pack()
          root.mainloop()
          
        • 使用pack()方法可设置 fill、side 等属性参数。其中,参数fill 可取值:fill=X,fill=Y或fill=BOTH,分别表示允许控件向水平方向、垂直方向或二维伸展填充未被占用控件。参数 side 可取值:side=TOP(默认),side=LEFT,side=RIGHT,side=BOTTOM,分别表示本控件实例的布局相对于下一个控件实例的方位。如下例子:

           

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

          from tkinter import  *
          root = Tk()
          
          lbred = Label(root,text="Red",fg="Red",relief=GROOVE)
          lbred.pack()
          lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)
          lbgreen.pack(side=RIGHT)
          lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)
          lbblue.pack(fill=X)
          root.mainloop()
          
      • 2.2.2、grid()方法:是基于网格的布局。先虚拟一个二维表格,再在该表格中布局控件实例。由于在虚拟表格的单元中所布局的控件实例大小不一,单元格也没有固定或均一的大小,因此其仅用于布局的定位。pack()方法与grid()方法不能混合使用。
        grid()方法常用布局参数如下:

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

         

        pack()方法排列标签

        from tkinter import  *
        root = Tk()
        
        lbred = Label(root,text="Red",fg="Red",relief=GROOVE)
        lbred.grid(column=2,row=0)
        lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)
        lbgreen.grid(column=0,row=1)
        lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)
        lbblue.grid(column=1,columnspan=2,ipadx=20,row=2)
        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()方法排列消息

          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()
          
    • 3、tkinter常见控件的特征属性

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

        • 标签(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()
            
        • 文本框(Text)

          文本框的常用方法如下:

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

          上表位置的取值可为整数,浮点数或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()
          
        • 输入框(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、列表框 与 组合框

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

        执行自定义函数时,通常使用“实例名.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.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()。
          看下面的一个例子:实现四则运算计算器,将两个操作数分别填入两个文本框后,通过选择组合框中的算法触发运算,如下:

          组合框的应用

           

          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) 是一种 直观地进行数值输入的交互控件,其主要属性见下表:

        属性功能描述
        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,用鼠标拖动滑块后释放鼠标可读取滑块值并显示在标签上。效果如下:

         

        滑块控件的应用

        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控件也可以创建快捷菜单(又称为上下文菜单)。通常需要右击弹出的控件实例绑定鼠标右击响应事件<Button-3>,并指向一个捕获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()
          

    4、事件响应

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

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

    其中,事件代码通常以半角小于号“<”和大于号“>” 界定,包括事件和按键等 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 码值

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

     

    响应键盘事件

    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()
    

     

     

    展开全文
  • python图形化翻译工具

    2021-08-02 10:49:33
    python写的图形化有道翻译小工具
  • Day14_Python图形化界面、tkinter、Python英汉词典 14.01Python语言基础(Python实现英汉字典)(掌握) 14.02Python语言基础(tkinter概述)(熟练) 14.03Python语言基础(创建一个图形化界面)(熟练) 14.04Python语言...

    Day14_Python图形化界面、Python GUI、tkinter、Python英汉词典

    14.01_Python语言基础(Python实现英汉字典)(掌握)
    14.02_Python语言基础(tkinter概述)(熟练)
    14.03_Python语言基础(创建一个图形化界面)(熟练)
    14.04_Python语言基础(控件lable)(熟练)
    14.05_Python语言基础(控件Button)(熟练)
    14.06_Python语言基础(Text控件)(熟练)
    14.07_Python语言基础(文本输入框)(熟练)
    14.08_Python语言基础(文本输入框关联文本显示框)(熟练)
    14.09_Python语言基础(进度条)(熟练)
    14.10_Python语言基础(绝对布局)(熟练)
    14.11_Python语言基础(相对布局)(熟练)
    14.12_Python语言基础(表格布局)(熟练)
    14.13_Python语言基础(浮雕布局)(熟练)
    14.14_Python语言基础(单选按钮)(熟练)
    14.15_Python语言基础(多选按钮)(熟练)
    14.16_Python语言基础(带界面的字典)(熟练)
    14.17_Python语言基础(Listbox)(熟练)
    14.18_Python语言基础(Menu)(熟练)
    

    14.01Python语言基础(Python实现英汉字典)(掌握)

    Python实现英汉字典

    # 打开英汉字典文件
    file = open("dict.txt", "r", encoding="utf-8")
    # 读取字符串
    lines = file.readlines()
    # 创建字典
    dictionary = {}
    # 字典添加内内容
    for i in lines:
        line_list = i.split("\t")
        dictionary[line_list[0]] = line_list[1]
    # 单词查询功能
    while True:
        print("请输入要查询的单词,输入0退出:")
        eng = input()
        if eng == "0":
            break
        if eng in dictionary.keys():
            print(eng + ":\t" + dictionary[eng])
        else:
            print("您查询的词尚未收录,敬请期待")
    

    14.02Python语言基础(tkinter概述)(熟练)

    1.1 tkinter的概述

    • tkinter是python的一个标准GUI(图形化界面)
    • 扩展:
      • wxpython;开源软件(免费,原码),是一个python优秀的图形库
      • jython:java swing AWT SWT

    14.03Python语言基础(创建一个图形化界面)(熟练)

    • 使用方式:
      • 1.导入tkinter
      • 2.创建控件
      • 3.指定这个控件的master,即这个控件属于谁
        1. 通知GM(geometry,manager)执行

    示例

    import tkinter
    # 创建主窗口
    window = tkinter.Tk()
    # 设置标题
    window.title("英汉词典")
    # 设置窗口的大小和位置400×400:宽高   200+20   初始化时候窗口的位置
    window.geometry("400x400+200+20") # 符号为(x)小写矮科斯
    # 显示内容
    window.mainloop()
    

    14.04Python语言基础(控件lable)(熟练)

    • 定义:
      • 标签控件可以显示文本

    lable控件

    import tkinter
    
    #创建主窗口
    window = tkinter.Tk()
    #设置标题
    window.title("英汉词典")
    #设置窗口的大小和位置400×400:大小宽高   200  20   初始化时候窗口所在的位置
    window.geometry("400x400+200+20")
    """
    window:父窗体
    text:显示的文本内容
    bg:背景
    fg:字体颜色
    wrapLength :指定text文本中多宽进行换行
    justify:设置换行后的对齐方式
    anchor: 位置  n 北   e  东  s南   w  西   center  居中
    """
    label = tkinter.Label(window,text="1806",
                  bg="blue",fg="red",
                  font=("黑体",20),width="10",
                  height="4",wraplength= 100,
                  justify="left",anchor = "center")
    
    # 管理控件
    label.pack()#pack是一个布局管理器,一个弹性的容器
    
    # 循环消息
    window.mainloop()
    

    14.05Python语言基础(控件Button)(熟练)

    • button定义:
      • button理解为按钮
    • 按钮的功能:
      • 当点击按钮时发生对应的事

    按钮显示和控制

    import tkinter
    
    # 创建窗口
    from tkinter import Frame
    
    window = tkinter.Tk()
    # 设置窗口
    window.title("英汉词典")
    window.geometry("500x500")
    
    
    # 控制台输出信息的方法
    def show_info():
        print("666")
    
    
    # 显示按钮
    btn_show = tkinter.Button(window, text="查询", command=show_info)
    btn_show.pack(side="left")
    
    # 退出按钮
    btn_exit = tkinter.Button(window, text="退出", command=window.quit)
    btn_exit.pack(side="right")
    
    # 按钮布局
    btn_frame = Frame(window, height=30)
    btn_frame.pack()
    #
    # # 显示按钮
    # btn_show = tkinter.Button(btn_frame, text="查询", command=show_info)
    # btn_show.pack(side="left")
    #
    # # 退出按钮
    # btn_exit = tkinter.Button(btn_frame, text="退出", command=window.quit)
    # btn_exit.pack(side="right")
    
    # 消息循环
    window.mainloop()
    

    14.06Python语言基础(Text控件)(熟练)

    • Text:
      • 显示文本信息

    文本显示框

    #
    import tkinter
    from tkinter import *
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 配置窗口
    window.title("英汉词典")
    window.geometry("500x300")
    window.resizable(width=True, height=False)
    
    # 文本显示框
    text = Text(window, width=68, height=20)
    text.pack(side="bottom")
    
    # 文本框插入内容
    word = "hello hello hello hello hello hello hello hello hello"
    text.insert(tkinter.INSERT, word)
    
    # 消息循环
    window.mainloop()
    

    14.07Python语言基础(文本输入框)(熟练)

    • 输入文本内容的控件
      • 通过get()方法可以获取到输入内容
      • 通过set()方法可以预设内容

    文本输入框案例

    import tkinter
    
    # 创建窗口
    window = tkinter.Tk()
    # 设置窗口
    window.title("英汉词典")
    window.geometry("500x500")
    
    # 输入框
    entry = tkinter.Entry(window)
    entry.pack()
    
    
    # 控制台输出内容
    def show_info():
        print(entry.get())
    
    
    # 按钮
    button = tkinter.Button(window, text="查询", command=show_info)
    button.pack()
    
    # 消息循环
    window.mainloop()
    

    14.08Python语言基础(文本输入框关联文本显示框)(熟练)

    • 用户在文本输入框书写内容
    • 内容显示在文本显示框
    • 通过按钮点击事件关联

    获取内容并显示案例

    import tkinter
    from tkinter import *
    
    
    # 显示信息
    def show_info():
        text.insert("1.0", entry.get() + "\n")
    
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 配置窗口
    window.title("英汉词典")
    window.geometry("500x300")
    window.resizable(width=True, height=False)
    
    # 输入框布局
    input_frame = Frame(window, width=30, height=30)
    input_frame.pack(side="top")
    
    # 输入框
    entry = Entry(input_frame, width=30)
    entry.pack(side="left")
    
    # 查询按钮
    btn_search = Button(input_frame, text="查询", command=show_info)
    btn_search.pack(side="left")
    
    # 退出按钮
    btn_search = Button(input_frame, text="退出", command=window.quit)
    btn_search.pack(side="right")
    
    # 文本
    text = Text(window, width=68, height=20)
    text.pack(side="bottom")
    
    # 循环消息
    window.mainloop()
    

    14.09Python语言基础(进度条)(熟练)

    • 文本内容超出文本显示框一页容量时,内容将无法完全展示
    • 拖动进度条可显示全部内容

    进度条案例

    import tkinter
    from tkinter import *
    
    
    # 显示信息
    def show_info():
        text.insert("1.0", entry.get() + "\n")
    
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 配置窗口
    window.title("英汉词典")
    window.geometry("500x300")
    window.resizable(width=True, height=False)
    
    # 输入框布局
    input_frame = Frame(window, width=30, height=30)
    input_frame.pack(side="top")
    
    # 输入框
    entry = Entry(input_frame, width=30)
    entry.pack(side="left")
    
    # 查询按钮
    btn_search = Button(input_frame, text="查询", command=show_info)
    btn_search.pack(side="left")
    
    # 退出按钮
    btn_search = Button(input_frame, text="退出", command=window.quit)
    btn_search.pack(side="right")
    
    # 清空数据
    def clear_info():
        text.delete(0.0, tkinter.END)
    
    # 滚动条
    scroll = tkinter.Scrollbar()
    scroll.pack(side="right", fill=tkinter.Y)
    
    # 文本
    text = Text(window, width=68, height=20)
    text.pack(side="bottom")
    
    # 关联滚动条和文字
    text.config(yscrollcommand=scroll.set)
    scroll.config(command=text.yview)
    
    # 循环消息
    window.mainloop()
    

    14.10Python语言基础(绝对布局)(熟练)

    • 绝对布局
      • 使用place方法可以通过坐标的方式确定控件的位置
      • 其他控件的变化(增加或删除)不会影响自身的位置

    绝对布局 案例

    import tkinter
    
    from tkinter import Label
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 设置窗口参数
    window = tkinter.Tk()
    window.title("英汉词典")
    window.geometry("500x500")
    
    # 创建控件
    label_01 = Label(window, text="label_01", bg="blue")
    label_02 = Label(window, text="label_02", bg="green")
    label_03 = Label(window, text="label_03", bg="red")
    
    # 管理控件
    label_01.place(x=10, y=10)
    label_02.place(x=50, y=50)
    label_03.place(x=100, y=100)
    
    # 循环消息
    window.mainloop()
    

    14.11Python语言基础(相对布局)(熟练)

    • 相对布局
      • 相对布局的控件会参照上一个控件的位置摆放自己
      • 其他控件的变化(增加或删除)会影响自身的位置

    相对布局案例:

    import tkinter
    
    from tkinter import Label
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 设置窗口参数
    window = tkinter.Tk()
    window.title("英汉词典")
    window.geometry("500x500")
    
    # 创建控件
    label_01 = Label(window, text="label_01", bg="blue")
    label_02 = Label(window, text="label_02", bg="green")
    label_03 = Label(window, text="label_03", bg="red")
    
    # 管理控件
    label_01.pack(fill=tkinter.Y, side=tkinter.LEFT)
    label_02.pack(fill=tkinter.X, side=tkinter.TOP)
    label_03.pack(fill=tkinter.X, side=tkinter.LEFT)
    
    # 循环消息
    window.mainloop()
    

    14.12Python语言基础(表格布局)(熟练)

    • 参照表格中的位置摆放
      • 参数row表示行数
      • 参数column表示列数

    表格布局案例

    import tkinter
    
    from tkinter import Label
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 设置窗口参数
    window = tkinter.Tk()
    window.title("英汉词典")
    window.geometry("500x500")
    
    # 创建控件
    label_01 = Label(window, text="label_01", bg="blue")
    label_02 = Label(window, text="label_02", bg="green")
    label_03 = Label(window, text="label_03", bg="red")
    label_04 = Label(window, text="label_01", bg="yellow")
    label_05 = Label(window, text="label_02", bg="orange")
    label_06 = Label(window, text="label_03", bg="pink")
    
    # 管理控件
    label_01.grid(row=1, column=1)
    label_02.grid(row=2, column=2)
    label_03.grid(row=3, column=3)
    label_04.grid(row=1, column=4)
    label_05.grid(row=2, column=5)
    label_06.grid(row=3, column=6)
    
    # 循环消息
    window.mainloop()
    

    14.13Python语言基础(浮雕布局)(熟练)

    • 浮雕布局可以让控件以3D的效果呈现
    • 浮雕布局属性为relief,共有五种类型:
      • FLAT —平的
      • RAISED —凸起的
      • RIDGE —脊状边缘
      • SUNKEN —凹陷
      • GROOVE —沟状

    浮雕布局案例

    import tkinter
    
    from tkinter import Label, GROOVE, SUNKEN, RAISED, FLAT, RIDGE
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 设置窗口参数
    window.title("英汉词典")
    window.geometry("500x500")
    
    """
    relief:3D效果
    FLAT    ---平的
    RAISED  ---凸起的
    RIDGE   ---脊状边缘
    SUNKEN  ---凹陷
    GROOVE  ---沟状
    """
    
    # 创建控件
    label_01 = Label(window, text="label_01", bg="blue", relief=GROOVE)
    label_02 = Label(window, text="label_02", bg="green", relief=SUNKEN)
    label_03 = Label(window, text="label_03", bg="red", relief=RAISED)
    label_04 = Label(window, text="label_04", bg="yellow", relief=FLAT)
    label_05 = Label(window, text="label_05", bg="orange", relief=RIDGE)
    
    # 管理控件
    label_01.grid(row=1, column=1)
    label_02.grid(row=2, column=2)
    label_03.grid(row=3, column=3)
    label_04.grid(row=4, column=4)
    label_05.grid(row=5, column=5)
    
    # 循环消息
    window.mainloop()
    

    14.14Python语言基础(单选按钮)(熟练)

    • 只可以选中一个选项,比如性别,毕业状况等信息

    单选按钮示例

    import tkinter
    
    # 创建窗口
    from tkinter import Checkbutton, IntVar, Radiobutton
    
    window = tkinter.Tk()
    
    # 设置窗口参数
    window.title("英汉词典")
    window.geometry("500x500")
    
    # 一组按钮绑定一个变量
    check_box = tkinter.BooleanVar()
    
    
    # 接收显示结果
    def send_result():
        print(check_box.get())
    
    
    # 创建单选按钮
    radio_man = Radiobutton(window, text="man", value=True, variable=check_box, command=send_result)
    radio_woman = Radiobutton(window, text="woman", value=False, variable=check_box, command=send_result)
    
    # 管理控件
    radio_man.pack()
    radio_woman.pack()
    
    # 循环消息
    window.mainloop()
    

    14.15Python语言基础(多选按钮)(熟练)

    • 只可以选中多个选项,比如情趣爱好等信息

    多选按钮示例

    import tkinter
    
    from tkinter import Checkbutton, StringVar, BooleanVar
    
    # 创建窗口
    window = tkinter.Tk()
    
    # 设置窗口参数
    window.title("英汉词典")
    window.geometry("500x500")
    # 存放选中信息
    hobby_list = set()
    
    
    # 获取选中信息
    def update_info():
        if check_01.get():
            hobby_list.add("篮球")
        else:
            if "篮球" in hobby_list:
                hobby_list.remove("篮球")
    
        if check_02.get():
            hobby_list.add("足球")
        else:
            if "足球" in hobby_list:
                hobby_list.remove("足球")
    
        if check_03.get():
            hobby_list.add("排球")
        else:
            if "排球" in hobby_list:
                hobby_list.remove("排球")
    
        print(hobby_list)
    
    
    # 给每一个选项创建一个变量
    check_01 = BooleanVar()
    check_02 = BooleanVar()
    check_03 = BooleanVar()
    
    # 复选框
    check_box_01 = Checkbutton(window, text="篮球", variable=check_01, command=update_info)
    check_box_02 = Checkbutton(window, text="足球", variable=check_02, command=update_info)
    check_box_03 = Checkbutton(window, text="排球", variable=check_03, command=update_info)
    
    # 管理控件
    check_box_01.pack()
    check_box_02.pack()
    check_box_03.pack()
    
    # 循环消息
    window.mainloop()
    

    14.16Python语言基础(带界面的字典)(熟练)

    结合以上知识,编写代码实现带界面的字典

    14.17Python语言基础(Listbox)(熟练)

    • Listbox为列表框控件
    • 它可以包含一个或多个文本项(text item)
    • 可以设置为单选或多选

    Listbox案例

    """
    1.导入模块
    2.创建窗口
    3.设置窗口属性
    4.创建Listbox控件
    5.设置控件属性
    6.保存控件属性
    7.显示控件
    """
    # 1.导入模块
    import tkinter
    
    # 2.创建窗口
    window = tkinter.Tk()
    # 3.设置窗口属性
    window.title("list_box")
    window.geometry("500x500+300+100")
    # 创建list_box控件,
    # 可以多选的Listbox,使用属性selectmaod,
    # 还可以设置为BROWSE,可以通过鼠标来移动Listbox中的选中位置(不是移动item)
    # 单选的Listbox,是有那个属性SINGLE
    # 使用selectmode  = EXPANDED使用Listbox来支持Shift和Control。'''
    list_box = tkinter.Listbox(window, selectmode=tkinter.MULTIPLE)
    list_box.pack()
    # 创建列表,向list_box添加内容
    list01 = ["hello", "world", "good", "nice"]
    for item in list01:
        list_box.insert(tkinter.END, item)
    # 向末尾添加控件
    list_box.insert(tkinter.END, list01)
    # 获取指定范围的内容
    print(list_box.get(1, 2))
    # 选中自动范围的内容
    print(list_box.select_set(0, 3))
    # 删除指定位置元素
    list_box.delete(2)
    print(list_box.get(tkinter.ACTIVE, tkinter.END))
    # 判断一个item是否被选中,越界返回False
    print(list_box.select_includes(23))
    # 循环消息
    window.mainloop()
    

    14.18Python语言基础(Menu)(熟练)

    • Tkinter提供了一个组件Menu用来实现菜单
    • 菜单包括顶级菜单,下拉菜单和弹出菜单,下面我们将会看到顶级菜单和下拉菜单的案例。
    • 菜单需要用config关联窗口
    • 添加菜单使用add_command
    • 添加下拉菜单使用add_cascade

    顶级菜单案例:

    # 1.导入模块
    import tkinter
    
    # 2.创建窗口
    window = tkinter.Tk()
    # 3.设置窗口属性
    window.title("list_box")
    window.geometry("500x500+300+100")	
    # 创建菜单
    menu_language = tkinter.Menu(window, tearoff=False)
    
    
    # 响应菜单回调函数
    def callback():
        print("hello")
    
    
    # 菜单添加内容
    list01 = ["python", "java", "oc", "c#", "php", "js", "c++", "汇编", "shell", "退出"]
    for item in list01:
        if item == "退出":
            menu_language.add_command(label=item, command=window.quit)
        else:
            menu_language.add_command(label=item, command=callback)
    # 菜单栏关联window
    # 虽然menu已经创建,但是还没添加到root窗口中,所以要调用config方法对root的menu选项相关联
    window.config(menu=menu_language)
    # 循环消息
    window.mainloop()
    

    顶级菜单和下拉菜单案例:

    # 1.导入模块
    import tkinter
    # 2.创建窗口
    window = tkinter.Tk()
    # 3.设置窗口属性
    window.title("list_box")
    window.geometry("500x500+300+100")
    # 创建菜单
    menu_bar = tkinter.Menu(window)
    menu_language = tkinter.Menu(menu_bar, tearoff=False)
    
    def python_show():
        print("python")
    
    list01 = ["python", "java", "oc", "c#", "php", "js", "c++", "汇编", "shell", "退出"]
    for item in list01:
        if item == "退出":
            menu_language.add_command(label=item, command=window.quit)
        else:
            menu_language.add_command(label=item, command=python_show)
    # 菜单栏关联window
    # 创建子菜单
    menu_bar.add_cascade(label="语言", menu=menu_language)
    # menu_list.
    # 虽然menu已经创建,但是还没添加到root窗口中,所以要调用config方法对root的menu选项相关联
    window.config(menu=menu_bar)
    window.mainloop()
    
    展开全文
  • python图形化项目实战

    2018-11-30 22:49:08
    基于python中tkinter库,这是学习python的小伙伴对图形化编程感兴趣的可以敲敲试试
  • 简介对于想学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图形化(turtle)编程

    千次阅读 2019-04-26 00:36:33
    Python图形化介绍 turtle(海龟)库是turtle绘图体系的python实现 它是python语言的标准库之一,也可以说是入门级的图形绘制函数库。 那么我们首先来了解一下这个turtle库。 turtle的意思就是海龟,对于turtle绘制...

    Python图形化介绍

    turtle(海龟)库是turtle绘图体系的python实现

    它是python语言的标准库之一,也可以说是入门级的图形绘制函数库。

    那么我们首先来了解一下这个turtle库。

    turtle的意思就是海龟,对于turtle绘制图形,咱们可以理解为有一只海龟起初在运行窗口的正中心,我们可以通过程序来控制它在画布上游走,走过的轨迹便成了绘制的图形。

    上图是turtle的一个画布空间,最小单位是像素。

    中间的那个箭头就是一只海龟在画布上的初始状态,我们可以以这点为坐标原点,建立直角坐标系,x轴正方向规定为前,y轴正方向规定为左。

    OK,看到这大家或许还会有点懵…

    想问我到底该怎么使用它呢?

    import turtle
    
    turtle.penup()
    turtle.pensize(2)
    turtle.pendown()
    turtle.fd(100)
    turtle.fd(-100)
    turtle.rt(90)
    turtle.fd(100)
    turtle.lt(-90)
    turtle.fd(100)
    turtle.done()
    

    大家看不懂没关系

    下面来和大家一起逐条分析这些代码

    import turtle  # 引入turtle库,此后的每一句的格式都应遵循turtle.<b>()的格式
    
    
    turtle.penup()  # 这句代码的意思是我们先将这只海龟从画布上拿起来,这样它就不会在画布上留下痕迹
    
    
    turtle.pensize()  # 我们可以通过pensize()来设置海龟身体的宽度,就是画笔的粗细
    
    turtle.pendown()  # pendown()与penup()是成对出现的,penup()是将海龟拿起来,那么与之相反,pendown()就是将拿起来的海龟放回画布上,这时我们就准备开始让海龟爬行进行图形的绘制了
    
    

    海龟在画布上的初始位置就是画布的中心

    我们以此点为原点建立直角坐标系。

    turtle.fd(100)  # 这句代码的意思是我们让海龟向前前进100个像素点  turtle.fd(-100) # 这句代码的意思就是我们让海龟向后退100个像素点,但此时我们要注意海龟的头部依然是指向x轴正方向,海龟向后退的过程中并没有先向后转再向x轴负方向前进100个像素点
    
    
    turtle.rt(90)  # 海龟向右旋转90°,即向y轴负方向顺时针旋转90°,如果括号里的值为-90,那就是逆时针旋转90°
    
    
    turtle.lt()  # 同上,这句代码的意思就是海龟向左旋转90°,如果括号里的值为-90,就是逆时针旋转90°
    
    
    turtle.fd()  # 此时这行代码的意思就是海龟调整方向后,向前行进100像素点
    
    turtle.done()  # 大家运行上面这些代码时如果不加这一行代码,会发现,运行完后画布窗口便会立即关闭,所以这一行代码的作用就是让画布窗口停留
    
    

    通过上面的讲解,大家现在可以去试着绘制一些简易的图形

    比如:矩形,三角形

    以此来巩固turtle库的基本使用方法

    1. 画布(canvas)**

    画布就是turtle展开用于绘图区域, 可以设置它的大小和初始位置

    1.1 设置画布大小

    turtle.screensize(canvwidth=None, canvheight=None, bg=None)
    

    参数分别为画布的宽(单位像素), 高, 背景颜色

    如:

    turtle.screensize(800, 600, "green")
    turtle.screensize() #返回默认大小(400, 300)
    
    turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
    

    参数:
    width, height: 输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例
    (startx, starty): 这一坐标表示 矩形窗口左上角顶点的位置, 如果为空,则窗口位于屏幕中心

    如:

    turtle.setup(width=0.6, height=0.6)
    turtle.setup(width=800, height=800, startx=100, starty=100)
    

    2. 画笔

    2.1 画笔的状态

    在画布上,默认有一个坐标原点为画布中心的坐标轴, 坐标原点上有一只面朝x轴正方向小乌龟. 这里我们描述小乌龟时使用了两个词语:坐标原点(位置),面朝x轴正方向(方向), turtle绘图中, 就是使用位置方向描述小乌龟(画笔)的状态

    2.2 画笔的属性

    画笔(画笔的属性,颜色、画线的宽度)

    1. turtle.pensize():设置画笔的宽度;
    2. turtle.pencolor(); 没有参数传入,返回当前画笔颜色,传入参数设置画笔颜色,可以是字符串如"green", “red”,也可以是RGB 3元组,
    pencolor('brown')
    
    tup = (0.2, 0.8, 0.55)
    
    pencolor(tup)
    
    pencolor()    '#33cc8c'
    
    1. turtle.speed(speed): 设置画笔移动速度,画笔绘制的速度范围[0,10]整数, 数字越大越快

    2.3 绘图命令

    操纵海龟绘图有着许多的命令,这些命令可以划分为3种:一种为运动命令,一种为画笔控制命令,还有一种是全局控制命令

    画笔运动命令:

    命令说明
    turtle.forward(distance)向当前画笔方向移动distance像素长
    turtle.backward(distance)向当前画笔相反方向移动distance像素长度
    turtle.right(degree)顺时针移动degree°
    turtle.left(degree)逆时针移动degree°
    turtle.pendown()移动时绘制图形,缺省时也为绘制
    turtle.goto(x,y)将画笔移动到坐标为x,y的位置
    turtle.penup()移动时不绘制图形,提起笔,用于另起一个地方绘制时用
    turtle.speed(speed)画笔绘制的速度范围[0,10]整数
    turtle.circle()画圆,半径为正(负),表示圆心在画笔的左边(右边)画圆

    (2)画笔控制命令:

    命令说明
    turtle.pensize(width)绘制图形时的宽度
    turtle.pencolor()画笔颜色
    turtle.fillcolor(colorstring)绘制图形的填充颜色
    turtle.color(color1, color2)同时设置pencolor=color1, fillcolor=color2
    turtle.filling()返回当前是否在填充状态
    turtle.begin_fill()准备开始填充图形
    turtle.end_fill()填充完成;
    turtle.hideturtle()隐藏箭头显示;
    turtle.showturtle()与hideturtle()函数对应

    (3) 全局控制命令

    命令说明
    turtle.clear()清空turtle窗口,但是turtle的位置和状态不会改变
    turtle.reset()清空窗口,重置turtle状态为起始状态
    turtle.undo()撤销上一个turtle动作
    turtle.isvisible()返回当前turtle是否可见
    stamp()复制当前图形
    turtle.write(s[,font=(“font-name”,font_size,“font_type”)])写文本,s为文本内容,font是字体的参数,里面分别为字体名称,大小和类型;font为可选项, font的参数也是可选项

    3. 命令详解

    turtle.circle(radius,extent=None,steps=None)
    

    描述: 以给定半径画圆
    参数:
    radius(半径); 半径为正(负),表示圆心在画笔的左边(右边)画圆
    extent(弧度) (optional);
    steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

    举例:

    circle(50)      # 整圆
    circle(50,steps=3)    # 三角形
    circle(120, 180)     # 半圆
    

    4. 绘图举例

    4.1 太阳花

    import turtle as t
    
    import time
    
    t.goto(0, 0)
    t.color("red", "yellow")
    t.speed(10)
    t.begin_fill()
    
    for i in range(50):
        t.forward(500)
        t.left(170)
    t.end_fill()
    time.sleep(1)
    

    奥运五环

        一只乌龟
        蓝黑红黄绿
        """
        # 导入turtle
        import turtle
        
        turtle.showturtle()
        turtle.pensize(5)
        
        turtle.color("blue")
        turtle.penup()
        turtle.goto(-110, 0)
        turtle.pendown()
        turtle.circle(45)
        
        
        turtle.color("black")
        turtle.penup()
        turtle.goto(0, 0)
        turtle.pendown()
        turtle.circle(45)
        
        
        turtle.color("red")
        turtle.penup()
        turtle.goto(110, 0)
        turtle.pendown()
        turtle.circle(45)
        
        
        turtle.color("yellow")
        turtle.penup()
        turtle.goto(-55, -45)
        turtle.pendown()
        turtle.circle(45)
        
        turtle.color("green")
        turtle.penup()
        turtle.goto(55, -45)
        turtle.pendown()
        turtle.circle(45)
        
        
        #书写口号
        
        turtle.color("green")
        turtle.penup()
        turtle.goto(-100, -120)
        turtle.pendown()
        turtle.write("好好学习",font=("微软雅黑",20,"italic"))
        
        turtle.done()   # #保神窗口的消息循环,而不是退出程序
    
    循环立体图
    
        # -*- coding: utf-8 -*-
        import turtle
        
        for i in range(1, 500):   # 重复500次
            turtle.forward(i)
            turtle.left(91)
    

    太阳花

    
    
        import time
        
        import turtle as t
        
        t.goto(0, 0)
        t.color("red", "yellow")
        t.speed(10)
        t.begin_fill()
        
        for i in range(50):
            t.forward(500)
            t.left(170)
        t.end_fill()
        time.sleep(1)
    

    绘制分形树

        # -*- coding: utf-8 -*-
        '''
        绘制分形树
        '''
        
        import turtle as tl
        
        
        def draw_smalltree(tree_length, tree_angle):
            '''
            绘制分形树函数
            '''
            if tree_length >= 3:
                tl.forward(tree_length)  # 往前画
                tl.right(tree_angle)  # 往右转
                draw_smalltree(tree_length - 10, tree_angle)  # 画下一枝,直到画到树枝长小于3
        
                tl.left(2 * tree_angle)  # 转向画左
                draw_smalltree(tree_length - 10, tree_angle)  # 直到画到树枝长小于3
        
                tl.rt(tree_angle)  # 转到正向上的方向,然后回溯到上一层
                if tree_length <= 30:  # 树枝长小于30,可以当作树叶了,树叶部分为绿色
                    tl.pencolor('green')
                if tree_length > 30:
                    tl.pencolor('brown')  # 树干部分为棕色
                tl.backward(tree_length)  # 往回画,回溯到上一层
        
        
        def main():
            tl.penup()
            # tl.pencolor('green')
            tl.left(90)  # 因为树是往上的,所以先把方向转左
            tl.backward(250)  # 把起点放到底部
            tl.pendown()
            tree_length = 100  # 我设置的最长树干为100
            tree_angle = 20  # 树枝分叉角度,我设为20
            draw_smalltree(tree_length, tree_angle)
            tl.exitonclick()  # 点击才关闭画画窗口
        
        
        if __name__ == '__main__':
            main()
    

    美队盾牌

        # -*- coding:utf-8 -*-
        import turtle
        import math
        
        
        def shield():
            '''
            该函数的作用是画一个美国队长的盾牌,并将其保存到本地
            '''
            # 设置画布背景
            turtle.bgcolor('#FFFFFF')
            # 设置画笔速度
            turtle.speed(10)
            # 依次填充同心圆
            fill_circle('#FF0000', 230)
            fill_circle('#FFFFFF', 178)
            fill_circle('#FF0000', 129)
            fill_circle('#0000FF', 75)
            # 完成五角星
            draw_five('#FFFFFF', 75)
            # 以下代码,将画好的图案按指定格式保存到当前文件目录
            # windows 可以使用.jpg/.ps格式,MAC使用.eps/.ps格式
            ts = turtle.getscreen()
            ts.getcanvas().postscript(file="shield.eps")
            # 启动事件循环,必须是乌龟图形程序中的最后一个语句
            # 如果没有这个语句,代码运行完成后,窗口直接消失。
            turtle.done()
        
        
        def draw_circle(radium):
            '''
            该函数的作用是画一个圆线
            :param radium:半径
            '''
            # 画笔定位到圆点
            turtle.home()
            # 提笔
            turtle.penup()
            # 向前移动指定的半径
            turtle.forward(radium)
            # 落笔
            turtle.pendown()
            # 偏转角度
            turtle.setheading(90)
            # 画一个指定半径的圆
            turtle.circle(radium)
            # 提笔
            turtle.penup()
        
        
        def fill_circle(color, r1):
            '''
            该函数的作用是,画一个圆环,有指定的填充色和半径
            :param color:颜色
            :param r1:半径
            '''
            # 设置画笔颜色
            turtle.pencolor(color)
            # 设置填充颜色
            turtle.fillcolor(color)
            # 开始填充
            turtle.begin_fill()
            # 画圆线
            draw_circle(r1)
            # 结束填充
            turtle.end_fill()
        
        
        def draw_five(color, radium):
            '''
            该函数的作用是画一个五角星
            :param color:颜色
            :para radium:
            '''
            # 画笔定位到圆点
            turtle.home()
            # 提笔
            turtle.penup()
            # 偏转90度
            turtle.setheading(90)
            # 向前移动90个像素
            turtle.forward(radium)
            # 偏转288度
            turtle.setheading(288)
            # 落笔
            turtle.pendown()
            # radians()将角度转换为弧度
            long_side = (math.sin(math.radians(36)) * radium) / math.sin(math.radians(126))
            # 设置画笔颜色
            turtle.pencolor(color)
            # 设置填充颜色
            turtle.fillcolor(color)
            # 开始填充
            turtle.begin_fill()
            for i in range(10):
                turtle.forward(long_side)
                if i % 2 == 0:
                    turtle.left(72)
                else:
                    turtle.right(144)
            # 结束填充
            turtle.end_fill()
            # 提笔
            turtle.penup()
        
        
        # 运行主函数
        shield()
    

    小猪佩奇

        # coding:utf-8
        
        import turtle as t
        
        # 绘制小猪佩奇# =======================================
        
        t.pensize(4)
        t.hideturtle()
        t.colormode(255)
        t.color((255, 155, 192), "pink")
        t.setup(840, 500)
        t.speed(10)
        
        # 鼻子
        
        t.pu()
        t.goto(-100, 100)
        t.pd()
        t.seth(-30)
        t.begin_fill()
        a = 0.4
        
        for i in range(120):
        
            if 0 <= i < 30 or 60 <= i < 90:
                a = a + 0.08
                t.lt(3)  # 向左转3度
                t.fd(a)  # 向前走a的步长
            else:
                a = a - 0.08
                t.lt(3)
                t.fd(a)
                t.end_fill()
        
        t.pu()
        t.seth(90)
        t.fd(25)
        t.seth(0)
        t.fd(10)
        t.pd()
        t.pencolor(255, 155, 192)
        t.seth(10)
        t.begin_fill()
        t.circle(5)
        t.color(160, 82, 45)
        t.end_fill()
        
        t.pu()
        t.seth(0)
        t.fd(20)
        t.pd()
        t.pencolor(255, 155, 192)
        t.seth(10)
        t.begin_fill()
        t.circle(5)
        t.color(160, 82, 45)
        t.end_fill()
        
        # 头
        
        t.color((255, 155, 192), "pink")
        
        t.pu()
        t.seth(90)
        t.fd(41)
        t.seth(0)
        t.fd(0)
        t.pd()
        t.begin_fill()
        t.seth(180)
        t.circle(300, -30)
        t.circle(100, -60)
        t.circle(80, -100)
        t.circle(150, -20)
        t.circle(60, -95)
        t.seth(161)
        t.circle(-300, 15)
        t.pu()
        t.goto(-100, 100)
        t.pd()
        t.seth(-30)
        a = 0.4
        
        for i in range(60):
        
            if 0 <= i < 30 or 60 <= i < 90:
        
                a = a + 0.08
                t.lt(3)  # 向左转3度
                t.fd(a)  # 向前走a的步长
            else:
                a = a - 0.08
                t.lt(3)
                t.fd(a)
                t.end_fill()
        
        # 耳朵
        
        t.color((255, 155, 192), "pink")
        t.pu()
        t.seth(90)
        t.fd(-7)
        t.seth(0)
        t.fd(70)
        t.pd()
        t.begin_fill()
        t.seth(100)
        t.circle(-50, 50)
        t.circle(-10, 120)
        t.circle(-50, 54)
        t.end_fill()
        
        t.pu()
        t.seth(90)
        t.fd(-12)
        t.seth(0)
        t.fd(30)
        t.pd()
        t.begin_fill()
        t.seth(100)
        t.circle(-50, 50)
        t.circle(-10, 120)
        t.circle(-50, 56)
        t.end_fill()
        
        # 眼睛
        
        t.color((255, 155, 192), "white")
        t.pu()
        t.seth(90)
        t.fd(-20)
        t.seth(0)
        t.fd(-95)
        t.pd()
        t.begin_fill()
        t.circle(15)
        t.end_fill()
        
        t.color("black")
        t.pu()
        t.seth(90)
        t.fd(12)
        t.seth(0)
        t.fd(-3)
        t.pd()
        t.begin_fill()
        t.circle(3)
        t.end_fill()
        
        t.color((255, 155, 192), "white")
        t.pu()
        t.seth(90)
        t.fd(-25)
        t.seth(0)
        t.fd(40)
        t.pd()
        t.begin_fill()
        t.circle(15)
        t.end_fill()
        
        t.color("black")
        t.pu()
        t.seth(90)
        t.fd(12)
        t.seth(0)
        t.fd(-3)
        t.pd()
        t.begin_fill()
        t.circle(3)
        t.end_fill()
        
        # 腮
        
        t.color((255, 155, 192))
        t.pu()
        t.seth(90)
        t.fd(-95)
        t.seth(0)
        t.fd(65)
        t.pd()
        t.begin_fill()
        t.circle(30)
        t.end_fill()
        
        # 嘴
        
        t.color(239, 69, 19)
        t.pu()
        t.seth(90)
        t.fd(15)
        t.seth(0)
        t.fd(-100)
        t.pd()
        t.seth(-80)
        t.circle(30, 40)
        t.circle(40, 80)
        
        # 身体
        
        t.color("red", (255, 99, 71))
        t.pu()
        t.seth(90)
        t.fd(-20)
        t.seth(0)
        t.fd(-78)
        t.pd()
        t.begin_fill()
        t.seth(-130)
        t.circle(100, 10)
        t.circle(300, 30)
        t.seth(0)
        t.fd(230)
        t.seth(90)
        t.circle(300, 30)
        t.circle(100, 3)
        t.color((255, 155, 192), (255, 100, 100))
        t.seth(-135)
        t.circle(-80, 63)
        t.circle(-150, 24)
        t.end_fill()
        
        # 手
        
        t.color((255, 155, 192))
        t.pu()
        t.seth(90)
        t.fd(-40)
        t.seth(0)
        t.fd(-27)
        t.pd()
        t.seth(-160)
        t.circle(300, 15)
        t.pu()
        t.seth(90)
        t.fd(15)
        t.seth(0)
        t.fd(0)
        t.pd()
        t.seth(-10)
        t.circle(-20, 90)
        
        t.pu()
        t.seth(90)
        t.fd(30)
        t.seth(0)
        t.fd(237)
        t.pd()
        t.seth(-20)
        t.circle(-300, 15)
        t.pu()
        t.seth(90)
        t.fd(20)
        t.seth(0)
        t.fd(0)
        t.pd()
        t.seth(-170)
        t.circle(20, 90)
        
        # 脚
        
        t.pensize(10)
        t.color((240, 128, 128))
        t.pu()
        t.seth(90)
        t.fd(-75)
        t.seth(0)
        t.fd(-180)
        t.pd()
        t.seth(-90)
        t.fd(40)
        t.seth(-180)
        t.color("black")
        t.pensize(15)
        t.fd(20)
        
        t.pensize(10)
        t.color((240, 128, 128))
        t.pu()
        t.seth(90)
        t.fd(40)
        t.seth(0)
        t.fd(90)
        t.pd()
        t.seth(-90)
        t.fd(40)
        t.seth(-180)
        t.color("black")
        t.pensize(15)
        t.fd(20)
        
        # 尾巴
        
        t.pensize(4)
        t.color((255, 155, 192))
        t.pu()
        t.seth(90)
        t.fd(70)
        t.seth(0)
        t.fd(95)
        t.pd()
        t.seth(0)
        t.circle(70, 20)
        t.circle(10, 330)
        t.circle(70, 30)
        t.done()
    
    展开全文
  • windows下Python图形化工具Matplotlib安装

    千次阅读 2016-04-22 16:25:05
    windows下Python图形化工具Matplotlib安装本人最近打算用科学运算生成的数据来进行可视化展示,无奈java的图形化接口太稀缺,Matlab太过庞大,不想多折腾。刚好最近用Python在做数值运算,看了一些网上说的工具,...
  • Python图形化用户界面入门实例-tkinter

    千次阅读 2019-08-22 09:52:42
    Python图形化用户界面入门实例-tkinter写在前面成果展示tkinter库介绍引入SpeedShow类类初始化添加控件数据显示爬虫主函数写在后面1.静态网页爬取2.动态网页请求获取3.时间处理问题 写在前面 其实上一篇文章的小项目...
  • python儿童编程;第一章 开始;3.和计算机交流吧;第二章 编程第一步变量;4.什么是变量;第三章 编程第二步常用数据;1.字符串String;1.字符串String;2.比字符串更强大的列表list;2.另一种列表元祖tuples;2.帮你找到你想...
  • python自带了tkinter模块,提供了快速创建GUI程序的方法。 import tkinter #导入tkinter模块 root=tkinter.Tk() root.title('我的第一个python窗体') #title root.geometry('320x240') #这里的乘号是英...
  • Python 图形化编程实例

    千次阅读 2017-12-20 12:59:46
    # coding=utf-8 import Tkinter as tk import time def processButton(): if v1. get () == ...v1 =tk....rbPiliang =tk....frame2 =tk....v1 =tk....rbPiliang =tk....frame2 =tk....图形化界面:
  • python图形化进度条 实战一(GUI干货)

    千次阅读 2020-02-29 00:48:10
    我刚接触python tkinter图形化界面时也是一脸懵逼,当时连多线程、多进程都搞不明白的我又怎能搞懂图形化界面。出于对python的热爱,使我一直坚持走到了这步,一路遇到了很多艰险,接下来我把整体的思路和代码实现给...
  • PySide2-5.15.2-5.15.2-cp35.cp36.cp37.cp38.cp39-none-win_amd64.whl
  • 运行结果: 参考: 1)图形化界面 https://blog.csdn.net/jacky_zhuyuanlu/article/details/77475635 Python图形用户界面-Tkinter https://segmentfault.com/a/1190000021662869 Python图形界面GUI程序设计(画一...
  • 如何在linux系统的服务器上创建新用户,并运行python图形化界面 使用secureCRT新建连接,输入hostname登陆,例如“192.1681.1.83” 使用命令“su”来获取root权限 使用命令“useradd -d /usr/liye -m liye”创建usr...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,693
精华内容 50,677
关键字:

python图形化

python 订阅