Python GUI——tkinter菜鸟编程（中）

Python GUI——tkinter菜鸟编程（中）
8. Radiobutton
选项按钮：可以用鼠标单击方式选取，一次只能有一个选项被选取。
Radiobutton(父对象,options,…)
常用options参数：
- anchor，bg，bitmap，bd，command，cursor，fg，font，height，highlightbackground、highlightcolor，image，justify，padx，pady，state，text，textvariable，underline，width，wraplength；
- activebackground：鼠标光标放在选项按钮上时的背景色彩；
- activeforeground：鼠标光标放在选项按钮上时的前景色彩；
- indicatoron：当此值为0时，可以建立盒子选项按钮；
- selectcolor：当选项按钮被选取时的颜色；
- selectimage：如果设置图像选项按钮时，可由此设置当选项按钮被选取时的不同图像；
- value：选项按钮的值，可以区分所选取的选项按钮；
- variable：设置或取得目前选取的单选按钮，通常为IntVar或StringVar类型。
var IntVar
rb1 = Radiobutton(root,...,variable=var,value=x1,...)
rb2 = Radiobutton(root,...,variable=var,value=x2,...)
...
rbn = Radiobutton(root,...,variable=var,value=xn,...)
使用get()方法，可以传回所选选项的参数value的值，使用set()可以设置初始默认value选项。
8.1 示例
```
def printSelection():
    label.config(text = "You are a " + var.get() + ".")
    
root = Tk()
root.title("Ex")
var = StringVar()
var.set("boy")
label = Label(root, text = "Please choose.", bg = "lightyellow", width = 30)
label.pack()
rbman = Radiobutton(root, text = "boy", variable = var, value = "boy", 
                   command = printSelection)
rbman.pack()
rbwoman = Radiobutton(root, text = "gril", variable = var, value = "gril", 
                      command = printSelection)
rbwoman.pack()
root.mainloop()
```
8.2 字典
```
cities = {0:"北京", 1:"哈尔滨", 2:"天津", 3:"西安", 4:"杭州"}
def printSelection():
    print(cities[var.get()])
    
root = Tk()
root.title("Ex")
var = IntVar()
var.set(0)
label = Label(root, text = "选择最喜欢的城市", bg = "lightyellow", width = 30)
label.pack()
for val, city in cities.items():
    Radiobutton(root, text = city, variable = var, value = val, 
                command = printSelection).pack()
root.mainloop()
```
8.3 盒子选项按钮
Radiobutton(…, indicatoron = 0, width = 30)
9. Checkbutton
复选框，可以复选。
Checkbutton(父对象,options,…)
options：
- …（通用参数）
- offvalue：控制变量，复选框未勾选时value的值，默认为0；
- onvalue：控制变量，复选框勾选时value的值，默认为1。
```
cities = {0:"北京", 1:"哈尔滨", 2:"天津", 3:"西安", 4:"杭州"}
def printInfo():
    selection = ""
    for i in checkboxes:
        if checkboxes[i].get() == True:
            selection += cities[i] + "	"
    print(selection)
root = Tk()
root.title("Ex")
label = Label(root, text = "选择喜欢的城市", bg = "lightyellow", width = 30)
label.pack()
checkboxes = {}
for i in range(len(cities)):
    checkboxes[i] = BooleanVar()
    Checkbutton(root, text = cities[i], variable = checkboxes[i]).pack()
Button(root, text = "确定", width = 10, command = printInfo).pack()
root.mainloop()
```
10. 容器
Frame可译为框架，LabelFrame即标签框架。
10.1 Frame
Frame(父对象,options,…) #父对象可以省略
options参数：
- bg，bd，cursor，height，highlightbackground，highlightcolor，highlighthickness，relief，width。
```
root = Tk()
root.title("Ex")
frameUpper = Frame(root, bg = "lightyellow", height = 30, width = 150)
frameUpper.pack()
btnRed = Button(frameUpper, text = "Red", fg = "red").pack(side = LEFT)
btnGreen = Button(frameUpper, text = "Green", fg = "green").pack(side = LEFT)
frameLower = Frame(root, bg = "lightblue", height = 30, width = 150)
frameLower.pack()
#btnPurple = Button(frameLower, text = "Purple", fg = "purple").pack()
root.mainloop()
```
10.2 LabelFrame
LabelFrame(父对象,options,…)
- bg，bd，cursor，font，height，highlightbackground，highlightcolor，highlighthickness，labelAnchor，relief，text，width。
labf = LabelFrame(root, text = "选择喜欢的城市")
checkboxes = {}
for i in range(len(cities)):
checkboxes[i] = BooleanVar()
Checkbutton(labf, text = cities[i], variable = checkboxes[i]).pack()
labf.pack()
10.3 Toplevel
功能类似于Frame，但是这个控件所产生的容器有一个独立的窗口，有自己的标题栏和边框。可以制作对话框。
- bg，bd，cursor，fg，font，height，width。
```
import random
root = Tk()
root.title("Ex")
msg = {1:"Yes", 2:"No", 3:"Exit"}
def MessageBox():
    msgType = random.randint(1,3)
    labTxt = msg[msgType]
    tl = Toplevel()
    tl.geometry("300x180")
    tl.title("Message Box")
    Label(tl, text = labTxt, bg = "lightgreen").pack(fill = BOTH, expand = True)


btn = Button(root, text = "Click Me", command = MessageBox)
btn.pack()
root.mainloop()
```
11. 与数字有关
11.1 Scale
用过移动尺度条产生某一范围的数字。
Scale(父对象,opitons,…)
- activebackground，bg，bd，command，cursor，fg，font，highlightbackground，highlightcolor，relief，state，width；
- digits：数值尺度，读取时需使用IntVar、DoubleVar、StringVar变量类型读取；
- from_：尺度条范围值的初值；
- label：便签文字，默认没有；
- length：默认100像素；
- orient：可设置HORIZONTAL或VERTICAL，默认水平；
- repeatdelay：可设置需要按住尺度条多久后才能移动此尺度条，单位是ms，默认值300；
- resolution：分辨率，数值间隔；
- showvalue：正常会显示尺度条的当前值，设为0以不显示；
- takefocus：正常时此尺度条可以循环取得焦点，设为0则无法取得焦点；
- tickinterval：尺度条的标记刻度分隔；
- to：尺度条范围值的终值；
- troughcolor：槽的色彩；
- variable：设置或取得目前的尺度值。
使用3个尺度条更改窗口背景色彩：
```
def bgUpdate(source):
    """更改窗口背景色彩"""
    red = rSlider.get()
    green = gSlider.get()
    blue = bSlider.get()
    #转换为十六进制
    myColor = "#%02x%02x%02x" % (red, green, blue)
    root.config(bg = myColor)
root = Tk()
root.title("Ex")
root.geometry("360x240")
rSlider = Scale(root, from_ = 0, to = 255, label = "R", 
                resolution = 1, troughcolor = "red", command = bgUpdate)
gSlider = Scale(root, from_ = 0, to = 255, label = "G", 
                resolution = 1, troughcolor = "green", command = bgUpdate)
bSlider = Scale(root, from_ = 0, to = 255, label = "B", 
                resolution = 1, troughcolor = "blue", command = bgUpdate)
rSlider.pack(anchor = S, side = LEFT)
gSlider.pack(anchor = S, side = LEFT)
bSlider.pack(anchor = S, side = LEFT)
root.mainloop()
```
11.2 askcolor()
tkinter模块的colorchoose模块中有askcolor()方法，利用此方法可以开启“色彩”对话框。
```
from tkinter.colorchooser import *
def bgUpdate():
    """更改窗口背景色彩"""
    myColor = askcolor()
    root.config(bg = myColor[1])
root = Tk()
root.title("Ex")
root.geometry("360x240")
btn = Button(text = "Slect color", command = bgUpdate).pack()
root.mainloop()
```
11.3 Spinbox
数值输入。
Spinbox(父对象,options,…)
- activebackground，bg，bd，command，disablebackground，disableforeground，fg，font，justify，relief，state，textvariable，width；
- format：格式化的字符串；
- from_：范围值的初值；
- increment：每次点击up/down按钮的增量；
- repeatdalay：可以单击up/down的时间间隔，单位是ms，默认300；
- values：可以是元组或其他序列值；
- to：范围的终值；
- wrap：单击up/down可以让数值重新开始；
- xscrollcommand：在x轴使用滚动条。
```
def printInfo():
    print(spin.get())
root = Tk()
root.title("Ex")
root.geometry("300x100")
spin = Spinbox(root, from_ = 10, to = 30, increment = 2, 
               command = printInfo)
spin.pack()
root.mainloop()
```
序列存储：
将数值存储在序列数据中，单击up/down时相当于观察元组或列表中的值。
spin = Spinbox(root, values = (10, 30, 170, 100),
command = printInfo)
也可以存储非数值数据：
spin = Spinbox(root, values = ("北京", "哈尔滨", "天津"),
command = printInfo)
12. 消息提示
12.1 Message
主要用于显示短消息，与Label功能和用法类似，但是使用更加灵活。
Message(父对象,options)
- anchor，bg，bitmap，cursor，fg，font，height，image，justify，padx/pady，relief，text，textvariable，underline，width，wraplength；
- aspect：控件宽度与高度比，默认150%。
12.2 Messagebox
tkinter模块内有Messagebox模块，提供了8个对话框：
1. showinfo(title, message)：显示一般提示信息；
2. showwarning(title, message)：显示警告信息；
3. showerror(title, message)：显示错误信息；
4. askquestion(title, message)：显示询问消息，传回"yes"或"no"；
5. askokcancel(title, message)：显示确定或取消消息，传回True或False；
6. askyesno(title, message)：显示是或否，传回True或False；
7. askyesnocancel(title, message)：显示是或否或取消，传回True或Flase或None;
8. askretrycancel(title, message)：显示重试或取消，传回True或False。
title是对话框的名称，message是对话框内的文字。
```
def myMsg():
    messagebox.showinfo("My message Box", 
                        "Python Tkinter 早安")
root = Tk()
root.title("Ex")
root.geometry("300x160")

Button(root, text = "Good Morning", command = myMsg).pack()

root.mainloop()
```
将用户相应传回，在窗口中列出相应的内容。
def myMsg():
     ret = messagebox.askyesnocancel("My message Box",
                         "是或否或取消？")
     print(ret)
利用传回值就可以进行进一步的操作。
13. 事件和绑定
其实GUI是一种事件导向的应用程序设计，事件的来源可能是用户单击鼠标，键盘输入或是Widget状态改变，tkinter提供一些机制让我们可以针对这些事件做更进一步的处理，这些处理的方式称为事件处理程序。
13.1 事件绑定
前面介绍的command参数其实就是一种事件绑定，command=callback就是事件处理程序。
在tkinter应用程序中最后一个指令是mainloop()，这个方法是让程序进入事件等待循环，tkinter也提供了为事件绑定处理程序的机制，它的语法为：
widget.bind(event, handler)
widget是事件的来源，可以是root窗口对象，或是任意的Widget控件，handler是事件处理程序。
有了以上事件绑定后，就可以自行设计事件绑定效果了。
若是在Button内省略command参数，可以用以下方法重建：
btn.bind("<Button-1>", event_handler)
鼠标绑定基本应用：
```
def callback(event):
    print("Clicked at", event.x, event.y)
root = Tk()
root.title("Ex")
root.geometry("300x160")
root.bind("<Button-1>", callback)
root.mainloop()
```
移动鼠标时在窗口下方显示鼠标目前的坐标：
```
def mouseMotion(event):
    x = event.x
    y = event.y
    textvar = "Mouse location - x:{}, y:{}".format(x,y)
    var.set(textvar)
root = Tk()
root.title("Ex")
root.geometry("300x160")
x, y = 0, 0
var = StringVar()
text = "Mouse location - x:{}, y:{}".format(x,y)
var.set(text)
lab = Label(root, textvariable = var)
lab.pack(anchor = S, side = RIGHT, padx = 10, pady = 10)
root.bind("<Motion>", mouseMotion)
root.mainloop()
```
```
def enter(event):
    x.set("鼠标进入Exit功能按钮")
def leave(event):
    x.set("鼠标离开Exit功能按钮")
root = Tk()
root.title("Ex")
root.geometry("300x160")
btn = Button(root, text = "Exit", command = root.destroy)
btn.pack(pady = 30)
btn.bind("<Enter>", enter)
btn.bind("<Leave>", leave)

x = StringVar()
lab = Label(root, textvariable = x, bg = "yellow", fg = "blue", 
            height = 5, width = 20)
lab.pack(pady = 20)

root.mainloop()
```
键盘Esc键测试：
```
def leave(event):
    ret = messagebox.askyesno("Exit", "是否离开？")
    if ret == True:
        root.destroy()
    else:
        return
root = Tk()
root.title("Ex")
root.geometry("300x160")
root.bind("<Escape>",leave)
lab = Label(root, text = "Esc键测试", bg = "yellow", fg = "blue")
lab.pack(pady = 30)
root.mainloop()
```
a~z按键测试：
```
def key(event):
    print("按了 " + repr(event.char) + " 键")
root = Tk()
root.title("Ex")
root.geometry("300x160")
root.bind("<Key>",key)
lab = Label(root, text = "a~z键测试", bg = "yellow", fg = "blue")
lab.pack(pady = 30)
root.mainloop()
```
注意：当事件绑定与Frame有关时，必须在Frame获得焦点时，键盘绑定才可生效。
```
def key(event):
    print("按了 " + repr(event.char) + " 键")
def coordXY(event):
    frame.focus_set()
    print("鼠标坐标:", event.x, event.y)
root = Tk()
root.title("Ex")
root.geometry("300x160")
frame = Frame(root, width = 100, height = 100, bg = "blue")
frame.bind("<Key>",key)
frame.bind("<Button-1>", coordXY)
frame.pack()
lab = Label(frame, text = "a~z键测试", bg = "yellow", fg = "blue")
lab.pack(padx = 30, pady = 30)
root.mainloop()
```
13.2 取消绑定
boj.unbind("<xxx>")
通过复选框控制是否绑定：
```
def buttonClicked(event):
    print("I like tkinter")
def toggle(onoff):
    if var.get() == True:
        onoff.bind("<Button-1>", buttonClicked)
    else:
        onoff.unbind("<Button-1>")
root = Tk()
root.title("Ex")
root.geometry("300x160")
btn = Button(root, text = "tkinter")
btn.pack(anchor = W, padx = 10, pady = 10)
var = BooleanVar()
cbtn = Checkbutton(root, text = "bind/unbind", variable = var, 
                   command = lambda:toggle(btn))
cbtn.pack(anchor = W, padx = 10)
root.mainloop()
```
13.3 绑定多个事件处理程序
tkinter也允许我们将一个事件绑定多个事件处理程序，同样是使用bind()方法，但是新增加的事件处理程序需要在bind()方法内增加参数add = "+"。
```
def buttonClicked1():
    print("Command event handler, I like tkinter")
def buttonClicked2(event):
    print("Bind event handler, I like tkinter")

root = Tk()
root.title("Ex")
root.geometry("300x160")
btn = Button(root, text = "tkinter", command = buttonClicked1)
btn.pack(anchor = W, padx = 10, pady = 10)
btn.bind("<Button-1>", buttonClicked2, add = "+")
root.mainloop()
```
bind()程序先被执行，command后执行。
13.4 Protocols
Protocols为窗口管理程序与应用程序之间的的通信协议。
单击按钮可以关闭窗口，它的名称是WM_DELETE_WINDOW，使用程序修改此协议，改为单击此按钮后弹出Messagebox，询问结束或取消，若单击确定才会结束此程序。
```
def callback():
    res = messagebox.askokcancel("Exit", "确定要退出吗？")
    if res == True:
        root.destroy()
    else:
        return

root = Tk()
root.title("Ex")
root.geometry("300x160")
root.protocol("WM_DELETE_WINDOW", callback)
root.mainloop()
```
14. Listbox
列表框（Listbox）是一个显示一系列选项的Widget控件，用户可以进行单项或多项的选择。
Listbox(父对象,options,…)
- bg，bd，cursor，fg，font，height，highlightcolor，highlightthickness，relief，width；
- listvariable：以变量方式处理选项内容；
- selectbackground：被选取字符串的背景色彩；
- selectmode：决定有多少个选项可以被选取，以及鼠标拖曳如何影响选项；
- xscrollcommand：在x轴使用滚动条；
- yscrollcommand：在y轴使用滚动条。
14.1 insert()
可以使用insert()方法为列表框建立项目。
insert(index, element)
index是项目插入位置，如果是在最后面可以使用END。
```
fruits = ["Banana", "Watermelon", "Pineapple", 
          "Orange", "Grapes", "Mango"]

root = Tk()
root.title("Ex")
root.geometry("300x160")

lb = Listbox(root, selectmode = MULTIPLE)
for fruit in fruits:
    lb.insert(END, fruit)
lb.pack(pady = 10)
root.mainloop()
```
14.2 Listbox()基本操作
1. size()：传回列表项目的数量
print("items数目", lb.size())
2. selection_set()：选取特定索引项
lb.selection_set(0)
设定初始选取项目为第一个。
lb.selection_set(0, 3)
设定初始选取项目为前3个。
3. delete()：删除特定索引项
lb.delete(0)
lb.delete(0, 3)
4. get()：传回指定索引项
print(lb.get(0))
5. curselection()：传回选取项目的索引
打印所选取的项目。
```
def callback():
    indexs = lb.curselection()
    for index in indexs:
        print(lb.get(index))
fruits = ["Banana", "Watermelon", "Pineapple", 
          "Orange", "Grapes", "Mango"]

root = Tk()
root.title("Ex")
root.geometry("300x300")

lb = Listbox(root, selectmode = EXTENDED)
for fruit in fruits:
    lb.insert(END, fruit)
lb.pack(pady = 10)
btn = Button(root, text = "Print", command = callback)
btn.pack(pady = 5)
root.mainloop()
```
6. selection_includes()：检查指定索引是否被选取
def callback():
print(lb.select_includes(0))
14.3 绑定事件
当Listbox执行选取操作时会产生<<ListboxSelect>>虚拟事件，可以由此设置时间处理程序。
当选择Listbox中的项目时，在上方列出所选的项目：
```
def itemSelected(event):
    obj = event.widget
    index = obj.curselection()
    var.set(obj.get(index))
fruits = ["Banana", "Watermelon", "Pineapple", 
          "Orange", "Grapes", "Mango"]
root = Tk()
root.title("Ex")
root.geometry("300x300")

var = StringVar()
lab = Label(root, text = "", textvariable = var)
lab.pack(pady = 5)
lb = Listbox(root, selectmode = SINGLE)
for fruit in fruits:
    lb.insert(END, fruit)
lb.pack(pady = 10)
lb.bind("<<ListboxSelect>>", itemSelected)
root.mainloop()
```
14.4 增删项目示例
Entry是输入控件，可以输入项目名称，输入完成后单击“增加”按钮可以将此项目加入Listbox，同时Entry被清空。若是选择Listbox内的项目后单击“删除”，就可以从Listbox删除所选项目。
```
def itemAdded():
    varAdd = entry.get()
    if len(varAdd.strip()) == 0:
        return
    lb.insert(END, varAdd)
    entry.delete(0, END)
def itemDeleted():
    index = lb.curselection()
    if len(index) == 0:
        return
    lb.delete(index)
root = Tk()
root.title("Ex")

entry = Entry(root)
entry.grid(row = 0, column = 0, padx = 5, pady = 5)

btnAdd = Button(root, text = "增加", width = 10, command = itemAdded)
btnAdd.grid(row = 0, column = 1, padx = 5, pady = 5)

lb = Listbox(root)
lb.grid(row = 1, column = 0, columnspan = 2, padx = 5, pady = 5, stick = W)

btnDel = Button(root, text = "删除", width = 10, command = itemDeleted)
btnDel.grid(row = 2, column = 0, padx = 5, pady = 5, stick = W)

root.mainloop()
```
14.5 项目排序
```
def itemSorted():
    listTmp = list(lb.get(0, END))
    sortedList = sorted(listTmp, reverse = var.get())
    lb.delete(0, END)
    for item in sortedList:
        lb.insert(END, item)
fruits = ["Banana", "Watermelon", "Pineapple", 
          "Orange", "Grapes", "Mango"]
root = Tk()
root.title("Ex")

lb = Listbox(root)
for fruit in fruits:
    lb.insert(END, fruit)
lb.pack(padx = 10, pady = 5)

btn = Button(root, text = "排序", command = itemSorted)
btn.pack(side = LEFT, padx = 10, pady = 5)

var = BooleanVar()
cb = Checkbutton(root, text = "倒序", variable = var)
cb.pack(side = LEFT)

root.mainloop()
```
14.6 拖曳项目
```
def getIndex(event):
    lb.index = lb.nearest(event.y) #目前选项的索引
def dragJob(event):
    newIndex = lb.nearest(event.y)
    x = lb.get(lb.index)
    lb.delete(lb.index)
    lb.insert(newIndex, x)
    lb.selection_set(newIndex)
    lb.index = newIndex
fruits = ["Banana", "Watermelon", "Pineapple", 
          "Orange", "Grapes", "Mango"]
root = Tk()
root.title("Ex")

lb = Listbox(root)
for fruit in fruits:
    lb.insert(END, fruit)
lb.bind("<Button-1>", getIndex)
lb.bind("<B1-Motion>", dragJob) #拖曳动作
lb.pack(padx = 10, pady = 5)

root.mainloop()
```
14.7 Scrollbar
在默认的情况下Listbox是没有滚动条的，如果选项太多将造成部分选项无法显示，此时可将滚动条Scrollbar加入Listbox。
另外，滚动条也可以应用在Text和Canvas控件上。
Scrollbar(父对象,options,…)
- bg，bd，cursor，orient，width；
- activebackground：当光标经过滚动条时，滚动条和方向箭头的色彩；
- command：滚动条移动时所触发的方法；
- elementborderwidth：滚动条和方向箭头的外部宽度，默认为1；
- highlightbackground；
- highlightcolor：当滚动条获得焦点时的色彩；
- highlightthickness；
- jump：默认为0，每次拖曳滚动条都会触发command方法，如果设为1则只有放开鼠标时才会触发command方法；
- repeatdalay：设置按住滚动条移动的停滞时间，单位是ms，默认值300；
- takefocus：正常可以用Tab键的方式切换滚动条成为焦点，设为0可以取消此设置；
- troughcolor：滚动条色槽的颜色。
```
root = Tk()
root.title("Ex")

scrollbar = Scrollbar(root)
scrollbar.pack(side = RIGHT, fill = Y)
# 将Listbox与滚动条做连动
lb = Listbox(root, yscrollcommand = scrollbar.set)
for i in range(50):
    lb.insert(END, "Line " + str(i+1))
lb.pack(side = LEFT, fill = BOTH, expand = True)
scrollbar.config(command = lb.yview)

root.mainloop()
```
15. OptionMenu
下拉式列表，用户可以从中选择一项。
OptionMenu(父对象,var,*value)
其中*value是一系列下拉列表。
使用set可以建立默认选项。
```
root = Tk()
root.title("Ex")
root.geometry("250x100")
omTuple = ("Python", "Matlab", "C")
var = StringVar()
var.set("Python")
optionmenu = OptionMenu(root, var, *omTuple)
optionmenu.pack()
root.mainloop()
```
同样，使用get()可以获取所选选项。
16. Combobox
组合框，tkinter.ttk中的控件，特性与OptionMenu类似，是Entry与下拉菜单的组合。
Combobox(父对象,options)
- textvariable：可以设置Combobox的变量值；
- value：Combobox的选项内容，以元组方式存在。
使用current()设置默认选项。
```
from tkinter.ttk import *
root = Tk()
root.title("Ex")
root.geometry("250x100")

var = StringVar()
cb = Combobox(root, textvariable = var)
cb["value"] = ("Python", "Matlab", "C")
cb.current(0)
cb.pack()
root.mainloop()
```
当Combobox中的选项有变动时，会产生<<ComboboxSelected>>虚拟事件，可以用此特性绑定事件处理方法。
17. PanedWindow
面板，可以在此容器内建立任意数量的子控件。
PanedWindow(父对象,options,…)
- bg，bd，borderwidth，cursor，height，orient（默认HORIZONTAL），relief（默认FLAT），width；
- handlepad：面板显示宽度，默认为8；
- handlesize：面板显示大小，默认为8；
- sashcursor：分割线光标；
- sashrelief：面板分割线外框，默认RAISED；
- showhandle：滑块属性，可设定是否显示。
17.1 add()
使用add(child, options)可以插入子对象。
```
root = Tk()
root.title("Ex")

pw = PanedWindow(orient = VERTICAL)
pw.pack(fill = BOTH, expand = True)
top = Label(pw, text = "Top Pane")
pw.add(top)
bottom = Label(pw, text = "Bottom Pane")
pw.add(bottom)

root.mainloop()
```
17.2 LabelFrame子对象
常见的应用是将PanedWindow分成两三份，然后可以将所设计的控件适度分配位置。
```
root = Tk()
root.title("Ex")

pw = PanedWindow(orient = HORIZONTAL)
pw.pack(fill = BOTH, expand = True)
leftframe = LabelFrame(pw, text = "Left Pane", width = 120, height = 150)
pw.add(leftframe)
rightframe = LabelFrame(pw, text = "Right Pane", width = 100, height = 150)
pw.add(rightframe)

root.mainloop()
```
使用ttk中的weight参数可以设置更改窗口大小时各个对象缩放的比例，都设为1以同比例缩放。
from tkinter.ttk import *
pw.add(leftframe, weight = 1)
pw.add(rightframe, weight = 1)
18. Notebook
tkinter.ttk中的控件。
也是一个容器控件，它的特点是可以有许多选项卡，当选择不同选项卡时可以看到不同的子控件内容。
Notebook(父对象,options)
- height，width；
- padding：设置Notebook外围的额外空间，可以设置4个数值代表left、top、right、bottom。
使用Notebook()建立框架的步骤如下：
1. 建立Notebook对象，名为notebook；
2. 调用add子方法插入子对象并添加选项卡add(子对象, text = "xxx")；
3. 正常add(子对象, options).
options:
- compound：设置当选项卡内同时含图像和文字时，彼此之间的位置关系；
- image：选项卡以图像方式呈现；
- padding：设置面板的额外空间；
- state：默认normal，设为disable表示无法使用，设为hidden表示隐藏；
- sticky：指出子窗口面板的配置方式，n/s/e/w；
- text：选项卡中的字符串内容；
- underline。
```
from tkinter import *
from tkinter.ttk import *
def msg():
    messagebox.showinfo("Notebook", "欢迎使用Notebook")
root = Tk()
root.title("Ex")
root.geometry("300x160")

notebook = Notebook(root)
frame1 = Frame()
frame2 = Frame()
label = Label(frame1, text = "Tkinter")
label.pack(padx = 10, pady = 10)
btn = Button(frame2, text = "Help", command = msg)
btn.pack(padx = 10, pady = 10)
notebook.add(frame1, text = "标签页1")
notebook.add(frame2, text = "标签页2")
notebook.pack(padx = 10, pady = 10, fill = BOTH, expand = True)

root.mainloop()
```
相关阅读:
各类 HTTP 返回状态代码详解
 ANDROID内存优化——大汇总（转）
Process Stats:了解你的APP如何使用内存（转）
Android开发之AlarmManager详解
 转 16 jmeter中的监听器以及测试结果分析
 转 15 jmeter分布式性能测试
 转 14 jmeter性能测试实战--数据库MySQL
转 12 jmeter性能测试实战--web程序
 转 11 jmeter之图形监控扩展
 转 10 jmeter之动态关联
原文地址：https://www.cnblogs.com/dingdangsunny/p/12683678.html

Python GUI——tkinter菜鸟编程（中）

8. Radiobutton

8.1 示例

8.2 字典

8.3 盒子选项按钮

9. Checkbutton

10. 容器

10.1 Frame

10.2 LabelFrame

10.3 Toplevel

11. 与数字有关

11.1 Scale

11.2 askcolor()

11.3 Spinbox

12. 消息提示

12.1 Message

12.2 Messagebox

13. 事件和绑定

13.1 事件绑定

13.2 取消绑定

13.3 绑定多个事件处理程序

13.4 Protocols

14. Listbox

14.1 insert()

14.2 Listbox()基本操作

14.3 绑定事件

14.4 增删项目示例

14.5 项目排序

14.6 拖曳项目

14.7 Scrollbar

15. OptionMenu

16. Combobox

17. PanedWindow

17.1 add()

17.2 LabelFrame子对象

18. Notebook