Python--详解TKinter类库

 1 #coding=gbk
 2 from tkinter import *
 3 master =Tk()
 4 def callback():
 5     print(‘click!‘)
 6 #最普通的返回操作，按钮返回一个值（通过一个函数传递）
 7 #b=Button(master,text=‘OK‘,command=callback)
 8
 9 #DISABLED  state状态    表示不能按下这个按钮，无法操作这个按钮
10 #b = Button(master, text="Help", state=DISABLED)
11
12 #当你不设置大小的时候，按钮能容纳所有东西；当然你也可以指定大小：padx，pady
13 #b = Button(master, text="Help", state=DISABLED,padx=59,pady=99)
14
15 #当然我们也可以在按钮里面在写入一个窗体，窗体一般是用像素来表示的，所以按钮也是可以按照像素来进行表示的，位图也是可以的
16 # f = Frame(master, height=320, width=320)
17 # f.pack_propagate(0) # don‘t shrink
18 # f.pack()
19 # b = Button(f, text="Sure!")#将窗体导入
20 # b.pack(fill=BOTH, expand=1)#填充顶部，扩展
21
22 #当text有多行的时候
23 #b = Button(master, text=‘longtext阿士大夫撒旦法士大夫撒旦法‘, anchor=W, justify=LEFT, padx=2)
24
25 #这个操作是让按钮好像已经按下去了但是实际上没有触发按钮的功能，再点击就能触发
26 #b.config(relief=SUNKEN)
27
28 #b = Checkbutton(master, image=, variable=‘var‘, indicatoron=0)
29 #b = Button(master, text="Click me", image=‘pattern‘, compound=CENTER)
30
31
32 b.pack()
33
34 mainloop()

 1 #coding=gbk
 2
 3 activebackground, activeforeground:当按钮被激活时所使用的颜色
 4 anchor:控制按钮上内容的位置。使用N, NE, E, SE, S, SW, W, NW, or CENTER这些值之一。默认值是CENTER。
 5 background (bg), foreground (fg):按钮的颜色。默认值与特定平台相关。
 6 bitmap:显示在窗口部件中的位图。如果image选项被指定了，则这个选项被忽略。下面的位图在所有平台上都有 效：error, gray75, gray50, gray25, gray12, hourglass, info, questhead, question, 和 warning.
 7
 8 borderwidth (bd):按钮边框的宽度。默认值与特定平台相关。但通常是1或2象素。
 9 command:当按钮被按下时所调用的一个函数或方法。所回调的可以是一个函数、方法或别的可调用的Python对象。
10 cursor:当鼠标移动到按钮上时所显示的光标。
11 default:如果设置了，则按钮为默认按钮。
12 disabledforeground:当按钮无效时的颜色。
13 image:在部件中显示的图象。如果指定，则text和bitmap选项将被忽略。
14 justify:定义多行文本如何对齐。可取值有：LEFT, RIGHT, 或 CENTER。
15 padx, pady:指定文本或图象与按钮边框的间距。
16 state:按钮的状态：NORMAL, ACTIVE 或 DISABLED。默认值为NORMAL。
17 relief:边框的装饰。通常按钮按下时是凹陷的，否则凸起。另外的可能取值有GROOVE, RIDGE, 和 FLAT。
18 text:显示在按钮中的文本。文本可以是多行。如果bitmaps或image选项被使用，则text选项被忽略
19 textvariable:
20 underline:在文本标签中哪个字符加下划线。默认值为-1，意思是没有字符加下划线
21 width, height:按钮的尺寸。如果按钮显示文本，尺寸使用文本的单位。如果按钮显示图象，尺寸以象素为单位（或屏幕的单位）。如果尺寸没指定，它将根据按钮的内容来计算。

 1 #coding=gbk
 2 from tkinter import *
 3 master = Tk()
 4
 5 #w = Label(master, text="Hello, world!")
 6
 7 # w = Label(master, text="Rouge", fg="red")
 8 # w = Label(master, text="Helvetica", font=("Helvetica", 16))
 9
10 # w = Label(master, text=longtext, anchor=W, justify=LEFT)
11
12 # v = StringVar()
13 # Label(master, textvariable=v).pack()
14 # v.set("New Text!")
15
16 b.pack()
17 mainloop()

 1 #coding=gbk
 2 from tkinter import *
 3 master = Tk()
 4
 5 w = Canvas(master, width=200, height=100)
 6 w.pack()
 7 #
 8 # w.create_line(0, 0, 200, 100)
 9 # w.create_line(0, 100, 200, 0, fill="red", dash=(4, 4))
10 #
11 # w.create_rectangle(50, 25, 150, 75, fill="blue")
12
13
14 mainloop()

 1 Canvas(root,bg):构造方法，在root上创建画布，root是母控件，bg是背景色，用字符串设定，例如bg=‘white‘
 2
 3 create_rectancle(x1,y1,x2,y2[,fill,outline,width,stipple,dash,tags]):
 4
 5    创建一个item对象，形状是矩形，即在Canvas对象画矩形，x1,y1,x2,y2是坐标，是前4个参数，后面的参数顺序是乱来的。fill表示item的填充颜色，凡是颜色都用字符串设定，outline表示边框线的颜色，width表示边框线的宽度，dash如果缺省，则边框线是实线，否则用一个1到255的整数表示，设定虚线的长度，一般用10即可，stipple可以在图形中加入斑点，一般参数是‘gray12‘,‘gray25‘这样，暂时不太清楚，一般省略。tags可以是一个字符串或元组.列表等，使用后创建的item对象的tags字段就设定了，可用来作为标识寻找该item，也可以用Canvas.gettags(item)返回item的tags字段。注意tags如果是一个序列，则元组中任一元素都可以作为标识符，也就是有多个标识符。该方法返回一个编号，而不是item对象本身，编号表示该item是Canvas的第几个item。
 6
 7 coords(item,position):
 8
 9     移动一个item(即画好的图形)的位置，item为移动的对象，position是一个元组，4个整数表示移动后的坐标。
10
11 find_withtag(tag):
12
13     返回一个元组，表示所有以tag为标识符的Item对象。item对象返回后不是一个对象而是一个整数，代表是Canvas对象的第几个item而已。即使不用该方法，直接print(item)，或item回车，显示的也是item对象的编号，比如1，2，3这些而已。
14
15 itemconfig(item[,item类的其他参数，参见create_rectancle):
16
17     设置item的各个参数，注意item可以用编号表示。
18
19 move(item,x,y):
20
21     把item移动，坐标增量为x,y
22
23 del(item or tag):
24
25     删除一个item，可用item编号（整数）或tag(字符串)
26
27 scale(item,xoffset,yoffset,xscale,yscale):
28
29     保持第一个端点不变，把变长，变为:(原边长 - offset)*scale + offset。简单的用法是offset全部为0，只改变变长的倍数
30
31 tag_bind(tag,buttonType,methor):
32
33     绑定事件与方法。当拥有tag标签的item的边框被点击时，会调用Methor，buttonType用字符串表示，设定点击的键，常用的‘<Button-1>‘表示鼠标左键，‘<Button-3>‘表示鼠标右键
34
35 除了绘制矩形外，还有弧形，支线，文字，位图（一些图标），图像文件等都可以绘制，具体看说明，不再详细记录。

 1     #构造函数
 2     __init__(self, vgap=0, hgap=0)
 3     (Constructor)
 4
 5     Constructor, with optional parameters to specify the gap between the rows and columns.
 6
 7         Parameters:
 8             vgap
 9                        (type=int)
10
11             hgap
12                        (type=int)
13
14     #添加单个构件到boxsizer
15     # pos 表示的单元格的点(cell position可以看做是坐标)
16     # span 表示的单个或合并的单元格
17     Add(self, item, pos, span=DefaultSpan, flag=0, border=0, userData=None)
18
19     Adds an item to the sizer at the grid cell pos, optionally spanning more than one row or column as specified with span. The remaining args behave similarly to wx.Sizer.Add.
20
21     Returns True if the item was successfully placed at the given cell position, False if something was already there.
22
23         Parameters:
24             pos
25                        (type=GBPosition)
26
27             span
28                        (type=GBSpan)
29
30             flag
31                        (type=int)
32
33             border
34                        (type=int)
35     .
36     .
37     .
38     (原文: http://www.wxpython.org/docs/api/wx.GridBagSizer-class.html)  

 1     def __init__(self, parent):
 2             wx.Panel.__init__(self, parent, -1, wx.DefaultPosition, wx.DefaultSize)
 3             wred = wx.TextCtrl(self, wx.NewId(), ‘red‘)
 4             wwhite = wx.TextCtrl(self, wx.NewId(), ‘white‘)
 5             wblue = wx.TextCtrl(self, wx.NewId())
 6             wcyan = wx.TextCtrl(self, wx.NewId())
 7
 8             vgap, hgap = 10, 20
 9             gbs = wx.GridBagSizer(vgap, hgap)
10
11             b = 0
12             # Add(self, item, pos, span=DefaultSpan, flag=0, border=0, userData=None)
13             # pos (type=GBPosition) cell position
14             # span(type=GBSPan)
15             gbs.Add(wred, (1, 1), (1, 1), wx.EXPAND | wx.ALL, b)
16             gbs.Add(wwhite, (2, 3), (1, 1), wx.EXPAND | wx.ALL, b)
17             gbs.Add(wblue, (1, 0), (1, 1), wx.EXPAND | wx.ALL, b)
18             gbs.Add(wcyan, (0, 0), (1, 1), wx.EXPAND | wx.ALL, b)
19
20             gbs.AddGrowableRow(0) # 0/1/2...表示的行号或列号
21             gbs.AddGrowableRow(1)
22             gbs.AddGrowableRow(2)
23             gbs.AddGrowableCol(0)
24             gbs.AddGrowableCol(1)
25             gbs.AddGrowableCol(3)
26
27             self.SetSizer(gbs)  

 1 #Tkinter教程之Entry篇
 2 #Entry用来输入单行文本
 3 ‘‘‘1.第一个Entry程序‘‘‘
 4 from Tkinter import *
 5 root = Tk()
 6 Entry(root,text = ‘input your text here‘).pack()
 7 root.mainloop()
 8 #上面的代码目的是创建一个Entry对象，并在Entry上显示‘input your text here‘,运行此代码，并没有看到文本的显示，由此可知与Lable和Button不同，Entry的text属性不可以设置Entry的文本
 9
10 ‘‘‘2.在Entry中设定初始值，使用textvariable将变量与Entry绑定‘‘‘
11 from Tkinter import *
12 root = Tk()
13 e = StringVar()
14 entry = Entry(root,textvariable = e)
15 e.set(‘input your text here‘)
16 entry.pack()
17 root.mainloop()
18
19 #上面的例子中将变量e与Entry绑定，然后将e的值设置为‘input your text here‘，程序运行时的初始值便设置了。
20
21 ‘‘‘3.设置为只读Entry.
22 Entry的另一个比较有用的属性，设置为只读，不允许用户对它的值改变。
23 设置state属性为‘readonly‘
24 ‘‘‘
25 from Tkinter import *
26 root = Tk()
27 e = StringVar()
28 entry = Entry(root,textvariable = e)
29 e.set(‘input your text here‘)
30 entry.pack()
31 entry[‘state‘] = ‘readonly‘
32 root.mainloop()
33
34 #实际上Entry的属性值可以使用的也为normal/active/disabled,‘readonly‘与disabled一样
35
36 ‘‘‘4.设置为密码输入框
37 #将Entry作为一个密码输入框来使用，即不显示用户输入的内容值，用特定符号代替。使用用属性
38 show来指定。
39 ‘‘‘
40 from Tkinter import *
41 root = Tk()
42 e = StringVar()
43 entry = Entry(root,textvariable = e)
44 e.set(‘input your text here‘)
45 entry.pack()
46 #使用*来显示输入的内容，如果喜欢可以改为其它字符
47 entry[‘show‘] = ‘*‘
48 #分别使用*#$显示输入的文本内容
49 for mask in [‘*‘,‘#‘,‘$‘]:
50     e = StringVar()
51     entry = Entry(root,textvariable = e)
52     e.set(‘password‘)
53     entry.pack()
54     entry[‘show‘] = mask
55
56 root.mainloop()
57
58 ‘‘‘5.验证输入的内容是否符合要求。
59 使用validate来校验输入的内容
60 使用validate方法来限制输入的内容
61 这是一个有问题的例子，无法调用validateText回调函数
62 ‘‘‘‘
63 from Tkinter import *
64 root = Tk()
65 e = StringVar()
66 def validateText(contents):
67     print contents
68     return contents.isalnum()
69
70 entry = Entry(root,validate = ‘key‘,textvariable = e,validatecommand = validateText)
71 entry.pack()
72
73 root.mainloop()
74 ‘‘‘
75 文档中说明使用validate来接受的事件，使用validatecommand来确定输入的内容是否合法，但
76 如何传入参数？没找到相应的说明
77 ‘‘‘
78 #还有其他的属性fg/bg/relief/width/height/justify/state使用方法与Button相同，不再举例。
79
80 #author:     jcodeer
81 #blog:    jcodeer.cublog.cn
82 #email:    [email protected]

  1 #coding=gbk
  2 from tkinter import *
  3 # root = Tk()
  4 # def hello():
  5 #     print ("hello menu")
  6 # menubar = Menu(root)
  7 # #创建主菜单，每个菜单对应的回调函数都是hello
  8 # for item in [‘Python‘,‘PHP‘,‘CPP‘,‘C‘,‘Java‘,‘JavaScript‘,‘VBScript‘]:
  9 #     #添加菜单函数
 10 #     menubar.add_command(label = item,command = hello)
 11 # #将root的menu属性设置为menubar
 12 # root[‘menu‘] = menubar
 13 # root.mainloop()
 14
 15
 16 # root = Tk()
 17 # def hello():
 18 #     print (‘hello menu‘)
 19 # menubar = Menu(root)
 20 #
 21 # filemenu = Menu(menubar,tearoff = 0)
 22 # for item in [‘Python‘,‘PHP‘,‘CPP‘,‘C‘,‘Java‘,‘JavaScript‘,‘VBScript‘]:
 23 #     #添加菜单函数
 24 #     filemenu.add_commad(label = item,command = hello)
 25 # #将menubar的menu属性指定为filemenu，即filemenu为menubar的下拉菜单
 26 # menubar.add_cascade(label = ‘Language‘,menu = filemenu)
 27 # root[‘menu‘] = menubar
 28 # root.mainloop()
 29
 30
 31 # ‘‘‘3.向菜单中添加Checkbutton项‘‘‘
 32 # # -*- coding: cp936 -*-
 33 # from Tkinter import *
 34 # root = Tk()
 35 #每次打印出各个变量的当前值
 36 # root = Tk()
 37 # #每次打印出各个变量的当前值
 38 # def printItem():
 39 #     print (‘Python = ‘),vPython.get()
 40 #     print (‘PHP = ‘),vPHP.get()
 41 #     print (‘CPP = ‘),vCPP.get()
 42 #     print (‘C = ‘),vC.get()
 43 #     print (‘Java = ‘),vJava.get()
 44 #     print (‘JavaScript = ‘),vJavaScript.get()
 45 #     print (‘VBScript = ‘),vVBScript.get()
 46 #
 47 # menubar = Menu(root)
 48 #
 49 # vPython = StringVar()
 50 # vPHP     = StringVar()
 51 # vCPP     = StringVar()
 52 # vC         = StringVar()
 53 # vJava     = StringVar()
 54 # vJavaScript = StringVar()
 55 # vVBScript     = StringVar()
 56 #
 57 # filemenu = Menu(menubar,tearoff = 0)
 58 # for k,v in {‘Python‘:vPython,
 59 #                ‘PHP‘:vPHP,
 60 #                ‘CPP‘:vCPP,
 61 #                ‘C‘:vC,
 62 #                ‘Java‘:vJava,
 63 #                ‘JavaScript‘:vJavaScript,
 64 #                ‘VBScript‘:vVBScript}.items():
 65 #     #绑定变量与回调函数
 66 #     filemenu.add_checkbutton(label = k,command = printItem,variable = v)
 67 # #将menubar的menu属性指定为filemenu，即filemenu为menubar的下拉菜单
 68 # menubar.add_cascade(label = ‘Language‘,menu = filemenu)
 69 # root[‘menu‘] = menubar
 70 # root.mainloop()
 71 #程序运行，使用了Checkbutton，并通过printItem将每个Checkbutton在当前值打印出来。
 72
 73
 74
 75 # ‘‘‘4.向菜单 中添加Radiobutton项‘‘‘
 76 #
 77 # root = Tk()
 78 #
 79 # menubar = Menu(root)
 80 # vLang = StringVar()
 81 # #每次打印出当前选中的语言
 82 # def printItem():
 83 #     print (‘vLang = ‘),vLang.get()
 84 # filemenu = Menu(menubar,tearoff = 0)
 85 # for k in [‘Python‘,‘PHP‘,‘CPP‘,‘C‘,‘Java‘,‘JavaScript‘,‘VBScript‘]:
 86 #     #绑定变量与回调函数，指定的变量vLang将这几项划为一组
 87 #     filemenu.add_radiobutton(label = k,command = printItem,variable = vLang)
 88 # #将menubar的menu属性指定为filemenu，即filemenu为menubar的下拉菜单
 89 # menubar.add_cascade(label = ‘Language‘,menu = filemenu)
 90 # root[‘menu‘] = menubar
 91 # root.mainloop()
 92 # #程序每次打印出当前选中的语言
 93 # #与Checkbutton不同的是，同一个组内只有一个处于选中状态。
 94
 95
 96 ‘‘‘5.向菜单中添加分隔符‘‘‘
 97 # # -*- coding: cp936 -*-
 98 #
 99 # root = Tk()
100 # menubar = Menu(root)
101 #
102 # #每次打印出当前选中的语言
103 # def printItem():
104 #     print (‘add_separator‘)
105 #
106 # filemenu = Menu(menubar,tearoff = 0)
107 # for k in [‘Python‘,‘PHP‘,‘CPP‘,‘C‘,‘Java‘,‘JavaScript‘,‘VBScript‘]:
108 #     filemenu.add_command(label = k,command = printItem)
109 #     #将各个菜单项使用分隔符隔开
110 #     filemenu.add_separator()
111 # menubar.add_cascade(label = ‘Language‘,menu = filemenu)
112 # root[‘menu‘] = menubar
113 # root.mainloop()
114 # #分隔符将相关的菜单项进行分组，只是UI上的实现，程序上没有任何改变，它也不执行任何的命令
115
116
117
118 ‘‘‘ 6.将以上的例5中的菜单改为右击弹出菜单‘‘‘
119 #方法是通过绑定鼠标右键，每当点击时弹出这个菜单，去掉与root的关联
120 # -*- coding: cp936 -*-
121
122 # root = Tk()
123 # menubar = Menu(root)
124 #
125 # def printItem():
126 #     print (‘popup menu‘)
127 #
128 # filemenu = Menu(menubar,tearoff = 0)
129 # for k in [‘Python‘,‘PHP‘,‘CPP‘,‘C‘,‘Java‘,‘JavaScript‘,‘VBScript‘]:
130 #     filemenu.add_command(label = k,command = printItem)
131 #     filemenu.add_separator()
132 # menubar.add_cascade(label = ‘Language‘,menu = filemenu)
133 # #此时就不要将root的menu设置为menubar了
134 # #root[‘menu‘] = menubar
135 # def popup(event):
136 #     #显示菜单
137 #     #这里设置右键点击显示菜单
138 #     menubar.post(event.x_root,event.y_root)
139 # #在这里相应鼠标的右键事件，右击时调用popup,此时与菜单绑定的是root，可以设置为其它的控件，在绑定的控件上右击就可以弹出菜单
140 # root.bind(‘<Button-3>‘,popup)
141 # root.mainloop()
142 # #运行测试一个，可以看到各个菜单 项的功能都是可以使用的，所以弹出菜单与一般的菜单功能是一样的，只是弹出的方式不同而已。
143
144
145
146 ‘‘‘ 7.以下的代码演示了菜单项的操作方法，包括添加各种菜单项，删除一个或多个菜单项‘‘‘
147 # -*- coding: cp936 -*-
148
149 root = Tk()
150 menubar = Menu(root)
151
152 def printItem():
153     print (‘add_separator‘)
154
155 filemenu = Menu(menubar,tearoff = 0)
156 for k in range(5):
157     filemenu.add_command(label = str(k),command = printItem)
158 menubar.add_cascade(label = ‘Language‘,menu = filemenu)
159
160 ‘‘‘以下为向菜单中添加项的操作‘‘‘
161 #在索引1添加一菜单command项
162 filemenu.insert_command(1,label = ‘1000‘,command = printItem)
163 #在索引2添加一菜单checkbutton项
164 filemenu.insert_checkbutton(2,label = ‘2000‘,command = printItem)
165 #在索引3添加一菜单radiobutton项
166 filemenu.insert_radiobutton(3,label = ‘3000‘,command = printItem)
167 #将新添加的菜单项使用分隔符隔开
168 filemenu.insert_separator(1)
169 filemenu.insert_separator(5)
170
171 ‘‘‘以下为删除菜单项的操作‘‘‘
172 #删除索引6-9的菜单项
173 #这两个参数是控制删除下拉列表的位置的
174 filemenu.delete(4,9)
175 #删除索引为0的菜单项
176 filemenu.delete(0)
177
178 root[‘menu‘] = menubar
179 root.mainloop()
180 #分隔符将相关的菜单项进行分组，只是UI上的实现，程序上没有任何改变，它也不执行任何的命令

 1 #coding=gbk
 2 ‘‘‘1.一个简单的Checkbutton例子‘‘‘
 3 #创建一个Checkbutton,显示文本为"python"
 4 from tkinter import *
 5 # root = Tk()
 6 # Checkbutton(root,text = ‘python‘).pack()
 7 # root.mainloop()
 8
 9
10 ‘‘‘2.设置Checkbutton的回调函数‘‘‘
11 # def callCheckbutton():
12 #     print (‘you check this button‘)
13 # root = Tk()
14 # Checkbutton(root,text = ‘check python‘,command = callCheckbutton).pack()
15 # root.mainloop()
16 # #不管Checkbutton的状态如何，此回调函数都会被调用
17
18
19 ‘‘‘3.通过回调函数改变Checkbutton的显示文本text的值‘‘‘
20
21 # def callCheckbutton():
22 #     #改变v的值，即改变Checkbutton的显示值
23 #     v.set(‘check Tkinter‘)
24 #
25 # root = Tk()
26 # v = StringVar()
27 # v.set(‘check python‘)
28 # #绑定v到Checkbutton的属性textvariable
29 # Checkbutton(root,text = ‘check python‘,textvariable = v,command = callCheckbutton).pack()
30 #
31 # root.mainloop()
32
33
34 ‘‘‘4.上述的textvariable使用方法与Button的用法完全相同，使用此例是为了区别Checkbutton的另外的一个属性variable,此属性与textvariable不同，它是与这个控件本身绑定，Checkbutton自己有值：On和Off值，缺省状态On为1，Off为0，如：‘‘‘
35 # #显示Checkbutton的值
36 # root = Tk()
37 # #将一整数与Checkbutton的值绑定，每次点击Checkbutton，将打印出当前的值
38 # v = IntVar()
39 # def callCheckbutton():
40 #     print (v.get())
41 # Checkbutton(root,
42 #             variable = v,
43 #             text = ‘checkbutton value‘,
44 #             command = callCheckbutton).pack()
45 # root.mainloop()
46
47
48 ‘‘‘5.Checkbutton的值不仅仅是1或0，可以是其他类型的数值，可以通过onvalue和offvalue属性设置Checkbutton的状态值，如下代码将On设置为‘python‘,Off值设置为‘Tkinter‘，程序的打印值将不再是0或1，而是‘Tkinter’或‘python’‘‘‘
49 # root = Tk()
50 # #将一字符串与Checkbutton的值绑定，每次点击Checkbutton，将打印出当前的值
51 # v = StringVar()
52 # def callCheckbutton():
53 #     print (v.get())
54 # Checkbutton(root,
55 #             variable = v,
56 #             text = ‘checkbutton value‘,
57 #             onvalue = ‘python‘,        #设置On的值
58 #             offvalue = ‘tkinter‘,    #设置Off的值
59 #             command = callCheckbutton).pack()
60 # root.mainloop()
61
62 # 6.还有其他的属性fg/bg/relief/width/height/justify/state使用方法与Button相同，不再举例。

 1 #coding=gbk
 2 ‘‘‘1.创建一个简单的Radiobutton‘‘‘
 3 from tkinter import *
 4 # root = Tk()
 5 # Radiobutton(root,text = ‘python‘).pack()
 6 # Radiobutton(root,text = ‘tkinter‘).pack()
 7 # Radiobutton(root,text = ‘widget‘).pack()
 8 # root.mainloop()
 9 # #不指定绑定变量，每个Radiobutton自成一组
10
11
12 ‘‘‘2.创建一个Radiobutton组，使用绑定变量来设置选中哦的按钮‘‘‘
13 # root = Tk()
14 # #创建一个Radiobutton组，创建三个Radiobutton，并绑定到整型变量v
15 # #选中value=1的按钮
16 # v = IntVar()
17 # v.set(1)
18 # for i in range(3):
19 #     Radiobutton(root,variable = v,text = ‘python‘,value = i).pack()
20 # root.mainloop()
21
22
23 ‘‘‘3.创建两个不同的组‘‘‘
24 # root = Tk()
25 # vLang = IntVar()
26 # vOS = IntVar()
27 # vLang.set(1)
28 # vOS.set(2)
29 #
30 # for v in [vLang,vOS]:    #创建两个组
31 #     for i in range(3):    #每个组含有3个按钮
32 #         Radiobutton(root,
33 #                     variable = v,
34 #                     value = i,
35 #                     text = ‘python‘ + str(i)
36 #                     ).pack()
37 # root.mainloop()
38 # #不同的组，各个按钮互不影响。
39
40
41
42 ‘‘‘4.如果同一个组中的按钮使用相同的alue，则这两个按钮的工作方式完全相同‘‘‘
43
44 root = Tk()
45 v = IntVar()
46 v.set(1)
47 for i in range(3):
48     Radiobutton(root,
49                 variable = v,
50                 value = 1,
51                 text = ‘python‘ + str(i)
52                 ).pack()
53 for i in range(3):
54     Radiobutton(root,
55                     variable = v,
56                     value = i,
57                     text = ‘python‘ + str(2 + i)
58                     ).pack()
59 root.mainloop()
60 #上述的例子中共有4个alue为1的值，当选中其中的一个时，其他三个也会被选中；选中除了这四个只外的按钮时，四个按钮全部取消
61
62
63 ‘‘‘5.与Checkbutton类似，每个Radiobutton可以有自己的处理函数，每当点击按钮时，系统会调用相应的处理函数‘‘‘
64 # -*- coding: cp936 -*-
65
66 # root = Tk()
67 # v = IntVar()
68 # v.set(0)
69 # def r1():
70 #     print (‘call r1‘)
71 # def r2():
72 #     print (‘call r2‘)
73 # def r3():
74 #     print (‘call r3‘)
75 # def r4():
76 #     print (‘call r4‘)
77 # i = 0
78 # #创建8个按钮，其中两个两个的value值相同
79 # for r in [r1,r2,r3,r4]:
80 #     Radiobutton(root,
81 #                     variable = v,
82 #                     text = ‘radio button‘,
83 #                     value = i,
84 #                     command = r
85 #                     ).pack()
86 #     Radiobutton(root,
87 #                     variable = v,
88 #                     text = ‘radio button‘,
89 #                     value = i,
90 #                     command = r
91 #                     ).pack()
92 #     i += 1
93 #
94 # root.mainloop()
95 # #注意虽然同时可以选中两个按钮，但每次点击按钮，执行的代码只有一次

  1 ‘‘‘1.创建一个Listbox，向其中添加三个item‘‘‘
  2 from Tkinter import *
  3 root = Tk()
  4 lb = Listbox(root)
  5 for item in [‘python‘,‘tkinter‘,‘widget‘]:
  6     lb.insert(END,item)
  7 lb.pack()
  8 root.mainloop()
  9
 10 ‘‘‘2.创建一个可以多选的Listbox,使用属性selectmaod‘‘‘
 11 from Tkinter import *
 12 root = Tk()
 13 lb = Listbox(root,selectmode = MULTIPLE)
 14 for item in [‘python‘,‘tkinter‘,‘widget‘]:
 15     lb.insert(END,item)
 16 lb.pack()
 17 root.mainloop()
 18 # 依次点击这三个item，均显示为选中状态。
 19 # 属性MULTIPLE允许多选，每次点击item，它将改变自己的当前选状态，与Checkbox有点相似
 20
 21 ‘‘‘3这个属性selectmode还可以设置为BROWSE,可以通过鼠标来移动Listbox中的选中位置（不是移动item），这个属性也是Listbox在默认设置的值，这个程序与1.程序运行的结果的一样的。‘‘‘
 22 from Tkinter import *
 23 root = Tk()
 24 lb = Listbox(root,selectmode = BROWSE)
 25 for item in [‘python‘,‘tkinter‘,‘widget‘]:
 26     lb.insert(END,item)
 27 lb.pack()
 28 root.mainloop()
 29 #使用鼠标进行拖动，可以看到选中的位置随之变化。
 30 # 与BROWSE相似 的为SINGLE，但不支持鼠标移动选中位置。
 31 from Tkinter import *
 32 root = Tk()
 33 lb = Listbox(root,selectmode = BROWSE)
 34 for item in [‘python‘,‘tkinter‘,‘widget‘]:
 35     lb.insert(END,item)
 36 lb.pack()
 37 root.mainloop()
 38 #使用鼠标进行拖动,没有任何变化
 39 ‘‘‘4.使用selectmode  = EXPANDED使用Listbox来支持Shift和Control。‘‘‘
 40 from Tkinter import *
 41 root = Tk()
 42 lb = Listbox(root,selectmode = EXTENDED)
 43 for item in [‘python‘,‘tkinter‘,‘widget‘]:
 44     lb.insert(END,item)
 45 lb.pack()
 46 root.mainloop()
 47 #运行程序，点中“python"，shift + 点击"widget"，会选中所有的item
 48 #运行程序，点中"python"，control + 点击"widget"，会选中python和widget，第二项tkinter处于非选中状态
 49
 50 ‘‘‘5.向Listbox中添加一个item‘‘‘
 51 # 以上的例子均使用了insert来向Listbox中添加 一个item，这个函数有两个属性一个为添加的索引值，另一个为添加的项(item)
 52 #  有两个特殊的值ACTIVE和END，ACTIVE是向当前选中的item前插入一个（即使用当前选中的索引作为插入位置）；END是向
 53 #  Listbox的最后一项添加插入一项
 54 # 先向Listbox中追加三个item，再在Listbox开始添加三项
 55 from Tkinter import *
 56 root = Tk()
 57 lb = Listbox(root)
 58 for item in [‘python‘,‘tkinter‘,‘widget‘]:
 59     lb.insert(END,item)
 60 #只添加一项将[]作为一个item
 61 #lb.insert(0,[‘linux‘,‘windows‘,‘unix‘])
 62 #添加三项，每个string为一个item
 63 lb.insert(0,‘linux‘,‘windows‘,‘unix‘)
 64 lb.pack()
 65 root.mainloop()
 66 ‘‘‘6.删除Listbox中的项，使用delete，这个函数也有两个参数，第一个为开始的索引值；第二个为结束的索引值，如果不指定则只删除第一个索引项。‘‘‘
 67 from Tkinter import *
 68 root = Tk()
 69 lb = Listbox(root)
 70 for i in range(10):
 71     lb.insert(END,str(i))
 72 lb.delete(1,3)
 73 lb.pack()
 74 root.mainloop()
 75 #运行程序，只有值0456789,1-3被删除
 76 #删除全部内容,使用delete指定第一个索引值0和最后一个参数END，即可
 77 #lb.delete(0,END)
 78 ‘‘‘7.选中操作函数，使用函数实现。selection_set函数有两个参数第一个为开始的索引；第二个为结束的索引，如果不指定则只选中第一个参数指定的索引项‘‘‘
 79 from Tkinter import *
 80 root = Tk()
 81 lb = Listbox(root)
 82 for i in range(10):
 83     lb.insert(END,str(i))
 84 lb.selection_set(0,10)
 85 lb.pack()
 86 root.mainloop()
 87 #  程序运行结果，选中了所有的项。 此代码并未指定Listbox为MULTIPLE或EXTENDED，查通过selection_set仍旧可以对Listbox
 88 #进行操作。
 89
 90 #与之相对的便是取消选中的函数了，参数与selection_set在参数相同，如下代码取消索引从0－3在状态
 91 from Tkinter import *
 92 root = Tk()
 93 lb = Listbox(root)
 94 for i in range(10):
 95     lb.insert(END,str(i))
 96 lb.selection_set(0,10)
 97 lb.selection_clear(0,3)
 98 lb.pack()
 99 root.mainloop()
100
101 ‘‘‘8.得到当前Listbox中的item个数‘‘‘
102 from Tkinter import *
103 root = Tk()
104 lb = Listbox(root)
105 for i in range(10):
106     lb.insert(END,str(i))
107 lb.delete(3)
108 print lb.size()
109 lb.pack()
110 root.mainloop()
111 #首先向Listbox中添加 了10个item,然后删除索引为3在item,最后的打印结果为9，即当前的Listbox中只有9项
112
113 ‘‘‘9.返回指定索引的项‘‘‘
114 from Tkinter import *
115 root = Tk()
116 lb = Listbox(root)
117 for i in range(10):
118     lb.insert(END,str(i*100))
119 print lb.get(3)
120 lb.pack()
121 root.mainloop()
122 #返回值为300
123 #get也为两个参数的函数，可以返回多个项(item)，如下返回索引值3－7的值
124 from Tkinter import *
125 root = Tk()
126 lb = Listbox(root)
127 for i in range(10):
128     lb.insert(END,str(i*100))
129 print lb.get(3,7)
130 lb.pack()
131 root.mainloop()
132 #返回值为(‘300‘, ‘400‘, ‘500‘, ‘600‘, ‘700‘)，是一个tuple类型。
133
134 ‘‘‘10.返回当前返回的项的索引，不是item的值‘‘‘
135 from Tkinter import *
136 root = Tk()
137 lb = Listbox(root)
138 for i in range(10):
139     lb.insert(END,str(i*100))
140 lb.selection_set(3,8)
141 print lb.curselection()
142 lb.pack()
143 root.mainloop()
144 #返回值为(‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘)，而不是(‘300‘,‘400‘,‘500‘,‘600‘,‘700‘,‘800‘)，哑然无法直接得到各项的值，知道了索引，得到值
145 #就很容易了:lb.get()就可以实现。
146
147 ‘‘‘11.判断 一个项是否被选中，使用索引。‘‘‘
148 from Tkinter import *
149 root = Tk()
150 lb = Listbox(root)
151 for i in range(10):
152     lb.insert(END,str(i*100))
153 lb.selection_set(3,8)
154 print lb.selection_includes(8)
155 print lb.selection_includes(0)
156
157 lb.pack()
158 root.mainloop()
159 #返回结果：True Flase，即8包含在选中的索引中，0不包含在选中的索引中
160
161 ‘‘‘12.Listbox与变量绑定‘‘‘
162 # -*- coding: cp936 -*-
163 from Tkinter import *
164 root = Tk()
165 v = StringVar()
166 lb = Listbox(root,listvariable = v)
167 for i in range(10):
168     lb.insert(END,str(i*100))
169 #打印当前列表中的项值
170 print v.get()
171 #输出：(‘0‘, ‘100‘, ‘200‘, ‘300‘, ‘400‘, ‘500‘, ‘600‘, ‘700‘, ‘800‘, ‘900‘)
172 #改变v的值,使用tuple可以与item对应
173 v.set((‘1000‘,‘200‘))
174 #结果只有两项了1000和200
175 lb.pack()
176 root.mainloop()
177
178 ‘‘‘13.Listbox与事件绑定‘‘‘
179 #  它不支持command属性来设置回调函数了，使用bind来指定回调函数,打印当前选中的值
180 # -*- coding: cp936 -*-
181 from Tkinter import *
182 root = Tk()
183 def printList(event):
184     print lb.get(lb.curselection())
185 lb = Listbox(root)
186 lb.bind(‘<Double-Button-1>‘,printList)
187 for i in range(10):
188     lb.insert(END,str(i*100))
189 lb.pack()
190 root.mainloop()
191
192 #还有一个比较实用的功能没有介绍：滚动条的添加，留到后面介绍Scrollbar的时候再一并介绍

 1 ‘‘‘1.创建简单的Toplevel‘‘‘
 2 # -*- coding: cp936 -*-
 3 from Tkinter import *
 4 root = Tk()
 5 tl = Toplevel()
 6 #为了区别root和tl，我们向tl中添加了一个Label
 7 Label(tl,text = ‘hello label‘).pack()
 8 root.mainloop()
 9 #运行结果生成了两个窗体，一个是root启动的，另一个则是Toplevel创建的，它包含有一个label;关闭tl
10 #则没有退出程序，Tk仍旧工作；若关闭Tk，整个Tk结束tl也结束，它不能单独存在。
11
12 ‘‘‘2.设置Toplevel的属性‘‘‘
13 #title设置标题
14 #geometry设置宽和高
15 # -*- coding: cp936 -*-
16 from Tkinter import *
17 root = Tk()
18 tl = Toplevel()
19 #设置tl的title
20 tl.title(‘hello Toplevel‘)
21 #设置tl在宽和高
22 tl.geometry(‘400x300‘)
23 #为了区别root和tl，我们向tl中添加了一个Label
24 Label(tl,text = ‘hello label‘).pack()
25 root.mainloop()
26
27 ‘‘‘3.使用Toplevel自己制作提示框‘‘‘
28 # -*- coding: cp936 -*-
29 from Tkinter import *
30 root = Tk()
31 mbYes,mbYesNo,mbYesNoCancel,mbYesNoAbort = 0,1,2,4
32 #定义一个消息对话框，依据传入的参数不同，弹出不同的提示信息
33 def MessageBox(): #没有使用使用参数
34         mbType = mbYesNo
35     textShow = ‘Yes‘
36     if mbType == mbYes:
37         textShow = ‘Yes‘
38     elif mbType == mbYesNo:
39         textShow = ‘YesNo‘
40     elif mbType == mbYesNoCancel:
41         textShow = ‘YesNoCancel‘
42     elif mbType == mbYesNoAbort:
43         textShow = ‘YesNoAbort‘
44     tl = Toplevel(height = 200,width = 400)
45     Label(tl,text = textShow).pack()
46 #由Button来启动这个消息框，因为它使用了空的回调函数，故MessageBox改为了无参数形式，使用了固定
47 #值mbYesNo
48 Button(root,text = ‘click me‘,command = MessageBox).pack()
49 root.mainloop()