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!。

字串相關的資料：

python 字串相加 http://www.cnblogs.com/wanpython/p/3250536.html
python字串比較 http://www.cnblogs.com/wanpython/p/3250533.html
python字串替換 http://www.cnblogs.com/wanpython/p/3250528.html
python字串擷取 http://www.cnblogs.com/wanpython/p/3250524.html
python字串連線 http://www.cnblogs.com/wanpython/p/3250521.html
python 字串相加 http://www.cnblogs.com/wanpython/p/3250536.html
python 字串比較 http://www.cnblogs.com/wanpython/p/3250533.html
python 字串替換 http://www.cnblogs.com/wanpython/p/3250528.html

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

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的基礎 上把字串轉換為數字返回（如果你輸入[email protected]#$$怎麼辦？自己試試看）。我們就利用這兩個輸入函式來作一些有趣的事情。

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()，然後你給出的輸入是一個無法轉換為數字的字串了，那麼我們就要來處理它。

python具有非常豐富的資料型別，
包括字串，列表，元組，字典集合等，每種資料型別的特點都大一樣，好好利用他們
可以讓你的python程式設計變的非常輕鬆，要好好利用就應該充分了解他們的特點，下面對他們的特點進行一些總結。

python字串：
字串在python中是一個單個字元的字串的序列，可以對字串進行切片連線等相關操作。
下面是關於python字串的一些文章：
python 字串替換
python字串連線

python列表：
列表是一個任意資料型別組成的有序集合，有點像其它語言的陣列，如果用過其它語言的朋友相信對它不會陌生，列表的操作非常
豐富，可以用dir來檢視他自帶的方法。
下面是關於python列表的一些文章：
python列表
python列表操作方法

python元組：
python元組和列表一樣都是有序序列，所不同的是元組是不可變的型別，經常用在系統配置檔案裡，作為系統的配置資訊，比較安全和穩定，不容易輕易被改變。
下面是python元組的一些文章：
python 元組

python字典：
字典是python物件中唯一的對映的型別，和數學的對映的關係差不多，其它的語言也有大概的資料型別，自帶的方法也很多
下面是python字典的一些文章：
python 字典：
python 字典 新增

python集合：
python集合在其它的語言好像比較少見，做一些中間處理還是非常好的
下面是python集合的一些文章：
python 集合

下面是一些朋友總結的。

共同點：
1、它們都是py的核心型別，是py語言自身的一部分。

核心型別與非核心型別
多數核心型別可通過特定語法來生成其物件，比如"spam"就是建立字串型別的物件的表示式；
非核心型別需要內建函式來建立，比如檔案型別需要呼叫內建函式open()來建立。
類也可以理解成自定義的非核心型別。

2、邊界檢查都不允許越界索引

3、索引方法都使用[]
s = 'spam'
print s[0]
s = ['s', 'p', 'a', 'm']
print s[0]
s = {'name':'bob', 'age':'12'}
print s['name']
s = ('s', 'p', 'a', 'm')
print s[0]

4大部分都支援迭代的協議

不同點：
1、有序性
字串、列表、元組是序列，元組可以理解成不可變的列表
字典是對映
序列才有有序性，字典沒有可靠的左右順序

2、可變性
字串、元組（還有數字）具有不可變性，即賦值後對應儲存空間的內容不可變，除非這個物件被銷燬。
列表、字典具有可變性

s = 'spam'
s = 'z' + s[1:]

第一行的s的指向的記憶體空間（比如地址0x000123）儲存了字串'spam'
第二行的s“變”成了'zpam'，但它只是重新指向了一個儲存著'zpam'字串的記憶體地址，原來0x000123出開始的記憶體空間可能還是一個'spam',直到系統來清理它。

3、序列操作
序列（字串、列表、元祖）支援，對映（字典）不支援
注意：序列操作生成的型別不變。

col = 'spam'
print col[1:]
#結果是pam

col = ['s', 'p', 'a', 'm']
print col[1:]
#結果是['p', 'a', 'm']

col = ('s', 'p', 'a', 'm')
print col[1:]
#結果是('p', 'a', 'm')


4、列表解析表示式
表示式中支援序列（字串、列表、元祖），貌似也支援對映（字典）。
注意：和序列操作不同的是，
列表解析表示式生成的只能是一個列表；
double = [c * 2 for c in 'spam']
print double
結果為['ss', 'pp', 'aa', 'mm']

L1 = [1, 2, 3]
L2 = [4, 5, 6]
L3 = [(a + b) for (a,b) in zip(L1, L2)]
print L3
#結果為[5, 7, 9]

tup = (1, 2, 3)
double = [c * 2 for c in tup]
print double
#結果為[2, 4, 6]

a = {'a':'zw','b':'ww'}
b = [i * 2 for i in a.items()]
print b
#結果為[('a','zw','a','zw'),('b','ww','b','ww')]


下 面一段程式碼似乎是列表解析表示式對字典的支援，對字典進行的迭代應該是對其keys的迭代，字典的items()、 keys()、values()方法都是返回的列表，所以，這裡的for i in a最好寫成for i in a.keys()，效果等同。總之，可以不追究列表解析表示式到底支不支援字典，本質上，列表解析表示式就是個對列表使用了迴圈結構，並生成新的列表的方 法。先這樣理解

a = {'a':'zw','b':'ww'}
b = [i * 2 for i in a]
print b
#結果為['aa', 'bb']

複製程式碼
5、巢狀
除了字串，列表、元組、字典可以相互多層次巢狀

#第一段
b = [1, 2, 3]
tup = (4, 5, b)
print tup[2]
#結果是[1, 2, 3]
b[0] = 'x'
print tup[2]
#結果是['x', 2, 3]


#第二段
b = '123'
tup = (4, 5, b)
print tup[2]
#結果是'123'
b = 'xxx'
print tup[2]
#結果仍然是'123'


有上面兩段可以看出，巢狀與可變性是不衝突的。
tup = (4, 5, b)中所記憶、錄入的b是個變數指標，或者叫記憶體地址，是個數字。
第一段，b指向一個列表，列表具有可變性，所以b[0] = 'x'的操作後，所以對元祖的索引能體現出變化；
第二段，b指向一個字串，字串具有不可變性，所以b = 'xxx'的操作後，b這個指標本身就改變了，重指向另一段記憶體空間，而tup元組中記憶的記憶體地址（那個曾經的b）所指空間並沒有變，還是字串'123'。
所以，不管是第一段還是第二段，元組tup始終保持不可變性，要變化也是其元素作為指標所指向記憶體的變化。

總結：python資料型別最重要的就是理解好可變性和不可變性，相信理解好了可以減少很多錯誤和少走一些彎路！

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://[email protected]


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.


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，就能一直得到當前輸入框的內容。當你能夠完整的把這個例子看懂的時候，你已經入門了。但是離自己寫一個有視窗的應用程式還有一定距離。主要是缺 少更加豐富的控制元件和事件響應的處理能力，以及合理排版佈局的能力。這個下次再說