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

8. Radiobutton

选项按钮：可以用鼠标单击方式选取，一次只能有一个选项被选取。

常用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类型。

使用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 盒子选项按钮

9. Checkbutton

复选框，可以复选。

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

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

• bg，bd，cursor，font，height，highlightbackground，highlightcolor，highlighthickness，labelAnchor，relief，text，width。

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

用过移动尺度条产生某一范围的数字。

• 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

数值输入。

• 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时相当于观察元组或列表中的值。

也可以存储非数值数据：

12. 消息提示

12.1 Message

主要用于显示短消息，与Label功能和用法类似，但是使用更加灵活。

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

将用户相应传回，在窗口中列出相应的内容。

利用传回值就可以进行进一步的操作。

13. 事件和绑定

其实GUI是一种事件导向的应用程序设计，事件的来源可能是用户单击鼠标，键盘输入或是Widget状态改变，tkinter提供一些机制让我们可以针对这些事件做更进一步的处理，这些处理的方式称为事件处理程序。

13.1 事件绑定

前面介绍的command参数其实就是一种事件绑定，command=callback就是事件处理程序。

在tkinter应用程序中最后一个指令是mainloop()，这个方法是让程序进入事件等待循环，tkinter也提供了为事件绑定处理程序的机制，它的语法为：

widget是事件的来源，可以是root窗口对象，或是任意的Widget控件，handler是事件处理程序。

有了以上事件绑定后，就可以自行设计事件绑定效果了。

若是在Button内省略command参数，可以用以下方法重建：

鼠标绑定基本应用：

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 取消绑定

通过复选框控制是否绑定：

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控件，用户可以进行单项或多项的选择。

• 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()方法为列表框建立项目。

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()：传回列表项目的数量

2. selection_set()：选取特定索引项

设定初始选取项目为第一个。

设定初始选取项目为前3个。

3. delete()：删除特定索引项

4. get()：传回指定索引项

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()：检查指定索引是否被选取

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控件上。

• 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

下拉式列表，用户可以从中选择一项。

其中*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与下拉菜单的组合。

• 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

面板，可以在此容器内建立任意数量的子控件。

• 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以同比例缩放。

18. Notebook

tkinter.ttk中的控件。

也是一个容器控件，它的特点是可以有许多选项卡，当选择不同选项卡时可以看到不同的子控件内容。

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