python之Tkinter

进行界面，首先少不了以下几个重要部分：
  窗体
  控件
  动作
窗体是容器，各式各样的控件放置在容器中，每种控件在触发之后都会执行一定的指令，即完成它的动作。
         怎样将控件绑定到一个命令上？一般来说在创建控件的时候，使用参数command来指定要执行的动作，这个动作可以使以下几类情况：
  普通函数
  同属于一个类的其他成员函数
  内置函数
  lamda函数
怎样创建窗口？一般来说有这么几种方法，一种是过程式的，使用Tk()。还有一种是面向对象式的，即：继承自Frame. Tk()返回的对象是根容器，Frame产生的对象可以放置在Tk()返回的对象中。
每个窗口在创建之后，使用pack对自己进行布局，并使自己可见。布局的方式可以使用expand、fill、side等。
控件对事件的绑定调用函数bind，第一个参数为表示事件的字符串，第二个为要执行的动作，动作的来源前面已经叙述。
下面为一些例子：
 
1. #!/usr/bin/python
2. 
3.  
4. 
5. from Tkinter import *
6. 
7.  
8. 
9. def quit():
10. 
11.          print "I have to leave now ..."
12. 
13.          import sys
14. 
15.          sys.exit()
16. 
17.  
18. 
19. b = Button(None,text="quit",bg="red",command=quit)
20. 
21. b.pack()
22. 
23. b.mainloop()
24. 
25.  
创建一个Button，点击后执行的动作为退出。
 
 
1. #!/usr/bin/python
2. 
3.  
4. 
5. from Tkinter import *
6. 
7.  
8. 
9. class ClassCall():
10. 
11.          def __init__(self):
12. 
13.                    self.msg="call from a class.\n"
14. 
15.          def __call__(self):
16. 
17.                    print self.msg
18. 
19.                    import sys
20. 
21.                    sys.exit()
22. 
23.  
24. 
25. widget = Button(None,text="test",command=ClassCall())
26. 
27. widget.pack()
28. 
29. widget.mainloop()

将一个类的实例指定为动作，默认时调用该类的__call__方法。
 
 
1. #!/usr/bin/python
2. 
3.  
4. 
5. from Tkinter import *
6. 
7.  
8. 
9. class InnerClass():
10. 
11.          def __init__(self):
12. 
13.                    self.b = Button(None,text="test",command = self.call)
14. 
15.                    self.b.pack()
16. 
17.          def call(self):
18. 
19.                    print "I am leaving now..."
20. 
21.                    import sys
22. 
23.                    sys.exit()
24. 
25.  
26. 
27. InnerClass()
28. 
29. mainloop()
30. 
31.  
调用同一个类内部的成员函数
 
1.  
2. 
3. #!/usr/bin/python
4. 
5.  
6. 
7. from Tkinter import *
8. 
9.  
10. 
11. class GuiDesign():
12. 
13.          def __init__(self,parent=None):
14. 
15.                    self.top = Frame(parent)
16. 
17.                    self.top.pack()
18. 
19.                    self.data = 0
20. 
21.                    self.layout()
22. 
23.                   
24. 
25.          def layout(self):
26. 
27.                    Button(self.top,text="exit",command=self.top.quit).pack(side = LEFT)
28. 
29.                    Button(self.top,text="hi",command=self.hi).pack(side = RIGHT)
30. 
31.  
32. 
33.          def hi(self):
34. 
35.                    self.data += 1
36. 
37.                    print "hi:%d" % self.data
38. 
39.  
40. 
41. frm = Frame()
42. 
43. frm.pack()         #easy to make mistake here.
44. 
45. Label(frm,text="hello").pack(side=TOP)
46. 
47. GuiDesign(frm).top.mainloop()
48. 
49.  
将Frame对象作为参数使用
 
 
1. #!/usr/bin/python
2. 
3.  
4. 
5. from Tkinter import *
6. 
7.     
8. 
9. def showPosEvent(event):
10. 
11.     print 'Widget=%s X=%s Y=%s' % (event.widget, event.x, event.y)
12. 
13.     print 'Got key perss:',event.char
14. 
15.  
16. 
17.     
18. 
19. tkroot = Tk()
20. 
21. labelfont = ('courier', 20, 'bold')               
22. 
23. widget = Label(tkroot, text='Hello bind world')
24. 
25. widget.config(bg='red', font=labelfont)           
26. 
27. widget.config(height=5, width=20)                 
28. 
29. widget.pack(expand=YES, fill=BOTH)
30. 
31.  
32. 
33. widget.bind('',  showPosEvent)            
34. 
35. widget.focus()                                  
36. 
37. tkroot.title('Click Me')
38. 
39. tkroot.mainloop()
响应按键事件，以及动态配置控件的方式