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] + "\t"
    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：決定有多少個選項可以被選取，以及鼠標拖曳如何影響選項；
• BROWSE：默認值，可以選擇一個選項，如果選取一個選項同時拖曳鼠標，將由鼠標釋放的位置決定被選取的選項；
• SINGLE：只能選擇一個選項，可以用單擊方式選取，不可用拖曳方式更改所選的項目；
• MULTIPLE：可以選擇多個選項，單擊項目切換是否選取該項目；
• EXTENDED：按住Ctrl可以多選，單擊第一個項目然后拖曳到最后一個項目，即可選取這個區間的一系列選項，單擊一個選項並按住Shift單擊另一個選項可以選取區間項目；
• 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()