Tkinter 布局管理器：pack

小甲鱼

萌萌哒 发表于 2015-5-25 18:42
Python还在更新吗？

更新的~

小甲鱼

delphi369 发表于 2015-5-25 21:27
小甲鱼的PYTHON既全面又权威！太感谢了！

谢谢哥们长期支持~

小甲鱼

Python3 将以下代码的 Tkinter 替换成 tkinter 即可：

1. """
   
2. This recipe describes how to handle asynchronous I/O in an environment where
   
3. you are running Tkinter as the graphical user interface. Tkinter is safe
   
4. to use as long as all the graphics commands are handled in a single thread.
   
5. Since it is more efficient to make I/O channels to block and wait for something
   
6. to happen rather than poll at regular intervals, we want I/O to be handled
   
7. in separate threads. These can communicate in a threasafe way with the main,
   
8. GUI-oriented process through one or several queues. In this solution the GUI
   
9. still has to make a poll at a reasonable interval, to check if there is
   
10. something in the queue that needs processing. Other solutions are possible,
    
11. but they add a lot of complexity to the application.
    
12. 
    
13. Created by Jacob Hallén, AB Strakt, Sweden. 2001-10-17
    
14. """
    
15. import Tkinter
    
16. import time
    
17. import threading
    
18. import random
    
19. import Queue
    
20. 
    
21. class GuiPart:
    
22.     def __init__(self, master, queue, endCommand):
    
23.         self.queue = queue
    
24.         # Set up the GUI
    
25.         console = Tkinter.Button(master, text='Done', command=endCommand)
    
26.         console.pack()
    
27.         # Add more GUI stuff here
    
28. 
    
29.     def processIncoming(self):
    
30.         """
    
31.         Handle all the messages currently in the queue (if any).
    
32.         """
    
33.         while self.queue.qsize():
    
34.             try:
    
35.                 msg = self.queue.get(0)
    
36.                 # Check contents of message and do what it says
    
37.                 # As a test, we simply print it
    
38.                 print msg
    
39.             except Queue.Empty:
    
40.                 pass
    
41. 
    
42. class ThreadedClient:
    
43.     """
    
44.     Launch the main part of the GUI and the worker thread. periodicCall and
    
45.     endApplication could reside in the GUI part, but putting them here
    
46.     means that you have all the thread controls in a single place.
    
47.     """
    
48.     def __init__(self, master):
    
49.         """
    
50.         Start the GUI and the asynchronous threads. We are in the main
    
51.         (original) thread of the application, which will later be used by
    
52.         the GUI. We spawn a new thread for the worker.
    
53.         """
    
54.         self.master = master
    
55. 
    
56.         # Create the queue
    
57.         self.queue = Queue.Queue()
    
58. 
    
59.         # Set up the GUI part
    
60.         self.gui = GuiPart(master, self.queue, self.endApplication)
    
61. 
    
62.         # Set up the thread to do asynchronous I/O
    
63.         # More can be made if necessary
    
64.         self.running = 1
    
65.             self.thread1 = threading.Thread(target=self.workerThread1)
    
66.         self.thread1.start()
    
67. 
    
68.         # Start the periodic call in the GUI to check if the queue contains
    
69.         # anything
    
70.         self.periodicCall()
    
71. 
    
72.     def periodicCall(self):
    
73.         """
    
74.         Check every 100 ms if there is something new in the queue.
    
75.         """
    
76.         self.gui.processIncoming()
    
77.         if not self.running:
    
78.             # This is the brutal stop of the system. You may want to do
    
79.             # some cleanup before actually shutting it down.
    
80.             import sys
    
81.             sys.exit(1)
    
82.         self.master.after(100, self.periodicCall)
    
83. 
    
84.     def workerThread1(self):
    
85.         """
    
86.         This is where we handle the asynchronous I/O. For example, it may be
    
87.         a 'select()'.
    
88.         One important thing to remember is that the thread has to yield
    
89.         control.
    
90.         """
    
91.         while self.running:
    
92.             # To simulate asynchronous I/O, we create a random number at
    
93.             # random intervals. Replace the following 2 lines with the real
    
94.             # thing.
    
95.             time.sleep(rand.random() * 0.3)
    
96.             msg = rand.random()
    
97.             self.queue.put(msg)
    
98. 
    
99.     def endApplication(self):
    
100.         self.running = 0
     
101. 
     
102. rand = random.Random()
     
103. root = Tkinter.Tk()
     
104. 
     
105. client = ThreadedClient(root)
     
106. root.mainloop()
     

复制代码