Python完全新手教程

轉載自http://www.cnblogs.com/taowen/articles/11239.aspx

作者：taowen, billrice

Lesson 1 准備好學習Python的環境
下載的地址是：
www.python.org
為了大家的方便，我在校內作了copy：
http://10.1.204.2/tool/compiler&IDE/Python-2.3.2-1.exe
linux版本的我就不說了，因為如果你能夠使用linux並安裝好說明你可以一切自己搞定的。

運行環境可以是linux或者是windows：
1、linux
redhat的linux安裝上去之后一定會有python的（必須的組件），在命令行中輸入python回車。這樣就可以進入一個
>>>的提示符
2、windows
安裝好了python之后，在開始菜單里面找到Python2.3->IDLE，運行也會進入一個有
>>>提示符的窗口

開始嘗試Python
1、輸入：
welcome = "Hello!"
回車
然后又回到了>>>
2、輸入：
print welcome
回車
然后就可以看到你自己輸入的問候了。

Lesson 2 搞定環境之后的前行
Python有一個交互式的命令行，大家已經看到了吧。所以可以比較方便的學習和嘗試，不用“新建－存檔－編譯－調試”，非常適合快速的嘗試。

一開始從變量開始（其實說變量，更准確的是對象，Python中什么都可以理解為對象）。

變量
welcome = "hello!"
welcome就是變量名，字符串就是變量的類型，hello!就是變量的內容，""表示這個變量是字符串，""中間的是字符串的內容。
熟悉其他語言的人，特別是編譯類型的語言，覺得沒有變量的聲明很奇怪。在python中用賦值來表示我要這么一個變量，即使你不知道要放什么內容，只是要先弄一個地方來放你的東西，也要這么寫：
store = ""
不過這個還是說明了store是字符串，因為""的緣故。

have a try

代碼:
tmp_storage = "" welcome = "hello!" tmp_storage = welcome print tmp_storage

你會發現同樣的問候出現了。

字符串
字符串是用""標記的，但是用''也可以（不要說你看不出一個是雙引號，一個是單引號），兩者之間是有一丁點區別，不過你可以不用理會。其實是差不多的。字符串有很多自己的操作，最常用的是這樣的：

代碼:
welcome = "hello" you = "world!" print welcome+you

運行之后就會發現她輸出了helloworld!。

更多變量
變量還有幾種類型。
數
字符串
列表
字典
文件
勿庸置疑，這些都是非常非常常用的。對於數字就不用講了那就是：

代碼:
radius = 10 pi = 3.14 area = pi*radius**2 print "the area is", area

下次講列表和字典

Lesson 3 Python中的數學結構
數學中你學什么東西最多遍？我想根據我的一點淺薄經驗（雖然我是數學系的），學得最多的是集合，無論什么數學書都從集合開始講起。然后講函數呢，又必然把映射再講一遍。可以說，集合和映射是數學中最基本的結構了。

Python對於數據結構非常明智的內置了兩個，回想我寫C的程序，往往是一開始就是用struct拼一個鏈表出來（重復勞動）。Python中提供了列表（list）和字典（dict）兩種數據結構。他們分別對應的原型是集合和映射。這個你應該明白了，只是表示方法有一點不一樣而已。

列表
列表的英文名是list嘛，所以我取一個名字叫

代碼:
my_list = [] 這個就產生了一個空的列表。然后給它賦值 my_list = [1,2] print my_list my_list.append(3) print my_list

非常容易明白的。append前面加了一個點，這個表示append是my_list方法。我實在不想又去給你解釋什么是對象，什么是成員方法，然后扯出一大段出來。
list是可以索引的：
print my_list[1]
不過你或許會不明白為什么是2，而不是顯示的是1。因為索引從0開始，要輸出第一個元素：
print my_list[0]

字典

代碼:
contact = {}

這個產生了一個空字典，contact。然后往里面填充內容：

代碼:
contact={} contact["name"]="taowen" contact["phone"]=68942443

name就是你查字典的時候要查找的單詞，taowen就是查到的內容。不過你現在不是查，而是在寫這個字典。同理添加了phone這個詞條。
現在添加好了，看看contact的內容，怎么查看？自己想辦法吧。。。
如果你悟性夠，就會發現python很多操作是通用的，既然能夠print 1, print "", print my_list，那么其他數據類型的變量就沒有理由不能用了。

結合列表和字典

代碼:
contact_list=[] contact1={} contact1['name']='taowen' contact1['phone']=68942443 contact_list.append(contact1) contact2={} contact2['name']='god' contact2['phone']=44448888 contact_list.append(contact2)

呵呵，夠復雜的吧。你可以想出我為什么要用兩個contact字典呢？。。。

Lesson 4 用不同的方式來操作Python
到現在為止，我們用的都是交互式的命令行來操作的，的卻是很方便，是吧？不過，復雜一些的情況就不那么好使了，來換一種方式來操作Python

在 IDLE中點擊File->New Window，出現一個新窗口（對於linux下，你要用vim或者emacs或者pico把文本的源文件寫好了）。為了方便，先點擊 File->Save，填入my_try.py。這樣能夠讓編輯器知道在編輯python的源文件，會把你輸入的代碼進行一點上色的處理。

填入下面的代碼：

代碼:
i = 5 n = 0 while i>0:     n = n + i     i = i - 1 print n

你 會發現輸入:之后，自動會給縮進。而且也沒有在python中發現和C/C++中類似的{}標記也沒有pascal中的begin end;，其實縮進就是python中表示一段代碼的從屬關系的標記方法。表示n=n+1和i=i-1這兩句都是while的。程序的運行邏輯應該不用解 釋了吧。就是運行5+4+3+2+1的結果。

運行代碼
按F5，可能提示你沒有存盤，照着辦就是了。
發揮你的能力，計算從1到10的所有偶數的和（提示，可能沒有你想象的那么智能）。

Lesson 5 Python中的輸入與判斷
健全的程序大凡都需要輸入的功能，所以要學習一下簡單的輸入：
輸 入要使用的是raw_input或者input函數，區別是raw_input直接把你的輸入作為字符串返回，而input則在raw_input的基礎 上把字符串轉換為數字返回（如果你輸入$@#$$怎么辦？自己試試看）。我們就利用這兩個輸入函數來作一些有趣的事情。

代碼:
your_name = raw_input("please input your name:") hint = "welcome! %s" % your_name print hint

不簡單吧，還有%呢。%s表示在這個位置插入一個字符串，%表示把后面提供的參數“推”入前面的字符串中，所以推的結果是把%s推出去了，把your_name給填入那個地方了。printf知道吧，C中的printf就是一樣的嘛。

代碼:
inputed_num = 0 while 1:     inputed_num = input("input a number between 1 and 10\n")     if inputed_num >= 10:         pass     elif inputed_num < 1:         pass     else:         break print "hehe, don't follow, won't out"

pass就是pass了，過了嘛，什么都不干了。break就是跳出這個while 1（無窮循環，1總是真的，while總是執行）。\n是換行，不會全部忘光了吧。

Lesson 6 Python余興節目

代碼:
from Tkinter import * root = Tk() w = Label(root, text="Hello, world!") w.pack() root.mainloop()

呵呵，一次太超前了一點，不過也不是解釋不清楚。我干脆也不解釋了吧。給大家增進一點興趣。

－－－－－－－－－
還是解釋一下
fromt Tkinter import *
是引入一個模塊，這個模塊用來創建GUI（Graphic User Interface）窗口
Tk()創建了一個主窗口
Label()創建一個標簽
Label的第一個參數是root表明Label是在這個主窗口中的。
w.pack()是指用缺省的方式把Label放置在主窗口中
root.mainloop()開始了一個循環，是等待你的輸入的循環。

Lesson 7 Python基本語法要素齊動員
現在的目的是盡量想出一個用的東西僅限於內置的變量類型和語句的一個綜合的例子，我想還是那個聯系人表的例子吧

代碼:

################ #呵呵，還忘記了講注釋 #第一個算是完整的程序 ################ contact = {} contact_list = [] while 1:     contact['name'] = raw_input("please input name: ")     contact['phone'] = raw_input("please input phone number: ")     contact_list.append(contact.copy())     go_on = raw_input("continue?\n")     if go_on == "yes":         pass     elif go_on == "no":         break     else:         print "you didn't say no\n" i = 1 for contact in contact_list:     print "%d: name=%s" % (i, contact['name'])     print "%d: phone=%s" % (i, contact['phone'])     i = i + 1

首先是回憶一下字符串
字符串既能夠用""也能夠用''。然后是很有特色的%操作，起到格式化字符串的作用，前面僅僅在字符串中有一個%s，現在有%d和%s兩個，分別代表插入十進制數值和字符串於%x標記的位置處。

然后是列表
列 表是順序的序列，用append在后面附加，也能構用索引值索引。所以我們完全可以用一個變量保存len(contact_list)得到的長度，然后一 個個的遍歷，不過這里展示了另外一種非常方便的方法。而且值得注意的是append()中的參數，我使用了contact.copy()，你可以嘗試着把 copy()給去掉，觀察結果你就知道了所謂的append是怎么干的了，特別是你對指針之類的東西很有感覺的話（但是在Python中是沒有指針這個概 念的）

再來看看字典
字典是鍵（key）和值（value）的對應組合成的無序的序列。所以你存的時候要指明鍵（name或者phone），而且取的時候也是一樣的。

接下來是判斷
if 是很好用的，==表示判斷兩個是否相等，=表示把右邊的賦給左邊的。而且可以直接判斷字符串是否相等，這個太方便了，如果你曾經用過strcpy()的 話，就知道了。elif是表示else if的意思，如果if不滿足就判斷elif的條件是否滿足，最后是到else中去。

循環是個主體
while 和for都是循環。不過這里while就沒什么說的了，又是很經典的while 1，死循環，然后必須在里面用break來跳出。for和C中的for是不一樣的，for in才是一個完整的語句，指的是從一個能夠逐一取值的序列中（比如list），一個一個的取出值賦給for后面指定的變量中，直到取空，循環結束。其實回 想一般用C中的for的經歷，也大體如此。而且你還可以用for i in range(1,100)來指定一個范圍從多少到多少。可以說for in充分體現了python的體貼周到，用起來很直觀，不會繞彎。

接下來就是運行了，大家慢慢調試吧。下次可能是講異常處理，因為我覺得在深入到使用各種高級的要素之前，先要學會怎么去處理異常。最常見的異常應該是input()，然后你給出的輸入是一個無法轉換為數字的字符串了，那么我們就要來處理它。

Lesson 8 Python中的錯誤檢測
寫 程序什么最重要？完成功能最重要。但是程序中難免要有用戶的輸入，對於這些寫的時候未可預知的因素中間可能出現的錯誤，一般稱作異常。對於異常情況的處 理，不同語言有不同的做法，比如檢查函數的返回值之類的，但是那種辦法會把代碼弄成一團漿糊。Python在這個方面是比較先進的，我們從一個例子來看 看：

代碼:
print input()

呵呵，看不同吧。其實input是輸入，print是輸出。也就是把輸入的東西立即輸出。但是這個和

代碼:
print raw_input()

有什么不同呢？
不同的地方是，input()會在raw_input()接收了“字符串”的輸入之后進行一些處理，比如你是輸入1+2，然后輸出的就是3了，而raw_input就是原原本本的1+2的輸出了。用代碼表示就是

代碼:
eval(raw_input())

eval是求表達式的值，任何一個簡單的python表達式，就像1+2這樣的作為字符串送入，就能把值從eval處理之后取出來。
現在你實驗一下"sdfsdf”之后，你會發現提示你

  引用:

Traceback (most recent call last):
  File "<pyshell#4>", line 1, in -toplevel-
    input()
  File "<string>", line 0, in -toplevel-
NameError: name 'sdfsdf' is not defined

如果輸入其他稀奇古怪的字符串還可能有其他的出錯提示，我們現在要做的就是捕捉這種由用戶輸入引起的錯誤。這么來作：

代碼:
try:     print input() except:     print 'there is an error in your input'

這下你無論怎么輸入都不會有什么其他的提示了，就是自己設定的print語句作為提示。現在把try except的組合去掉，回到print input()你再嘗試一下：
1/0
這個顯然是一個錯誤，被零除的錯誤。那么專門來捕捉一下這個錯誤：

代碼:
try:     print input() except ZeroDivisionError:     print 'can not be divided by zero'

這下你能夠捕捉到被零除的錯誤了。然后你再嘗試其他的輸入，可能錯誤就沒有被捕捉了。所以再補上：

代碼:
try:     print input() except ZeroDivisionError:     print 'can not be divided by zero' except:     print 'there is an error in your input'

注意，捕捉所有錯誤的except必須放在所有的except的最后一位。明白了？OK

還有更多的能夠捕捉的錯誤，自己查手冊吧（暫時看不了手冊沒關系，慢慢來嘛）。以后還能夠自己raise（引發）異常呢。不過那都是比較高級的應用了，對於出錯處理從一開始就有這個印象，並牢記在心中對於以后寫大一些的軟件很有好處。

Lesson 9 走向模塊化的第一步
大規模的程序設計需要你把一個大的程序拆分成n個模塊。然后把模塊進行組合，交互成為一個完整的程序。你不可能像現在這樣，從頂寫到尾。。。
那么我們從函數開始。

代碼:
def square(x):     return x**2 print square(5)

簡單吧，這個是我看過的函數定義中最簡潔的。def表示這個開始定義一個函數，x是參數，參數是不需要類型的，因為python是不需要明確指出類型的。return是返回值，返回的值插入到調用函數的地方。再復雜一些

代碼:
def multiply(a, b):     return a*b print multiply(1,2)

這是兩個參數的函數。那么返回兩個值呢？

代碼:
def swap(a, b):     return (b,a) print swap(1,2)

呵呵，其實這里返回的並不是兩個值，而是一個值。怎么說呢。(b, a)就是一個東西，是一個元組（turple），你可以用這樣的方式成生一個元組，並使用它。元組是基本的變量類型：

代碼:
my_turple = (1, 2, 3) my_list = [] for i in my_turple:     my_list.append(i) print my_list

其實元組和列表非常像，但是列表的長度是可以變化的，而且成員是可以改變的。但是元組是什么都不能變的，是只讀的。

對於高級一點的話題：傳遞進來的參數是否可以被修改，這個問題取決於你傳遞了什么近來。如果是數字或者字符串，是不能夠改變的，但是如果是這樣的：

代碼:
def test_func(list_be_passed):     list_be_passed[0] = 'towin' my_list = ['taowen'] print my_list test_func(my_list) print my_list

就能夠改變傳遞近來的參數了，所以處理的時候要小心，必要的時候copy一下再傳遞。

函數簡單吧，但是很好用的。想起C中的函數那么那么多麻煩，真是感慨萬千啊。下面是應該講GUI編程呢，還是面向對象呢？思考一下

Lesson 10 Python的文件操作
文件操作....是一個語言和外界聯系的主要方法....現在以txt為例簡單的講一下...



首先是建立關聯...假設在存在以下文件 c:\a.txt

代碼:
This is line #1 This is line #2 This is line #3 END

代碼:
>>> xxx = file('c:\\a.txt', 'r')

關鍵字的第一部分，是文件路徑及名稱。注意這里面，路徑需要用\\
第二部分，是對文件的模式或者叫權限，一般有以下3種 "r" (read)， "w" (write)和 "a"(append).



之后，就可以利用
xxx_content = infile.read()
xxx_content = infile.readlines()
來讀取文件內容了

代碼:
>>> xxx = file('c:\\a.txt', 'r') >>> xxx_content = xxx.read() >>> print xxx_content This is line #1 This is line #2 This is line #3 END >>> xxx.close() >>> >>> infile = file('c:\\a.txt', 'r') >>> xxx = file('c:\\a.txt', 'r') >>> for xxx_line in xxx.readlines():         print 'Line:', xxx_line         Line: This is line #1 Line: This is line #2 Line: This is line #3 Line: END >>> xxx.close() >>>

然后是文件的寫入

代碼:
>>> xxx=file('c:\\test.txt','w') >>> xxx.write('billrice') >>> xxx.write('testtest') >>> xxx.write('enter\n') >>> xxx.writelines(['billrice','ricerice']) >>> xxx.close() >>> >>> xxx=file('c:\\test.txt','r') >>> content=xxx.read() >>> print content billricetesttestenter billricericerice >>>

需要注意的是...在xxx.close()之前，c盤下面只有一個空空的test.txt，xxx.close()的作用相當於最后的存盤。

Lesson 11 走向模塊化的第二步
函數上面還能是什么呢？內嵌函數^_^，其實python是支持的。不過用起來會讓你吐血的，LGB名稱查找規則。。。（寒）。python是面向對象的，對於面向對象的支持挺好玩的。

代碼:
class person:     def __init__(self):         self.name = 'taowen'         self.id = 20022479     def say_id(self):         print "%s's id is %d" % (self.name, self.id) me = person() me.say_id()

比較復雜了吧。如果不熟悉面向對象的概念的，可能會覺得暈。我來解釋一下。所謂面向對象是把數據和操作數據的函數放到同一個類中去，然后用類來創建對象，操作的時候能夠比較方便（很不精確的說法，任何一個OO高手都可以把我罵得屁都不是）。

類
類是class關鍵來定義的。class person:就是說定義一個類，名字叫person。

對象
對象是用類來產生的。所以me就是對象，產生的辦法就是像調用函數一樣，person()，而且()中是能夠放參數的，什么時候要參數，看下面的“初始化函數“

初始化函數
類可以有自己的初始化函數，每次類被創建的時候（調用person()這樣的語句的時候），都會調用它。這個在C++中的名稱是構造函數。__init__是必須的名字，你不能用其他名字來當初始化函數。但是你可以沒有初始化函數。

類的數據
類的數據是所有類產生的對象共享的數據。這里沒有用到類的數據，要寫的話是這樣：

代碼:
class person:     school = 'bit'     def __init__(self):         self.name = 'taowen'         self.id = 20022479     def say_id(self):         print "%s's id is %d" % (self.name, self.id) me = person() me.say_id() print me.school

對象的數據
對象的數據是用
self.變量名 = 。。。
來生成的。這里self.name就是對象的數據。對象的數據和類的數據不同，因為對象之間的數據是互不共享的，而類的數據是被所有由類生成的對象共享的。

對象的函數（類的函數）
兩 個沒有區別，是類的就是對象的。其實就是類的（我說的是底層實現，不過不用管，如果關心怎么實現的，等我寫Hacking OO吧，還沒影呢）。say_id就是對象的函數，你能夠調用它。每個對象的函數都需要一個self參數，表示[color]這個對象[/color]。

為什么使用面向對象編程
除 去讓人覺得你比較專業外，當然由切實的好處。比較淺顯的是你能夠表達一定的層次關系，類與類之間能夠有包含和繼承的關系（當然你現在還不會。。。）。而且 對象能夠把數據和操作數據的函數放在一起，能夠比較清晰。雖然有所謂的數據隱藏的概念，但是在python中其實就是一個不要直接調用對象中的數據的 約定，而要用一個函數作為中轉。其實不懂面向對象很正常，其實有的時候就是要在用的中間感悟的。什么時候把用函數編程用牛了，用出個道道來了，說不定你已 經感覺到了什么是面向對象編程。另外：所謂什么OO，都是一些認為規定，不用語法支持，只要心中有這個想法（什么想法？自己悟啊），就能夠寫出OO的代碼，不管你用的是什么語言，什么語法。

Lesson 12 python to exe
about py2exe

本文講述如何將一個python源代碼編譯成一個exe.....我會的只是最初步最基本的.....實際上那個py2exe似乎有着更強大的功能

1：下載安裝py2exe.....from http://[e-mail]


2：假設你寫好了一個python程序....guess_number.py.......存在了c:\Python23\下面

3：再寫一個setup.py....也存在c:\Python23\下面......內容如下

代碼:
# setup.py from distutils.core import setup import py2exe setup(name="guess_number",       scripts=["guess_number.py"], )

其中name和scripts是需要你到時候具體修改的....

4：找到windows的dos模式（命令提示符）.....或者自己做個快捷方式也可以....
C:\Python23>
C:\Python23>python setup.py py2exe
構造就開始了....
幾秒鍾以后....
在你的C:\Python23就會出現兩個文件夾build和dist，前面那個里面似乎是源程序（這個我不太清楚）....dist里面的就是編譯好的.exe了.....ok....


btw....等國兩天有了實際應用再來翻譯這些東西

Specifying additional files
Some applications need additional files at runtime, this maybe configuration files, fonts, bitmaps, whatever.

py2exe can copy these files into subdirectories of dist\myscript if they are specified in the setup script with the data_files option. data_files should contain a sequence of (target-dir, files) tuples, where files is a sequence of files to be copied.

Here's an example:

代碼:
# setup.py from distutils.core import setup import glob import py2exe setup(name="myscript",       scripts=["myscript.py"],       data_files=[("bitmaps",                    ["bm/large.gif", "bm/small.gif"]),                   ("fonts",                    glob.glob("fonts\\*.fnt"))], )

This would create a subdirectory bitmaps in dist\myscript, containing the two bitmaps, and a subdirectory fonts, containing all the *.fnt files.



相關資料出處....
http://starship.python.net/crew/theller/py2exe/

Lesson 13 寫一個簡單的界面很容易
圖 形界面是非常有吸引力的東西。但是制作出來似乎不是那么容易，這個觀點對於用C來笨拙寫windows的窗口程序來說，是比較正確的。微軟公司出品的 windows是一個圖形界面的操作系統，這個和dos或者linux這些不一樣，他們一開始出來是針對字符界面的，然后再在上面加上一些庫來提供圖形的 功能。windows則不同，它是包含在自己的最原始的功能之中，而這些圖形功能的提供是在user32.dll這樣的system目錄下的dll文件中 以函數導出的形式提供的，但是要使用這些東西必須使用c語言的函數接口，而且編寫麻煩。有一個很大的wndproc中要填入所有的事件處理代碼，非常丑 陋。而作為腳本語言，所應該有的簡潔性，python對這個進行了封裝。但是事情不是如你所想象。中間過程非常復雜，而且python用的也不是自己的 庫，還是tcl的一個tk的庫再封裝了一次。雖然經過層層封裝，裹得非常嚴實，但是除了影響其在比較高性能的圖形場合下的應用之外，並沒有帶來太大的麻 煩。你能夠用很少的代碼，來完成其他語言+庫要很大行代碼才能表達的圖形樣式，雖然非常簡陋，不過足夠使用。而且python除了自己原包裝帶的這個 tkinter庫之外，還有其他的第三方的選擇，比較豐富，而且也有能夠勝任各種應用的選擇。甚至，還有opengl和directx的庫的封裝庫，能夠 用來編寫2d和3d的游戲，這個非常的誘人哦。但是我不會，

圖 形界面的奧秘其實並不深奧。我相信很多人學習windows編程都是從寫一個窗口開始的，而且都是從嘗試理解那個消息和事件驅動的模型入手的。大體的過程 是這樣的，窗口就是用象素畫出來的。你可以把一個窗口想象成一個窗口，也可以把窗口看成一堆象素的集合。就像有人說看女色不過是皮肉色相一樣。而且窗口中 的按鈕，編輯礦，各種圖標，無論是什么看起來像一個”物體“的東西，其實本質上都是有應用程序或者是庫或者是操作系統調用顯卡的驅動，通過顯卡的功能在屏 幕上繪畫一些點出來。而所謂的”物體“有很多稱法，在windows中一般成為控件（control）。

而對於圖形界面的操控一般是通過 鼠標和鍵盤來完成的。鼠標在屏幕上有一個自己的形象，那就是一個箭頭（當然你也可以調整這個圖形為其他好玩的東西，it is your freedom）。而鍵盤呢則一般表示為一個虛線的框，表示這個是鍵盤的”焦點“所在的地方。或者是編輯框中閃動的豎杠。這兩點中有一個共同點，就是都有 一個位置來確定要操作的對象。你點下鼠標的時候，你操作的就是鼠標的箭頭尖端指向的那個空間，而鍵盤按下也是在其焦點所在的控件那兒放聲。發生的是什么 呢？發生的過程從硬件層面到軟件層面之后，最終是被操作系統接收。操作系統能夠知道你是點擊的是鼠標還是鍵盤，在什么一個地方點下的，而且按下的是左鍵還 是右鍵。操作系統還知道當前窗口各處擺放的位置。綜合各路的信息，操作系統就能夠知道把這個”事件“作為”消息“發送給哪個窗口來處理。從中應該能夠明白 什么叫事件，而消息呢則是一個C中的結構體，其中有幾個field中間放了有關這個事件的信息，然后就像一封信一樣從操作系統投遞到了窗口所在的應用程 序。然后應用程序有一個事先注冊的”窗口過程“，其實就是一個函數，用來接收這封“信”。其實就是接收到傳過來的參數。然后再進行一些判斷，作出一定的響 應。這個就是所謂的事件驅動。在沒有冗長的代碼，和展示所有細節的情況下，如果你真的以前對這個過程一無所知，肯定會覺得非常茫然。這個一筆帶過的敘述其 實只是讓你有一個感性的認識。其實在python中使用窗口根本不用管諸葛么多。基本上只是把自己要的窗口和控件，給一些位置的參數，一些文字的提示內容 的參數就能把窗口擺好，顯示出來。然后再通過代碼告訴python，當“這個按鈕按下的時候執行這個函數”，然后就能讓窗口有響應。最后記得給一個退出窗 口的辦法就一切OK了。其中能省的復雜度基本上都被庫給隱藏掉了。付出的代價是慢一些，但是我就不相信你能感覺出來，除非你用的電腦連vcd都看不流暢。 所以大可放心的享受這種便利。

OK，下面來正式的看看怎么在python中創建一個窗口，然后顯示出來。

代碼:
from Tkinter import * root = Tk() root.mainloop()

就 3行就能夠把主窗口顯示出來了。root是一個變量名稱，其代表了這個主窗口。以后創建控件的時候指定控件創建在什么窗口之中，就要用這個root來表示 了。而Tk()是一個Tkinter庫之中的函數（其實是類的構造函數，構造了一個對象）。而mainloop則是主窗口的成員函數，也就是表示讓這個 root工作起來，開始接收鼠標的和鍵盤的操作。你現在就能夠通過鼠標縮放以及關閉這個窗口了。注意到窗口的標題是tk，我們可以進行一些修改

root= Tk(className='bitunion')

然后窗口的標題就變成了bitunion了。下面要作的是把這個窗口的內容填充一下，讓其有一些東西。先加入一個標簽，所謂標簽就是一行字。

代碼:
from Tkinter import * root = Tk(className='bitunion') label = Label(root) label['text'] = 'be on your own' label.pack() root.mainloop()

我 們很驚訝的發現窗口變小了，但是其中多了一行字。變小了是因為窗口中已經放了東西了，python的Tkinter非常智能，能夠根據內容自動縮放，而不 用和傳統的windows程序一樣，手工的指定絕對坐標了。對於label，它還是一個變量而已。不過這個變量代表了一個標簽，也就是那一行字。而這個 label的創建是用Label，而Label的參數是root表明了這個控件是root主窗口的成員控件，或者說是子窗口。label['text'] 表示設置這個標簽的text屬性為'be on your own'，也就是文字內容了。label.pack和root.mainloop一樣費解，但是內涵一樣深刻。你現在可以簡單理解為把label顯示出來 的功能，因為你把pack去掉，那你就看不到東西了。其實pack是和控件的布局排版有關西的。

再添加一個按鈕就能夠有更加豐富的內容了，方法是很類似的。看着吧：

代碼:
from Tkinter import * root = Tk(className='bitunion') label = Label(root) label['text'] = 'be on your own' label.pack() button = Button(root) button['text'] = 'change it' button.pack() root.mainloop()

只 不過把button替換了label而Button替換了Label。注意一下Button和Label這些都是Tkinter這些庫提供的，而 button和Button這樣大小寫之間的差別僅僅是巧合，你能夠隨便的給變量取名字，但是Button和Label這些則是需要記住的東西，寫代碼的 時候要經常用到的名字。但是點擊按鈕你會比較失望，因為並沒有什么反應。不過也是當然的事情，你並沒有告訴計算機對於這樣一個按鈕的點擊操作需要作出一個 什么樣的反應來反饋給用戶。而這個指定作出什么反應的工作只需要一個行，但是作出具體什么樣反應的描述則需要新建一個函數來進行處理。

代碼:
from Tkinter import * def on_click():     label['text'] = 'no way out' root = Tk(className='bitunion') label = Label(root) label['text'] = 'be on your own' label.pack() button = Button(root) button['text'] = 'change it' button['command'] = on_click button.pack() root.mainloop()

button['command'] = on_click表示對於button（按鈕）的點擊屬性用on_click這個函數來處理。而on_click函數也很簡潔，只是把label的文本重 新設置一下。這個完成了一個事件消息的處理，如果用C來寫，需要比這個長更加不好懂的寫法。另外你是否會對on_click中出現label這個變量比較 奇怪呢？明明在on_click前面沒有定義label這個變量啊。如果我在C中這么寫程序，編譯器一定會告訴我出錯的。而python是怎么知道 label這個變量存在，然后沒有報錯的呢？其實python在你寫的時候根本就不用知道其是否存在，只是要在運行的時候找得到label就可以了。而運 行的前后關系，是通過時間來關聯的而不是代碼上前后行的關系。這里由於label = Label(root)先於on_click執行，所以當on_click執行的時候，label就是一個已經定義的變量。如果沒有定義呢？那就報告出錯 嘍。

最后一個例子：

代碼:
from Tkinter import * def on_click():     label['text'] = text.get() root = Tk(className='bitunion') label = Label(root) label['text'] = 'be on your own' label.pack() text = StringVar() text.set('change to what?') entry = Entry(root) entry['textvariable'] = text entry.pack() button = Button(root) button['text'] = 'change it' button['command'] = on_click button.pack() root.mainloop()

這 個就比較復雜了。里面有一個StringVar。這個代表一個字符串，但是跟一般字符串不一樣。一般的這樣'dfsdf'的字符串是不可變的，你只能把變 量指定為不同的字符串，但是字符串本身的內容是不可改變的。而StringVar則是可變的字符串。所以了set和get來設置和取得其內容。主要是 entry（單行輸入框）要求一個這樣的屬性來設置和接收其輸入框的內容。一開始可能不習慣，但是用多了之后會覺得很方便的，因為只要用這個變量 text，就能一直得到當前輸入框的內容。當你能夠完整的把這個例子看懂的時候，你已經入門了。但是離自己寫一個有窗口的應用程序還有一定距離。主要是缺 少更加豐富的控件和事件響應的處理能力，以及合理排版布局的能力。這個下次再說