精华内容
下载资源
问答
  • Python布局管理

    2016-09-13 17:07:20
    创建sizers布局管理器 调用SetSizer()将布局管理器添加到容器中 调用Add()将组件添加到布局管理器中 调用Fit()计算计算布局布局管理器和容器窗口的大小 #-*- coding:utf-8 -*- import wx class gridbagSizer(wx....

    使用步骤:

    创建sizers布局管理器

    调用SetSizer()将布局管理器添加到容器中

    调用Add()将组件添加到布局管理器中

    调用Fit()计算计算布局布局管理器和容器窗口的大小

    #-*- coding:utf-8 -*-
    import wx
    class gridbagSizer(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u"布局管理器之-表格",size = (500,500))
            self.panel = wx.Panel(self,-1)
            self.grid = wx.GridBagSizer(hgap= 5, vgap =5) 
            colorlist =  [u'红',u'绿',u'蓝',u'黄']
            col =0
            for color in colorlist:
                btn = wx.Button(self.panel,-1,color)
                self.grid.Add(btn,pos = (0,col))
                col = col + 1
            btn = wx.Button(self.panel,-1,u'白')
            self.grid.Add(btn,pos = (1,0),span = (1,3),flag = wx.EXPAND)
            
            btn1 = wx.Button(self.panel,-1,u'紫')
            self.grid.Add(btn1,pos = (2,1),span = (2,2),flag = wx.EXPAND)
            
            self.panel.SetSizer(self.grid)
            self.panel.Fit()
    if __name__ == '__main__':
        app = wx.PySimpleApp()
        fram = gridbagSizer()
        fram.Show()
        app.MainLoop()
    #-*- coding:utf-8 -*-
    import wx
    class MyBoxSizer(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u"布局管理器之-表格",size = (500,500))
            self.panel = wx.Panel(self,-1)
            self.grid = wx.BoxSizer(wx.HORIZONTAL) 
            self.grid1 = wx.BoxSizer(wx.VERTICAL) 
            self.grid2 = wx.BoxSizer(wx.VERTICAL) 
            colorlist =  [u'红',u'绿',u'蓝',u'黄']
            col =0
            for color in colorlist:
                btn = wx.Button(self.panel,-1,color)
                self.grid1.Add(btn)
            for color in colorlist:
                btn = wx.Button(self.panel,-1,color)
                self.grid2.Add(btn)
            self.grid.Add(self.grid1,flag=wx.EXPAND)  #嵌套
            self.grid.Add(self.grid2,flag=wx.EXPAND)  #嵌套
            
            self.panel.SetSizer(self.grid)
            self.panel.Fit()
    if __name__ == '__main__':
        app = wx.PySimpleApp()
        fram = MyBoxSizer()
        fram.Show()
        app.MainLoop()



    #-*- coding:utf-8 -*-
    import wx
    class MyBoxSizer(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u"布局管理器之-表格",size = (500,500))
            self.panel = wx.Panel(self,-1)
            self.grid = wx.BoxSizer(wx.HORIZONTAL) 
            self.grid1 = wx.BoxSizer(wx.VERTICAL) 
            self.grid2 = wx.BoxSizer(wx.VERTICAL) 
            colorlist =  [u'红',u'绿',u'蓝',u'黄']
            col =0
            for color in colorlist:
                btn = wx.Button(self.panel,-1,color)
                self.grid1.Add(btn)
            for color in colorlist:
                btn = wx.Button(self.panel,-1,color)
                self.grid2.Add(btn)
            self.grid.Add(self.grid1,flag=wx.EXPAND)  #嵌套
            self.grid.Add(self.grid2,flag=wx.EXPAND)  #嵌套
            
            self.panel.SetSizer(self.grid)
            self.panel.Fit()
    if __name__ == '__main__':
        app = wx.PySimpleApp()
        fram = MyBoxSizer()
        fram.Show()
        app.MainLoop()



    展开全文
  • from the Python Imaging Library (PIL) module. style = Style() style.configure("TFrame", background="#333") We configure our frame to have a dark gray background using styles. bard = ...

    

    Layout management in Tkinter

    In this part of the Tkinter programming tutorial, we introduce layout managers.

    When we design the GUI of our application, we decide what widgets we will use and how we will organise those widgets in the application. To organise our widgets, we use specialised non-visible objects called layout managers.

    There are two kinds of widgets: containers and their children. The containers group their children into suitable layouts.

    Tkinter has three built-in layout managers: the pack, grid, and place managers. The place geometry manager positions widgets using absolute positioning. The pack geometry manager organises widgets in horizontal and vertical boxes. The grid geometry manager places widgets in a two dimensional grid.

    Absolute positioning

    In most cases, programmers should use layout managers. There are a few situations where we could use absolute positioning. In absolute positioning, the programmer specifies the position and the size of each widget in pixels. The size and the position of a widget do not change if we resize a window. Applications look different on various platforms, and what looks OK on Linux, might not look OK on Mac OS. Changing fonts in our application might spoil the layout. If we translate our application into another language, we must redo our layout.

    absolute.py

    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    
    """
    ZetCode Tkinter tutorial
    
    In this script, we lay out images
    using absolute positioning.
    
    Author: Jan Bodnar
    Last modified: July 2017
    Website: www.zetcode.com
    """
    
    from PIL import Image, ImageTk
    from tkinter import Tk, BOTH
    from tkinter.ttk import Frame, Label, Style
    
    class Example(Frame):
      
        def __init__(self):
            super().__init__()   
             
            self.initUI()
    
            
        def initUI(self):
          
            self.master.title("Absolute positioning")
            self.pack(fill=BOTH, expand=1)
            
            Style().configure("TFrame", background="#333")
            
            bard = Image.open("bardejov.jpg")
            bardejov = ImageTk.PhotoImage(bard)
            label1 = Label(self, image=bardejov)
            label1.image = bardejov
            label1.place(x=20, y=20)
            
            rot = Image.open("rotunda.jpg")
            rotunda = ImageTk.PhotoImage(rot)
            label2 = Label(self, image=rotunda)
            label2.image = rotunda
            label2.place(x=40, y=160)        
            
            minc = Image.open("mincol.jpg")
            mincol = ImageTk.PhotoImage(minc)
            label3 = Label(self, image=mincol)
            label3.image = mincol
            label3.place(x=170, y=50)        
                  
    
    def main():
      
        root = Tk()
        root.geometry("300x280+300+300")
        app = Example()
        root.mainloop()  
    
    
    if __name__ == '__main__':
        main()  
    

    In this example, we place three images using absolute positioning. We use the place geometry manager.

    from PIL import Image, ImageTk
    

    We use Image and ImageTk from the Python Imaging Library (PIL) module.

    style = Style()
    style.configure("TFrame", background="#333") 
    

    We configure our frame to have a dark gray background using styles.

    bard = Image.open("bardejov.jpg")
    bardejov = ImageTk.PhotoImage(bard)
    

    We create an image object and a photo image object from an image in the current working directory.

    label1 = Label(self, image=bardejov)
    

    We create a Label with an image. Labels can contain text or images.

    label1.image = bardejov
    

    We must keep the reference to the image to prevent image from being garbage collected.

    label1.place(x=20, y=20)
    

    The label is placed on the frame at x=20 and y=20 coordinates.

    AbsoluteFigure: Absolute positioning

    Pack manager

    The pack geometry manager organises widgets in horizontal and vertical boxes. The layout is controlled with the fill, expand, and side options.

    Buttons example

    In the following example, we position two buttons in the bottom-right corner of the window. We use the pack manager.

    buttons.py

    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    
    """
    ZetCode Tkinter tutorial
    
    In this script, we use the pack manager
    to position two buttons in the
    bottom-right corner of the window. 
    
    Author: Jan Bodnar
    Last modified: July 2017
    Website: www.zetcode.com
    """
    
    from tkinter import Tk, RIGHT, BOTH, RAISED
    from tkinter.ttk import Frame, Button, Style
    
    class Example(Frame):
      
        def __init__(self):
            super().__init__()   
             
            self.initUI()
    
            
        def initUI(self):
          
            self.master.title("Buttons")
            self.style = Style()
            self.style.theme_use("default")
            
            frame = Frame(self, relief=RAISED, borderwidth=1)
            frame.pack(fill=BOTH, expand=True)
            
            self.pack(fill=BOTH, expand=True)
            
            closeButton = Button(self, text="Close")
            closeButton.pack(side=RIGHT, padx=5, pady=5)
            okButton = Button(self, text="OK")
            okButton.pack(side=RIGHT)
                  
    
    def main():
      
        root = Tk()
        root.geometry("300x200+300+300")
        app = Example()
        root.mainloop()  
    
    
    if __name__ == '__main__':
        main()  
    

    We have two frames. There is the base frame and an additional frame, which expands in both directions and push the two buttons to the bottom of the base frame. The buttons are placed in a horizontal box and placed to the right of this box.

    frame = Frame(self, relief=RAISED, borderwidth=1)
    frame.pack(fill=BOTH, expand=True)
    

    We create another Frame widget. This widget takes the bulk of the area. We change the border of the frame so that the frame is visible; by default it is flat.

    closeButton = Button(self, text="Close")
    closeButton.pack(side=RIGHT, padx=5, pady=5)
    

    A closeButton is created. It is put into a horizontal box. The side parameter causes the button to be placed to the right of the horizontal. The padx and the pady parameters put some space between the widgets. The padx puts some space between the button widgets and between the closeButton and the right border of the root window. The pady puts some space between the button widgets and the borders of the frame and the borders of the root window.

    okButton.pack(side=RIGHT)
    

    The okButton is placed next to the closeButton with 5 px space between them.

    Buttons exampleFigure: Buttons example

    Review example

    The pack manager is a simple layout manager. It can be used to do simple layout tasks. In order to create more complicated layouts, we need to utilise more frames, each having its own pack manager.

    review.py

    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    
    """
    ZetCode Tkinter tutorial
    
    In this script, we use the pack manager
    to position two buttons in the
    bottom-right corner of the window. 
    
    Author: Jan Bodnar
    Last modified: July 2017
    Website: www.zetcode.com
    """
    
    from tkinter import Tk, Text, TOP, BOTH, X, N, LEFT
    from tkinter.ttk import Frame, Label, Entry
    
    
    class Example(Frame):
      
        def __init__(self):
            super().__init__()   
             
            self.initUI()
    
            
        def initUI(self):
          
            self.master.title("Review")
            self.pack(fill=BOTH, expand=True)
            
            frame1 = Frame(self)
            frame1.pack(fill=X)
            
            lbl1 = Label(frame1, text="Title", width=6)
            lbl1.pack(side=LEFT, padx=5, pady=5)           
           
            entry1 = Entry(frame1)
            entry1.pack(fill=X, padx=5, expand=True)
            
            frame2 = Frame(self)
            frame2.pack(fill=X)
            
            lbl2 = Label(frame2, text="Author", width=6)
            lbl2.pack(side=LEFT, padx=5, pady=5)        
    
            entry2 = Entry(frame2)
            entry2.pack(fill=X, padx=5, expand=True)
            
            frame3 = Frame(self)
            frame3.pack(fill=BOTH, expand=True)
            
            lbl3 = Label(frame3, text="Review", width=6)
            lbl3.pack(side=LEFT, anchor=N, padx=5, pady=5)        
    
            txt = Text(frame3)
            txt.pack(fill=BOTH, pady=5, padx=5, expand=True)           
                  
    
    def main():
      
        root = Tk()
        root.geometry("300x300+300+300")
        app = Example()
        root.mainloop()  
    
    
    if __name__ == '__main__':
        main()  
    

    The example shows how to create a more complex layout with multiple frames and pack managers.

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

    The first frame is the base frame, on which other frames are placed. Note that in addition to organising children within frames, we also manage the frames on the base frame.

    frame1 = Frame(self)
    frame1.pack(fill=X)
    
    lbl1 = Label(frame1, text="Title", width=6)
    lbl1.pack(side=LEFT, padx=5, pady=5)           
    
    entry1 = Entry(frame1)
    entry1.pack(fill=X, padx=5, expand=True)
    

    The first two widgets are placed on the first frame. The entry is horizontally streched with the fill and the expand parameters.

    frame3 = Frame(self)
    frame3.pack(fill=BOTH, expand=True)
    
    lbl3 = Label(frame3, text="Review", width=6)
    lbl3.pack(side=LEFT, anchor=N, padx=5, pady=5)        
    
    txt = Text(frame3)
    txt.pack(fill=BOTH, pady=5, padx=5, expand=True) 
    

    Inside the third frame, we place a label and a text widget. The label is anchored to the north. The text widget takes the whole remaining area.

    Review exampleFigure: Review example

    Grid manager

    The Tkinter's grid geometry manager is used to create a skeleton of a calculator.

    calculator.py

    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    
    """
    ZetCode Tkinter tutorial
    
    In this script, we use the grid manager
    to create a skeleton of a calculator.
    
    Author: Jan Bodnar
    Last modified: July 2017
    Website: www.zetcode.com
    """
    
    from tkinter import Tk, W, E
    from tkinter.ttk import Frame, Button, Entry, Style
    
    class Example(Frame):
      
        def __init__(self):
            super().__init__()   
             
            self.initUI()
    
            
        def initUI(self):
          
            self.master.title("Calculator")
            
            Style().configure("TButton", padding=(0, 5, 0, 5), 
                font='serif 10')
            
            self.columnconfigure(0, pad=3)
            self.columnconfigure(1, pad=3)
            self.columnconfigure(2, pad=3)
            self.columnconfigure(3, pad=3)
            
            self.rowconfigure(0, pad=3)
            self.rowconfigure(1, pad=3)
            self.rowconfigure(2, pad=3)
            self.rowconfigure(3, pad=3)
            self.rowconfigure(4, pad=3)
            
            entry = Entry(self)
            entry.grid(row=0, columnspan=4, sticky=W+E)
            cls = Button(self, text="Cls")
            cls.grid(row=1, column=0)
            bck = Button(self, text="Back")
            bck.grid(row=1, column=1)
            lbl = Button(self)
            lbl.grid(row=1, column=2)    
            clo = Button(self, text="Close")
            clo.grid(row=1, column=3)        
            sev = Button(self, text="7")
            sev.grid(row=2, column=0)        
            eig = Button(self, text="8")
            eig.grid(row=2, column=1)         
            nin = Button(self, text="9")
            nin.grid(row=2, column=2) 
            div = Button(self, text="/")
            div.grid(row=2, column=3) 
            
            fou = Button(self, text="4")
            fou.grid(row=3, column=0)        
            fiv = Button(self, text="5")
            fiv.grid(row=3, column=1)         
            six = Button(self, text="6")
            six.grid(row=3, column=2) 
            mul = Button(self, text="*")
            mul.grid(row=3, column=3)    
            
            one = Button(self, text="1")
            one.grid(row=4, column=0)        
            two = Button(self, text="2")
            two.grid(row=4, column=1)         
            thr = Button(self, text="3")
            thr.grid(row=4, column=2) 
            mns = Button(self, text="-")
            mns.grid(row=4, column=3)         
            
            zer = Button(self, text="0")
            zer.grid(row=5, column=0)        
            dot = Button(self, text=".")
            dot.grid(row=5, column=1)         
            equ = Button(self, text="=")
            equ.grid(row=5, column=2) 
            pls = Button(self, text="+")
            pls.grid(row=5, column=3)
            
            self.pack()
    
    
    def main():
      
        root = Tk()
        app = Example()
        root.mainloop()  
    
    
    if __name__ == '__main__':
        main()   
    

    The grid manager is used to organize buttons in the frame container.

    Style().configure("TButton", padding=(0, 5, 0, 5), 
        font='serif 10')
    

    We configure the Button widget to have a specific font and to have some internal padding.

    self.columnconfigure(0, pad=3)
    ...        
    self.rowconfigure(0, pad=3)
    

    We use the columnconfigure() and the rowconfigure() methods to define some space in grid columns and rows. This way we achieve that the buttons are separated by some space.

    entry = Entry(self)
    entry.grid(row=0, columnspan=4, sticky=W+E)
    

    The Entry widget is where the digits are displayed. The widget is placed in the first row and it spans all four columns. Widgets may not occupy all the space allotted by cells in the grid. The sticky parameter expands the widget in a given direction. In our case we ensure that the entry widget is expanded from left to right.

    cls = Button(self, text="Cls")
    cls.grid(row=1, column=0)
    

    The cls button is placed in the second row and first column. Note that the rows and columns start at zero.

    self.pack()
    

    The pack() method shows the frame widget and gives it initial size. If no other parameters are given, the size will be just enough to show all children. This method packs the frame widget to the toplevel root window, which is also a container. The grid geometry manager is used to organize buttons in the frame widget.

    CalculatorFigure: Calculator

    Windows example

    The following example creates the windows dialog using the grid geometry manager.

    windows.py

    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    
    """
    ZetCode Tkinter tutorial
    
    In this script, we use the grid
    manager to create a more complicated
    layout.
    
    Author: Jan Bodnar
    Last modified: July 2017
    Website: www.zetcode.com
    """
    
    from tkinter import Tk, Text, BOTH, W, N, E, S
    from tkinter.ttk import Frame, Button, Label, Style
    
    
    class Example(Frame):
      
        def __init__(self):
            super().__init__()   
             
            self.initUI()
            
            
        def initUI(self):
          
            self.master.title("Windows")
            self.pack(fill=BOTH, expand=True)
    
            self.columnconfigure(1, weight=1)
            self.columnconfigure(3, pad=7)
            self.rowconfigure(3, weight=1)
            self.rowconfigure(5, pad=7)
            
            lbl = Label(self, text="Windows")
            lbl.grid(sticky=W, pady=4, padx=5)
            
            area = Text(self)
            area.grid(row=1, column=0, columnspan=2, rowspan=4, 
                padx=5, sticky=E+W+S+N)
            
            abtn = Button(self, text="Activate")
            abtn.grid(row=1, column=3)
    
            cbtn = Button(self, text="Close")
            cbtn.grid(row=2, column=3, pady=4)
            
            hbtn = Button(self, text="Help")
            hbtn.grid(row=5, column=0, padx=5)
    
            obtn = Button(self, text="OK")
            obtn.grid(row=5, column=3)        
                  
    
    def main():
      
        root = Tk()
        root.geometry("350x300+300+300")
        app = Example()
        root.mainloop()  
        
    
    if __name__ == '__main__':
        main()  
    

    In this example, we use a Label widget, a Text widget, and four buttons.

    self.columnconfigure(1, weight=1)
    self.columnconfigure(3, pad=7)
    self.rowconfigure(3, weight=1)
    self.rowconfigure(5, pad=7)
    

    We define some space among widgets in the grid. The weight parameter makes the second column and fourth row growable. This row and column is occupied by the text widget, so all the extra space is taken by it.

    lbl = Label(self, text="Windows")
    lbl.grid(sticky=W, pady=4, padx=5)
    

    The label widget is created and put into the grid. If no column and row is specified, then the first column or row is assumed. The label sticks to the west and it has some padding around its borders.

    area = Text(self)
    area.grid(row=1, column=0, columnspan=2, rowspan=4, 
        padx=5, sticky=E+W+S+N)
    

    The text widget is created and starts from the second row and first column. It spans two columns and four rows. There is a 4 px space between the widget and the left border of the root window. Finally, the widget sticks to all the four sides. So when the window is resized, the text widget grows in all directions.

    abtn = Button(self, text="Activate")
    abtn.grid(row=1, column=3)
    
    cbtn = Button(self, text="Close")
    cbtn.grid(row=2, column=3, pady=4)
    

    These two buttons go next to the text widget.

    hbtn = Button(self, text="Help")
    hbtn.grid(row=5, column=0, padx=5)
    
    obtn = Button(self, text="OK")
    obtn.grid(row=5, column=3)  
    

    These two buttons go below the text widget; the Help button takes the first column, the Ok Button takes the last column.

    Windows exampleFigure: Windows example

    In this part of the Tkinter tutorial, we mentioned layout management of widgets.

    展开全文
  • 这时候,就需要使用 tkinter提供的布局管理器帮助我们组织、 管理在父组件中子组件的布局方式。 tkinter 提供了三种管理器: pack、 grid、 place。 二、grid 布局管理器 grid 表格布局, 采用表格结构组织组件。 ...

    一、概述
    …一个 GUI 应用程序必然有大量的组件,这些组件如何排布? 这时候,就需要使用 tkinter提供的布局管理器帮助我们组织、 管理在父组件中子组件的布局方式。 tkinter 提供了三种管理器: pack、 grid、 place。
    二、grid 布局管理器
    grid 表格布局, 采用表格结构组织组件。 子组件的位置由行和列的单元格来确定, 并且可以跨行和跨列, 从而实现复杂的布局。
    在这里插入图片描述
    示例

    from tkinter import *
    from tkinter import messagebox
    import random
    class Application(Frame):
    def __init__(self, master=None):
    super().__init__(master) # super()代表的是父类的定义, 而不是父类
    对象
    self.master = master
    self.pack()
    self.createWidget()
    def createWidget(self):
    """通过 grid 布局实现登录界面"""
    self.label01 = Label(self,text="用户名")
    self.label01.grid(row=0,column=0)
    self.entry01 = Entry(self)
    self.entry01.grid(row=0,column=1)
    Label(self,text="用户名为手机号").grid(row=0,column=2)
    Label(self, text="密码").grid(row=1, column=0)
    Entry(self, show="*").grid(row=1, column=1)
    Button(self, text="登录").grid(row=2, column=1, sticky=EW)
    Button(self, text="取消").grid(row=2, column=2, sticky=E)
    if __name__ == '__main__':
    root = Tk()
    root.geometry("400x90+200+300")
    app = Application(master=root)
    root.mainloop()
    

    运行结果
    在这里插入图片描述
    三、pack 布局管理器
    pack 按照组件的创建顺序将子组件添加到父组件中, 按照垂直或者水平的方向自然排布。 如果不指定任何选项, 默认在父组件中自顶向下垂直添加组件。
    pack 是代码量最少, 最简单的一种, 可以用于快速生成界面。
    在这里插入图片描述
    在这里插入图片描述
    【小灰灰建议】 如上列出了 pack 布局所有的属性, 但是不需要挨个熟悉, 了解基本的即可。pack 适用于简单的垂直或水平排布, 如果需要复杂的布局可以使用 grid 或 place。
    【示例】 pack 布局用法, 制作钢琴按键布局
    在这里插入图片描述

    #coding=utf-8
    from tkinter import *
    root = Tk();root.geometry("700x220")
    #Frame 是一个矩形区域, 就是用来防止其他子组件
    f1 = Frame(root)
    f1.pack()
    f2 = Frame(root);f2.pack()
    btnText = ("流行风","中国风","日本风","重金属","轻音乐")
    for txt in btnText:
    Button(f1,text=txt).pack(side="left",padx="10")
    for i in range(1,20):
    Button(f2,width=5,height=10,bg="black" if i%2==0 else
    "white").pack(side="left")
    root.mainloop()
    
    

    四、place 布局管理器
    place 布局管理器可以通过坐标精确控制组件的位置, 适用于一些布局更加灵活的场景。
    在这里插入图片描述
    在这里插入图片描述
    示例

    #coding=utf-8
    from tkinter import *
    root = Tk();root.geometry("500x300")
    root.title("布局管理 place");root["bg"]="white"
    f1 = Frame(root,width=200,height=200,bg="green")
    f1.place(x=30,y=30)
    Button(root,text="小灰灰").place(relx=0.5,rely=0,
    x=100,y=200,relwidth=0.2,relheight=0.2)
    Button(f1,text="小灰灰牛逼").place(relx=0.6,rely=0.7)
    Button(f1,text="小灰灰真牛逼").place(relx=0.2,rely=0.2)
    root.mainloop()
    
    展开全文
  • Python GUI之tkinter布局管理

    万次阅读 多人点赞 2017-01-02 23:08:06
    tkinter 共有三种几何布局管理器,分别是:pack布局,grid布局,place布局。 pack布局 使用 pack布局,将向容器中添加组件,第一个添加的组件在最上方,然后是依次向下添加。 from tkinter import *root = Tk()#...

    Python3 tkinter系列

    一、概述
    二、布局管理
    三、常用组件
    四、实战(一)
    五、实战(二)
    六、进阶 自定义控件
    推荐视频课程 tkinter从入门到实战

    所谓布局,就是指控制窗体容器中各个控件(组件)的位置关系。tkinter 共有三种几何布局管理器,分别是:pack布局,grid布局,place布局。


    pack布局
    使用 pack布局,将向容器中添加组件,第一个添加的组件在最上方,然后是依次向下添加。

    from tkinter import *
     
    root = Tk()
     
    #创建三个 Label 分别添加到root窗体中 
    #Label是一种用来显示文字或者图片的组件
    Label(root,text = 'pack1',bg = 'red').pack() 
    Label(root, text = 'pack2', bg = 'blue').pack() 
    Label(root, text = 'pack3', bg = 'green').pack() 
     
    root.mainloop()
    

    如图:
    这里写图片描述

    pack常用属性

    属性名 属性简析 取值 取值说明
    fill 设置组件是否向水平或垂直方向填充 X、Y、BOTH 和NONE fill = X(水平方向填充)fill = Y(垂直方向填充)fill = BOTH(水平和垂直)NONE 不填充
    expand 设置组件是否展开,当值为YES时,side选项无效。组件显示在父容器中心位置;若fill选项为BOTH,则填充父组件的剩余空间。默认为不展开 YES 、NO(1、0) expand=YES expand=NO
    side 设置组件的对齐方式 LEFT、TOP、RIGHT、BOTTOM 值为左、上、右、下
    ipadx、ipady 设置x方向(或者y方向)内部间隙(子组件之间的间隔) 可设置数值,默认是0 非负整数,单位为像素
    padx、pady 设置x方向(或者y方向)外部间隙(与之并列的组件之间的间隔) 可设置数值,默认是0 非负整数,单位为像素
    anchor 锚选项,当可用空间大于所需求的尺寸时,决定组件被放置于容器的何处 N、E、S、W、NW、NE、SW、SE、CENTER(默认值为CENTER) 表示八个方向以及中心
    注意:上表中取值都是常量,YES等价于"yes",亦可以直接传入字符串值。另外当界面复杂度增加时,要实现某种布局效果,需要分层来实现。
    from tkinter import *    #注意模块导入方式,否则代码会有差别
     
    class App:
        def __init__(self, master):
            #使用Frame增加一层容器
            fm1 = Frame(master)
            #Button是一种按钮组件,与Label类似,只是多出了响应点击的功能
            Button(fm1, text='Top').pack(side=TOP, anchor=W, fill=X, expand=YES)
            Button(fm1, text='Center').pack(side=TOP, anchor=W, fill=X, expand=YES)
            Button(fm1, text='Bottom').pack(side=TOP, anchor=W, fill=X, expand=YES)
            fm1.pack(side=LEFT, fill=BOTH, expand=YES)
     
            fm2 = Frame(master)
            Button(fm2, text='Left').pack(side=LEFT)
            Button(fm2, text='This is the Center button').pack(side=LEFT)
            Button(fm2, text='Right').pack(side=LEFT)        
            fm2.pack(side=LEFT, padx=10)
     
            
    root = Tk()
    root.title("Pack - Example")
    display = App(root)
    root.mainloop()
    

    如上,创建一个Frame容器fm1,将三个垂直排列的Button组件使用pack布局放入fm1容器中,然后创建fm2容器,同样将三个水平排列的Button组件放入,最后将两个Frame容器当做组件,使用pack布局放入根窗体容器中。如此分层布局,实现了相对复杂一些的界面需求。
    这里写图片描述

    pack类提供了下列函数(使用组件实例对象调用):

    函数名 描述
    pack_slaves() 以列表方式返回本组件的所有子组件对象。
    pack_configure(option=value) 给pack布局管理器设置属性,使用属性(option)= 取值(value)方式设置
    propagate(boolean) 设置为True表示父组件的几何大小由子组件决定(默认值),反之则无关。
    pack_info() 返回pack提供的选项所对应得值。
    pack_forget() Unpack组件,将组件隐藏并且忽略原有设置,对象依旧存在,可以用pack(option, …),将其显示。
    location(x, y) x, y为以像素为单位的点,函数返回此点是否在单元格中,在哪个单元格中。返回单元格行列坐标,(-1, -1)表示不在其中
    size() 返回组件所包含的单元格,揭示组件大小。

    grid布局
    grid布局又被称作网格布局,是最被推荐使用的布局。程序大多数都是矩形的界面,我们可以很容易把它划分为一个几行几列的网格,然后根据行号和列号,将组件放置于网格之中。使用grid 布局时,需要在里面指定两个参数,分别用row 表示行,column 表示列。需要注意的是 row 和 column 的序号都从0 开始。

    如下图,假设将界面分成网格。
    描述

    grid属性设置

    属性名 属性简析 取值 取值说明
    row、column row为行号,column为列号,设置将组件放置于第几行第几列 取值为行、列的序号,不是行数与列数 row 和 column 的序号从0开始,但是,column的默认值是0,row的默认值是下一个编号较大的未占用行号
    sticky 设置组件在网格中的对齐方式(前提是有额外的空间) N、E、S、W、NW、NE、SW、SE 类似于pack布局中的锚选项
    rowspan 组件所跨越的行数 默认值为1 取值为跨越占用的行数,而不是序号
    columnspan 组件所跨越的列数 默认值为1 取值为跨越占用的列数,而不是序号
    ipadx、ipady、padx、pady 组件的内部、外部间隔距离,与pack的该属性用法相同 同pack 同pack

    grid类提供了下列函数(使用组件实例对象调用):

    函数名 描述
    grid_slaves() 以列表方式返回本组件的所有子组件对象。
    grid_configure(option=value) 给pack布局管理器设置属性,使用属性(option)= 取值(value)方式设置
    grid_propagate(boolean) 设置为True表示父组件的几何大小由子组件决定(默认值),反之则无关。
    grid_info() 返回pack提供的选项所对应得值。
    grid_forget() Unpack组件,将组件隐藏并且忽略原有设置,对象依旧存在,可以用pack(option, …),将其显示。
    grid_location(x, y) x, y为以像素为单位的点,函数返回此点是否在单元格中,在哪个单元格中。返回单元格行列坐标,(-1, -1)表示不在其中
    size() 返回组件所包含的单元格,揭示组件大小。

    place布局。
    最简单最灵活的一种布局,使用组件坐标来放置组件的位置。但是不太推荐使用,在不同分辨率下,界面往往有较大差异。

    place属性设置

    属性名 属性简析 取值 取值说明
    anchor 锚选项,同pack布局 默认值为 NW 同pack布局
    x、y 组件左上角的x、y坐标 整数,默认值0 绝对位置坐标,单位像素
    relx、rely 组件相对于父容器的x、y坐标 0~1之间浮点数 相对位置,0.0表示左边缘(或上边缘),1.0表示右边缘(或下边缘)
    width、height 组件的宽度、高度 非负整数 单位像素
    relwidth、relheight 组件相对于父容器的宽度、高度 0~1之间浮点数 与relx(rely)取值相似
    bordermode 如果设置为INSIDE,组件内部的大小和位置是相对的,不包括边框;如果是OUTSIDE,组件的外部大小是相对的,包括边框 INSIDE、OUTSIDE(默认值INSIDE) 可以使用常量INSIDE、OUTSIDE,也可以使用字符串形式"inside"、"outside"

    place类提供了下列函数(使用组件实例对象调用):

    函数名 描述
    place_slaves() 以列表方式返回本组件的所有子组件对象。
    place_configure(option=value) 给pack布局管理器设置属性,使用属性(option)= 取值(value)方式设置
    propagate(boolean) 设置为True表示父组件的几何大小由子组件决定(默认值),反之则无关。
    place_info() 返回pack提供的选项所对应得值。
    grid_forget() Unpack组件,将组件隐藏并且忽略原有设置,对象依旧存在,可以用pack(option, …),将其显示。
    location(x, y) x, y为以像素为单位的点,函数返回此点是否在单元格中,在哪个单元格中。返回单元格行列坐标,(-1, -1)表示不在其中
    size() 返回组件所包含的单元格,揭示组件大小。

    关注个人公众号:编程之路从0到1

    编程之路从0到1

    展开全文
  • Python Tkinter 布局管理

    千次阅读 2015-02-27 17:18:07
    所有的Tkinter组件都包含专用的几何管理方法,这些方法是用来组织和管理整个父配件区中子配件的布局的。Tkinter提供了截然不同的三种几何管理类:pack、grid和place。   pack()  pack几何管理采用块的方式组织...
  • Python TKinter 布局管理 (Pack Place Grid)

    万次阅读 多人点赞 2018-08-13 19:05:18
    Tkinter是Python常用的一个GUI库,本文主要介绍了Tkinter的布局管理部分。 Tkinter有三种布局管理方式: pack grid place 这三种布局管理在同一个 master window 里是不可以混用的。 pack布局管理 pack布局...
  • 布局管理器 tkinter 提供了三种 管理器:pack、grid、place。 grid 布局管理器 grid 表格布局,采用表格结构组织组件。 column 单元格的列号 从 0 开始的正整数 columnspan 跨列,跨越的列数 正整数 row 单元格的...
  • Python Tkinter Grid布局管理器详解

    千次阅读 2016-01-18 13:07:26
    Grid(网格)布局管理器会将控件放置到一个二维的表格里。主控件被分割成一系列的行和列,表格中的每个单元(cell)都可以放置一个控件。 什么时候使用Grid管理器 grid管理器是Tkinter里面最灵活的几何...
  • place 布局管理器可以通过坐标精确控制组件的位置 适用于一些布局更加灵活的场景。 place()方法的选项 x,y 组件左上角的绝对 坐标(相对于窗口) 非负整数 x 和 y 选项用于设置偏移(像素),如果同时设置 relx...
  • Python之Tkinter布局管理

    千次阅读 2012-12-04 03:34:39
    所有的Tkinter组件都包含专用的几何管理方法,这些方法是用来组织和管理整个父配件区中子配件的布局的。Tkinter提供了截然不同的三种几何管理类:pack、grid和place。   1. pack方式  pack几何管理采用块的...
  • pack,grid,place均用于管理在一个父组件下的所有组件的布局,其中:1)pack是按添加顺序排列组件2)grid是按行/列形式排列组件3)place则容忍我们指定组件的大小和位置pack对比grid管理器,pack更适用于少量组件的...
  • Grid(网格)布局管理器会将控件放置到一个二维的表格里。主控件被分割成一系列的行和列,表格中的每个单元(cell)都可以放置一个控件。 什么时候使用Grid管理器 grid管理器是Tkinter里面最灵活的几何管理...
  • 布局管理:1、绝对定位--每个窗口部件被创建时可以显式地指定它的位置和大小。2、灵活布局的解决方案--sizer· sizer是屏幕布局的一个算法· sizer允许嵌套import wx class Frame1(wx.Frame): def __init__(self,...
  • 所有的Tkinter组件都包含专用的几何管理方法,这些方法是用来组织和管理整个父配件区中子配件的布局的。Tkinter提供了截然不同的三种几何管理类:pack、grid和place。pack() pack几何管理采用块的方式组织配件,在...
  • python之pack布局管理

    2019-11-18 21:28:18
    pack 按照组件的创建顺序将子组件添加到父组件中 按照垂直或者水平的方向自然排布。 如果不指定任何选项,默认在父组件中自顶向下垂直添加组件。 pack 是代码量最少,最简单的一种,可以用于快速生成界面。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 599
精华内容 239
关键字:

python布局管理

python 订阅