对程序员来说，界面设计的实现，要解决的一个主要问题就是如何根据界面设计的需求，将组件以规定的大小放置在规定的位置。tkinter是python语言中常用的界面实现模块，其中pack()方法，可创建浮动，自动伸缩扩展的软件界面，如以下界面。
 
 
如果你对以上用tkinter.pack实现的界面布局有兴趣，觉得有些实现效果可以参考借鉴，请继续阅读下面的内容。
 
一. pack的组件空间布局原理分析
 
用pack进行的布局界面组件，可用以下一些界面布局空间来进行分析
 
side = top 的布局空间
 
 
side = left 的布局空间
 
 
1. 容器可用空间 
 
系统严格按代码的前后组织顺序依次排列组件，前辈组件还没有占据的空间，是当前组件的可用空间，pack布局是在当前组件的可用空间内进行的。如上图的黑边白底的区域。（为了说明，我留出padding空间，若没有padding，组件将占据整个目前可用空间）
 
2.组件原始大小可见空间
 
设置了width, height, 或由具体内容确定的组件原始大小，也就是可以看得见的组件宽高。如上图的黄色区域。
 
3.组件的独占空间
 
组件不单只占据它原始可见的位置，而是会同时占据可用空间的整行空间或整列空间。如上图红色区域。
 
side = top / bottom 时，组件占据整行，后辈组件只能依次排在它的下面 / 上面；组件为上下排列方式
 
side = left / right 时， 组件占据整列，后辈组件只能依次排在它的右边 / 左边；组件为左右排列方式
 
pack() , 我分析下来，其实就是 pack(side=top)
 
组件独占空间，没有进行填充(fill)时，不可见，但我们必须了解到它的存在，因为它直接影响组件本身及后辈组件的布局。
 
组件独占空间，是固有的，其它后辈组件绝对不可能进入该空间，后辈组件最多只能紧靠它。
 
4. 组件可扩展空间
 
组件独占空间的另一个方向，是组件的可扩展空间方向。如上图的浅蓝色区域。
 
side = top / bottom 时，组件独占整行，并可向整列方向进行扩展。
 
side = left / right 时，组件独占整列，并可向整行方向进行扩展。
 
组件可扩展空间，没有进行填充(fill)时，也是不可见的，但它同样会直接影响自身和后辈组件的布局，必须掌握它的空间存在。
 
若设置了 expand = yes, 则启用可扩展空间；若 expand = no, 则不启用可扩展空间。
 
组件可扩展空间，是动态的，是可以被后辈组件的独占空间占据压缩的，后辈组件可以从前辈可扩展空间的边缘开始入侵，直至压缩到前辈组件自身的独占空间为止。 
 
5. 组件占用总空间
 
组件独占空间 + 组件可扩展空间，就是当前组件的总占用空间，若没有启用组件扩展空间（expand = no），则只包含组件独占空间。
 
接下来的 锚定位(anchor)和填充(fill)，都是基于组件的占用总空间来进行处理的。
 
6. 空间定位和填充
 
锚定位（anchor ），加 padx, pady , 可将组件安排在指定位置
 
锚定位有9个方向，缺省为 center, 居中
 
若 side = top / bottom ,  expand=no, 则合并到一行，即NW, W, SW的效果一样，其他同理。
 
若 side = left / right,  expand = no, 则合并到一列，即NW, N, NE的效果一样，其他同理
 
 
填充（fill）组件，可以将组件的可见，可操作范围充满指定区域
 
填充的方式有4种，缺省的方式是（none）,不填充。
 
 
 
 
二. 单组件布局的分析步骤
 
以上描述的pack布局原理，需要仔细理解和掌握，这是pack布局的基础，当我们理解这些原理后，就可以用来控制单个组件的位置了。
 
基本分析步骤为：
 
1. 明确当前容器的可用空间范围
 
2.分析是用上下排列方式（side=top / bottom）,还是左右排列方式（side=left/right）
 
3.分析是否需要启用扩展空间，若需要则设置 expand = yes, 否则保持缺省值 expand = no
 
4.利用锚定位（anchor），确定组件的具体位置
 
5.利用填充（fill）, 对组件的可见区域进行填充
 
 
 
举例分析：
 
 
设置代码
 
 
布局效果
 
 
说明
 
 
.pack(side=‘top‘)
 
 
 
 
独占整行，缺省居中
 
 
.pack(side='top', anchor='sw')
 
 
 
 
没有启用可扩展空间，只独占行，锚定位 nw, w, sw 都一样，定位在西边
 
 
.pack(side='top', expand='yes', anchor='sw')
 
 
 
 
启用可扩展空间，除了独占的行空间，还扩展到了容器可用空间的所有列空间，锚定位'sw' ，定位到了容器的西南边
 
 
.pack(side='top', expand='yes')
 
 
 
 
启动扩展空间，没有设置anchor，则缺省居中（整个组件占用空间的中间，不同于第1个例子）
 
 
.pack(side='top', expand='yes', fill='y')
 
 
 
 
启用扩展空间，定位完后，进行“y”轴方向的填充，填满整个占用空间的列
 
 
.pack(side='top', fill='y')
 
 
 
 
没有启用扩展空间，当选择进行“y”方向填充时，也只是在独占的行空间内进行“y”方向填充
 
 
 
三.  多组件布局的分析
 
我们现在基本掌握了单个组件的布局定位分析方法，而实际的软件界面，一定是多组件的综合布局，涉及多组件之间的相互关系和影响。以上所有讲到的单组件布局分析，都有一个前提，就是在已知容器可用空间的前提下， 进行当前组件的布局定位。
 
 
 
整理分析多组件布局的要点：
 
1. 所有组件按代码的前后组织次序，依次进行布局定位
 
2. 设置side = top / bottom 的组件，为上下排列的组件，独占当时可用空间的整行 
 
3. 设置side = left / right 的组件，为左右排列的组件，独占当时可用空间的整列
 
4. 后辈组件不可进入任何前辈组件的独占空间，不论 side的设置如何，是否相同，一律都是前辈
 
5. 组件可扩展空间，是动态的，是可以被后辈组件的独占空间占据压缩的，后辈组件可以从前辈可扩展空间的边缘开始入侵，直至压缩到前辈组件自身的独占空间为止
 
6.后辈组件的扩展空间，不能侵占前辈组件的扩展空间；既若扩展空间重叠，前辈享用扩展空间
 
7. 若整个界面空间缩小，出现后辈组件独占空间跟前排组件独占空间重叠时，后辈组件将被压缩，直至消失。
 
8. 若界面空间继续缩小，小到比组件独占空间小时，组件将被压缩，直至消失。
 
9. 空间优先级别为：界面空间 > 前辈组件独占空间 > 后辈组件独占空间 > 前辈组件可扩展空间 > 后辈组件可扩展空间
 
10.可利用frame的多层嵌套，进行灵活布局
 
 
 
举例分析：
 
 
设置代码
 
 
布局效果
 
 
说明
 
1.pack(side='left', expand='no', anchor='w', fill='y', padx=5, pady=5)
 2.pack(side='top')
 3.pack(side='right')
 4.pack(side='bottom')
 
 
 
块1：
 
第一个组件，可用空间为整个界面空间，靠左，独占列，不启动扩展空间，按“y”方向填充，周围有5个像素的padding
 
 
 
块2：
 
可用空间从块1的右边缘开始，靠上，独占行，位置居中，但注意是从块1右边缘到界面边缘的中间位置，而不是整个界面的中间位置
 
 
 
块3:
 
靠右，居中；其上下可用空间大小是块2的下边缘，到界面边缘
 
 
 
块4：
 
靠下，居中；其左右可用空间大小是从块1的右边缘 到 块3的左边缘
 
1.pack(side='left', expand='yes', fill='x')
 2.pack(side='top')
 3.pack(side='right', expand='yes', fill='x')
 4.pack(side='bottom')
  
 
这个例子比较复杂点
 
块1:
 
启用了扩展空间，往“x”行方向填充，但被块2，块3，块4的独占空间压回到了现在的大小。
 
 
 
块2：
 
同上，始终位于块1右边缘和界面边界的中间靠上位置
 
 
 
块3：
 
启用了扩展空间，但也越不过块4的独占列空间
 
 
 
块4：
 
始终位于块1，块3的中间位置靠下
 
 
1.pack(side='left', expand='no', fill='y')
 2.pack(side='top', fill='x')
 3.pack(side='right', expand='yes', fill='both')
 
 
 
 
一个很常规的导航界面设置
 
块1：导航栏
 
靠左，上下填充，不可扩展
 
 
 
块2：标题栏
 
靠上，左右扩展
 
 
 
块3：内容栏
 
位置无所谓，全面扩展填充
 
 
 
 
 
四. 代码演示
 
我写了一个布局演示程序，包含文章开头展示的界面，可以对照界面实际效果和具体代码，来了解实现的细节。另外提供了单组件和多组件的演示工具，可以调整设置，观察效果，来理解和掌握pack布局的基本方法。演示程序中还包括一些其它窗体布局和实现的方法，希望对大家有帮助。
 
源代码位置：
 
https://github.com/EdwinZhang1970/Python/tree/master/tkinter-pack%20Demo
 
 
 
 
 
 
 
 
 
 
 
 
 

前面三篇博文介绍了 tkinter-label，tkinter-menu详解，tkinter-button详解，可以说对tkinter的控件有了基础的认识，可能这时大家自然会想，这些控件放置的什么位置要怎样控制呢？为了搞清楚这个问题，接下来分三篇博文来分别介绍tkinter的三种布局方法。
 
tkinter中控件的布局可以有三个类来控制,分别是Pack,Place,Grid.本系列文章将这三个类统称为布局类.
 
布局类与控件类的类间关系如下:
 
 由上图可以看出,tkinter总共有17个控件类,三个布局类都是控件类(Widget)的父类.所以任何控件类对象都可以直接调用布局类的方法,来完成控件布局.
 


 
文章目录
 
Pack
默认分布
紧凑分布
填满分布
填充分布
外边距
内边距
 

 
Pack
 
widget.pack(cnf={}, **kw)
 
为了直观起见,接下来主要通过实例来辅助理解pack的布局结构并学会使用。
 
默认分布
 
首先，我们从最简单的默认配置入手。
 
from tkinter import (Tk, Button)
from tkinter.constants import RIGHT, LEFT, X, Y, BOTH
main_win = Tk()
main_win.title('渔道的pack布局')
width = 300 
height = 300 
main_win.geometry(f'{width}x{height}')

apple_color = 'Crimson'
banana_color = 'Yellow'
orange_color = 'Orange'
grape_color = 'Purple'

fruit = {'apple':'Crimson', 'banana':'Yellow', 'orange':'Orange', 'grage':'Purple'}
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack()
    print(bt.info())
 
print函数的打印信息如下：
 
{'in': <tkinter.Tk object .>, 'anchor': 'center', 'expand': 0, 'fill': 'none', 'ipadx': 0, 'ipady': 0, 'padx': 0, 'pady': 0, 'side': 'top'}
 
我们来看两个主要的属性anchor和side.
 
anchor为center,表示相对于父控件(这里为主窗口)button居中显示,显然button将占用这一整行的空间,下一个控件将从下一行开始布局.
 
side为top,表示向顶部对齐.
 
 
side 属性 决定将控件放在父对象的哪一边.TOP (default) 表示顶部, BOTTOM 表示底部, LEFT 表示靠左, RIGHT 表示靠右.
 
anchor 属性 决定控件的锚点，也就是控件的起始位置。可设置的值为’n’, ‘ne’, ‘e’, ‘se’, ‘s’, ‘sw’, ‘w’, ‘nw’; ‘e’、‘w’、‘s’、'n’分别表示东西南北。
 
紧凑分布
 
# 四个按钮紧邻分布
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(side=LEFT, anchor='nw')
 
 
pack布局中,控件是紧凑分布的，可以通过side和anchor属性的组合，来决定控件的实际布局。
 
填满分布
 
该分布主要用到expand属性。我们先来看一个实际的显示效果。
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(expand=True)
 
 
从上图可以看出，4个按钮控件，基本上将主窗口的空间填满了。
 
expand 属性 设置为True,将填满控件的父对象的空间。
 
如果改变side属性，4个按钮控件的布局如下：
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(side=LEFT, expand=True)
 
 
如果再改变anchor属性，4个按钮控件的布局如下：
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(anchor='s', side=LEFT, expand=True)
 
 
填充分布
 
fill 属性 决定填充方向.None (default)表示保持控件原尺寸.X 表示填充水平方向.Y 表示填充垂直方向.BOTH 表示水平和垂直方向都填充.
 
我们先看一下4个按钮控件在水平方向的填充分布效果
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(fill=X)
 
 
在垂直方向的填充分布效果：
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(fill=Y)
 
 
在水平、垂直方向的填充分布效果：
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(fill=BOTH)
 
 
外边距
 
外边距通过两个属性来控制，padx和pady。
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(anchor='nw',side=LEFT)

for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(anchor='nw', side=LEFT, padx=10)
 
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack()

for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(pady=10)
 
 
内边距
 
内边距通过两个属性来控制，ipadx和ipady。
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack()

for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(ipadx=10)
 
从下图的显示效果可以看出，第2组按钮，x方向上，文字和按钮边框的间隔要大一些，就是因为设置了ipadx=10.
 
 
for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack()

for k,v in fruit.items():
    bt = Button(main_win, text=k, fg='black', bg=v)
    bt.pack(ipady=10)
 
从下图的显示结果可以看出，第2组按钮，y方向上，文字和按钮边框的间隔要大一些，就是因为设置了ipady=10.
 
 
pack不同属性的组合可以形成非常多的布局效果，本文就不再一一列举。pack布局还支持不同父子控件的组合分布，但是不管怎样组合，pack的属性就是这几种，使用者灵活组合即可。
 
原创不易，若认可本文，老铁请点赞、评论、分享、收藏、打赏。你的鼓励与支持是我前进的动力！！！

Tkinter的pack()方法记录
 我理解的pack方法就是需要将容器如何放置在你的窗口上面，主要是相对位置的一个概念,而且最重要的是pack方法是按照代码执行顺序一行一行放置的，先后顺序对结果有很大影响。
 首先pack()方法的属性有如下几个：
 -after, -anchor, -before, -expand, -fill, -in, -ipadx, -ipady, -padx, -pady, -side
 其中pack方法可以应用于Tkinter内的所有容器；
  
  
  
 
expand
 
expand参数表示的是容器在整个窗口上，将容器放置在剩余空闲位置上的中央(包括水平和垂直方向)
 expand=1或者expand=“yes”，表示放置在中央
 expand=0或者expand=“no”，表示默认不扩展
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
window.geometry("150x150")
tk.Button(window, text="Button-1", bg="green").pack(expand="yes")
tk.Button(window,text="Button-2",bg="yellow").pack(expand="no")
#tk.Button(window,text="Button-3",bg="yellow").pack()
window.mainloop()
 
效果图如下：
 可以明显的对比出expand不是整个窗口的中心，而是剩余位置的中心；
  
  
  
 
fill 和 side
 
fill表示的是容器相对于整个窗口是否进行填充，这个参数的优先级高于width和heigh；有三个选项可以配置，
 fill=“x”，表示横向填充
 fill=“y”，表示纵向填充
 fill=“both”，表示横向和纵向都填充
 
上面几个填充选项当和side同时使用时需要注意：
 当side="left"或side="right"时，fill="x"不起作用，只能填充y
 side=“top”,side="bottom"时，fill="y"不起作用，只能填充x
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
window.geometry("150x150")

tk.Label(window, text="上边", bg="green").pack(fill="x", side="top")
tk.Label(window, text="下边", bg="red").pack(fill="y", side="bottom")
tk.Label(window, text="左边", bg="green").pack(fill="y", side="left")
tk.Label(window, text="右边", bg="red").pack(fill="x", side="right")
tk.Button(window, text="中间", bg="yellow").pack(expand="yes")

window.mainloop()
 
效果如下：
 
 
  
  
 如果多个容器使用同一个side，那么将会按照如下箭头方向进行排列：
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
window.geometry("250x250")

tk.Label(window,text="1",bg="green").pack(side="left")
tk.Label(window,text="2",bg="green").pack(side="left")

tk.Label(window,text="3",bg="red").pack(side="right")
tk.Label(window,text="4",bg="red").pack(side="right")

tk.Label(window,text="5",bg="yellow").pack(side="top")
tk.Label(window,text="6",bg="yellow").pack(side="top")

tk.Label(window,text="7",bg="pink").pack(side="bottom")
tk.Label(window,text="8",bg="pink").pack(side="bottom")

window.mainloop()
 
 
  
  
 
padx,pady和ipadx,ipady
 
1.简单来说就是padx和pady表示的是2个容器，或者是容器和边框之间需要的间距(x是上和下对称，y是左和右对称)
 2.ipadx和ipady表示容器的内容和容器边框之间的距离，同样是对称的；
 下面2个列子说明；
 ipadx和ipady：
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
window.geometry("200x200")
tk.Button(window,text="Button-1").pack()
tk.Button(window,text="Button-2").pack(ipadx=10,ipady=10)
window.mainloop()

 

  
  
 padx和pady：
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
tk.Button(window,text="Button-1").pack()
tk.Button(window,text="Button-2").pack(padx=50,pady=10)
window.mainloop()
 
 
  
  
 
anchor
 
首先anchor共有9个参数可以设置n, s, w, e ,nw, ne, sw, se, center. 分别是各个方向英语的缩写。
 有一个注意点是，anchor 放置容器时是相对于每一行放置的，重点在控制每一个容器在每一行的位置比较有用。如果要想实现相对于整个窗口的相对位置放置，可以参考上面的side用法。
 
#"作者：晒晒小木桩"
import tkinter as tk

window = tk.Tk()
window.geometry("300x300")

tk.Button(window,text="1-North West").pack(anchor="nw")
tk.Button(window,text="2-North").pack(anchor="n")
tk.Button(window,text="3-North East").pack(anchor="ne")
tk.Button(window,text="4-West").pack(anchor="w")
tk.Button(window,text="5-East").pack(anchor="e")
tk.Button(window,text="6-South West").pack(anchor="sw")
tk.Button(window,text="7-South").pack(anchor="s")
tk.Button(window,text="8-South East").pack(anchor="se")
tk.Button(window,text="9-Center").pack(anchor="center")

window.mainloop()
 
运行结果
  
  
  
  
 
after，before，in这3个基本不用
 
最后推荐一个看到别人总结的很好的文章，连接如下：
 tkinter模块常用方法和其属性

0️⃣前言
 此文章代码都在Github：3-窗口控件配置管理员/pack方法别忘了⭐️呀
 
 
做一个应用程序，肯定需要更多的widget控件，所以这时候就牵扯到了如何将这些widget控件配置到 容器 或 窗口 内。在设计GUI程序时，可以使用三种方法包装和定为各组件在 容器 或 窗口 内的位置，这三个方法又称窗口控件配置管理员（Widget Layout Manager），通常叫做布局方法。
 
一共有三种布局方法：pack、grid和place，最常用的是pack方法，本章介绍pack方法
 
窗口控件配置管理员
 
前言
side参数
padx/pady参数
ipadx/ipady参数
anchor参数
fill参数
expand参数
pack参数
 
 
pack方法的语法格式如下
 
***.pack(options, ...)
 
options参数可以是如下属性：
 
side
fill
padx/pady
ipadx/ipady
anchor
 
下面将详细说明
 1️⃣side参数
 可以垂直或水平配置控件，可以设置控件的排列顺序
 
#coding:UTF-8
#ch1.py

from tkinter import *

root = Tk()
root.title("普通设置控件")

Label(root, text="Tkinter", bg="lightyellow").pack()
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen").pack()

Label(root, text="PyQt", bg="lightblue").pack()

root.mainloop()
 

 如果窗口中有多个控件，pack会自动让控件从上往下排列显示，这是默认设置。也可以使用side参数改变排列方式，此参数取值如下
 
TOP：默认值，由上往下排列
BOTTOM：由下往上排列
LEFT：从左往右排列
RIGHT：从右往左排列
 
重新改造，使用side，并让标签的宽度都为15
 
#coding:UTF-8
#ch2.py --ch1.py 2.0

from tkinter import *

root = Tk()
root.title("普通设置控件")

Label(root, text="Tkinter", bg="lightyellow", width=15).pack(side=BOTTOM)
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen", width=15).pack(side=BOTTOM)

Label(root, text="PyQt", bg="lightblue", width=15).pack(side=BOTTOM)

root.mainloop()

 

 再改成LEFT
 
#coding:UTF-8
#ch3.py -- ch2.py->side->LEFT

from tkinter import *

root = Tk()
root.title("普通设置控件")

Label(root, text="Tkinter", bg="lightyellow", width=15).pack(side=LEFT)
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen", width=15).pack(side=LEFT)

Label(root, text="PyQt", bg="lightblue", width=15).pack(side=LEFT)

root.mainloop()
 

 混合使用side
 
#coding:UTF-8
#ch4.py -- ch3.py->side->混合使用

from tkinter import *

root = Tk()
root.title("普通设置控件")

Label(root, text="Tkinter", bg="lightyellow", width=15).pack()
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen", width=15).pack(side=RIGHT)

Label(root, text="PyQt", bg="lightblue", width=15).pack(side=LEFT)

root.mainloop()
 
 
2️⃣padx / pady参数
 可以使用padx/pady参数设定控件边界与容器（可以想成窗口边界）的距离或是控件边界间的距离。在默认环境下窗口控件间的距离是 1 像素，如果希望有适度间距，可以设置padx/pady，代表水平间距/垂直间距
 
 
实例：
 
#coding:UTF-8
from tkinter import *

root = Tk()
root.title("relief")

Label(root, text="flat", relief="flat").pack(side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)
Label(root, text="groove", relief="groove").pack(side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)
Label(root, text="raised", relief="raised").pack(side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)
Label(root, text="ridge", relief="ridge").pack(side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)
Label(root, text="solid", relief="solid").pack(side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)
Label(root, text="sunken", relief="sunken").pack(
    side=LEFT, pady=5, padx=4, ipadx=10, ipady=10)

root.mainloop()
 
用relief参数实现各种标签的边框，ipadx和ipady等会讲，运行结果
 
 3️⃣ipadx / ipady参数
 ipadx/ipady是调整内部距离的，padx/pady是调整外部距离的，还是刚才的程序运行结果，再次分析
 
 4️⃣anchor参数
 可以设定Widget控件在窗口中的位置，参数如下
 

 实例：
 
#coding: UTF-8
#ch7.py anchor
from tkinter import *
root = Tk()
root.title("ch7.py")
root.geometry("300x180")
okbtn = Button(root, text="OK",
                font="Times 20 bold",
                fg="white", bg="blue")
okbtn.pack(anchor=S, side=RIGHT,
            padx=10, pady=10)
root.mainloop()
 
原本书中写的是Label的，因为这个是鉴于刚学了Label其他的都不知道的同学看的，我觉得既然是OK，Button更好一些吧
 
 那么再加上一个NO键是不是更好？
 
#coding: UTF-8
#ch8.py anchor + NO BTN
from tkinter import *
root = Tk()
root.title("ch7.py")
root.geometry("300x180")
okbtn = Button(root, text="OK",
               font="Times 20 bold",
               fg="white", bg="blue")
okbtn.pack(anchor=S, side=RIGHT,
           padx=10, pady=10)
nobtn = Button(root, text = "NO",
                font="Times 20 bold",
                fg="white", bg="red")
nobtn.pack(anchor=S, side=RIGHT,
            pady=10)
root.mainloop()
 

 5️⃣fill参数
 此参数是告诉pack管理程序，设置控件填满所分配容器区间的方式，如果是fill=X表示控件可以填满所分配空间X轴不留白，反之亦然，如果是fill=BOTH表示控件可以填满所分配空间的X轴和Y轴。fill的默认值是None，表示保持原始大小。
 
实例：（改编第一个ch1.py）
 
#coding:UTF-8
#ch9.py fill
from tkinter import *

root = Tk()
root.title("普通设置控件")

Label(root, text="Tkinter", bg="lightyellow").pack(fill=X)
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen").pack()

Label(root, text="PyQt", bg="lightblue").pack(fill=X)

root.mainloop()
 

 如果所分配容器空间已经满了，则使用fill没有任何作用，将wxPython那个标签设置为.pack(fill=Y)不会有任何效果。
 6️⃣expand参数
 expand参数可设定Widget控件是否填满额外的父容器空间，默认是False（或0），表示不填满，如果是True（或是1）则填满。这很重要！
 
 不管怎么设置fill参数，其结果都没有填满整个窗口，于是expand隆重出场！
 
#coding:UTF-8
#ch9.py fill
from tkinter import *

root = Tk()
root.title("expand")

Label(root, text="Tkinter", bg="lightyellow").pack(side=LEFT, fill=Y)
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen").pack(fill=X)

Label(root, text="PyQt", bg="lightblue").pack(fill=BOTH, expand=True) #设置可以变化

root.mainloop()
 
 
#coding:UTF-8
#ch9.py fill
from tkinter import *

root = Tk()
root.title("expand")

Label(root, text="Tkinter", bg="lightyellow").pack(
    side=LEFT, fill=Y)
#第一个标签
#这些标签不需要保存在变量中，设置好直接布局
Label(root, text="wxPython", bg="lightgreen").pack(fill=BOTH, expand=True)

Label(root, text="PyQt", bg="lightblue").pack(fill=BOTH, expand=True) #设置可以变化

root.mainloop()
 

 7️⃣pack参数
 
forget()——隐藏Widget控件，可以用pack(option, ...)复原
info()——传回pack选项的对应值
size()——传回Widget控件的大小
…………更多问度娘😏
 
PS：一个程序只能有一种窗口布局，如果使用pack，就不能使用grid、place了
 再PS：别忘了点赞留言收藏呀😸哦还要关注啊🌠
 *还PS：此文章代码都在Github：Coding-Notes/Python-Notes/学习/图形界面开发学习笔记/PythonGUI设计tkinter菜鸟编程书/3-窗口控件配置管理员/pack方法别忘了star仓库！