]]>
]]>
]]>
]]>
23、類屬性
1)類屬性是一個類的屬性，在創(chuàng)建任何類實例之前就有效了。類屬性既可以通過直接對類的引用，也可以通過對類的任意實例的引用來使用。
2)類屬性可以作為類級別的常量來使用，但是它們不是真正的常量，可以修改它們。
3)__class__ 是每個類實例的一個內(nèi)置屬性(也是每個類的),它是一個類的引用，而 self 是一個類的實例
24、私有
1)python有私有函數(shù)、私有類方法和私有屬性，它們不能被從模塊外（或類外）調(diào)用。
2)如果一個Python函數(shù)的名字，類方法，或?qū)傩砸詢蓚€下劃線開始(但不是結(jié)束)，它是私有的；其它所有的都是公有的。
3)Python沒有類方法保護的概念(只能用于它們自已的類和子父中)。類方法要不私有(只能在它們自已的類中使用)要不公有(任何地方都可使用)。
25、異常
1)一個 try...except ,try后面的塊是要監(jiān)聽的塊，有異常時執(zhí)行except后的塊。還可以有一條 else 子句，就象 if 語句。如果在 try 塊中沒有異常引發(fā)，然后 else 子句被執(zhí)行。
2)一個try ... finally，finally后的塊總被執(zhí)行。
26、文件對象
1)Python有一個內(nèi)置函數(shù)open，用來打開在磁盤上的文件。open 返回一個文件對象，它擁有一些方法和屬性，可以得到打開文件的信息，和對打開文件進行操作。
2)open 方法可以接收三個參數(shù)：文件名，模式，和緩沖區(qū)參數(shù)。只有第一個參數(shù)，文件名，是必須的；其它兩個是可選的。如果沒有指定，文件以文本方式打開。
3)文件對象的mode屬性，標(biāo)明文件屬性以何種方式被打開
4)文件對象的 name 屬性標(biāo)明文件對象所打開的文件名。
5)文件對象的 tell 方法指明在打開文件中的當(dāng)前位置
6)文件對象的 seek 方法在打開文件中移動到另一個位置。第二個參數(shù)指出第一個參數(shù)是什么意思：0 表示移動到一個絕對位置(從文件開始算起)，1 表示移到一個相對位置(從當(dāng)前位置算起)，還有 2 表示對于文件尾的一個相對位置。
7)read 方法從打開文件中讀取指定個數(shù)的字節(jié)，并且返回含有讀取數(shù)據(jù)的字符串。可選參數(shù)指定了讀取的最大字節(jié)數(shù)。如果沒有指定參數(shù)，read 將讀到文件末尾。
8)文件對象的 closed 屬性表示對象是否打開或關(guān)閉了文件
9)調(diào)用文件對象的 close 方法來關(guān)閉一個文件，以釋放掉你加在文件上的鎖(如果有的話)，刷新被緩沖的系統(tǒng)確實還未寫入的輸出(如果有的話)，并且翻放系統(tǒng)資源。closed 屬性證實了文件被關(guān)閉了。
10)當(dāng)文件被關(guān)閉后，文件對象所對應(yīng)的變量仍然存在，直到超出作用域，或被刪除，此時所有的對文件的操作（close除外）都會拋出異常，close只是靜靜地失敗。
27、python有for循環(huán)
28、賦值
1)使用一個序列或列表一次給多個變量賦值，如下例
>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v
>>> (x, y, z) = range(3)
2)內(nèi)置函數(shù)range接受一個表示上限的參數(shù)，返回一個從0開始的整數(shù)列表。
3)如果一個函數(shù)返回一個序列或列表，則可將它組賦值給一組變量，就象函數(shù)一次返回一組值一樣。如：
>>> (filepath, filename) = os.path.split("/music/ap/mahadeva.mp3")
>>> (shortname, extension) = os.path.splitext(filename)
]]>
20、定義類
以FileInfo類的定義為例
from UserDict import UserDict
class FileInfo(UserDict):
"store file metadata"
def __init__(self, filename=None):
UserDict.__init__(self)
self["name"] = filename
1)父類放在類名后的小括號內(nèi)；
2)類可以有文檔字符串
3)__init__函數(shù)在對象被創(chuàng)建后被自動調(diào)用的第一個函數(shù)，可以指定任何個數(shù)的參數(shù)。
4)慣例，__init__應(yīng)為類中第一個定義的方法，其第一個參數(shù)指向類的當(dāng)前實例的第一個引用，且應(yīng)命之為self。__init__中要顯式地調(diào)用父類的__init__方法。
5)__init__無返回值。
6)__init__的定義是可選的，一旦定義必須顯式調(diào)用父類的__init__方法。
7)除了可自由定義的普通的類方法，還有一些可以定義的專用方法。專用方法是在特殊情況下或當(dāng)使用特別語法時由Python替你調(diào)用的，而不是在代碼中直接調(diào)用(象普通的方法那樣)。也就是說，python提供了一種方法，可以將非方法調(diào)用語法映射到方法調(diào)用上。最常見是__getitem__和__setitem__方法。例如，在上例中增加兩個方法的定義，就可以實現(xiàn)方便的取值和賦值：
def __getitem__(self, key): return self.data[key]
def __setitem__(self, key, item): self.data[key] = item
>f = fileinfo.FileInfo("/music/_singles/kairo.mp3")
>f[“name”]
>f[“anothername”]=...
8)__repr__專用函數(shù)，返回一個對象的字符串表示。Python用內(nèi)置函數(shù)repr來顯示變量的值，如果repr的參數(shù)是某個對象時，那用它的類的__repr__返回對象的字符串表示。
9)__cmp__專用函數(shù)，在比較類實例時被調(diào)用。即當(dāng)作==比較時，被調(diào)用。
10)__len__專用函數(shù)，當(dāng)調(diào)用內(nèi)置函數(shù)len(instance)時被調(diào)用，對字符串返回字符的個數(shù)，對字典返回關(guān)鍵字的個數(shù)，對序列或列表返回元素個數(shù)。對自由定義的類，可自由定義返回的len的值的含義。：)
11)__delitem__專用函數(shù)， 在調(diào)用 del instance[key]被調(diào)用。
12)__setitem__,__getitem__,__cmp__,__len__,等方法加入到類的定義中后，可以使任何類看起來象“字典”。還有其它的一些專用方法，可以使類看起來象數(shù)值一樣可以對它進行運行。
21、類的實例化和清除
1)象調(diào)用函數(shù)一樣調(diào)用類，就可以實例化一個類，傳入的參數(shù)是__init__定義的參數(shù)(參數(shù)是以從右向左的順序傳遞給__init__的，python會自動添加self)，返回一個實例對象。
2)一個類的所有實例，共享類的文檔字符串，
3)python采用引用計數(shù)的技術(shù)進行垃圾回收，因而維護著對第一個創(chuàng)建的實例的引用的列表，當(dāng)計數(shù)為0時，實例自動被破壞。
4)不用顯式的釋放一個實例，因為當(dāng)變量超出作用域時自動失效，而至其所對應(yīng)的實例的引用數(shù)減一。
5)在Python中，你不能子類化象字符串、列表和字典的內(nèi)置數(shù)據(jù)類型。作為補償，Python附帶了封裝類，可以模擬這些內(nèi)置的數(shù)據(jù)類型的行為： UserString，UserList，和 UserDict。
6)子類中定義的方法覆蓋父類的方法，python不支持函數(shù)重載。由此，子類的__init__與父類的__init__的參數(shù)序列可以有較大的不同。
7)python支持?jǐn)?shù)據(jù)屬性，即C++中所謂的“數(shù)據(jù)成員”，對其值的引用需要以"實例名.屬性名"的方式。注意，數(shù)據(jù)屬性是類實例擁有的屬性，還有一種屬性是叫屬性，是類所擁有的
8)
22、當(dāng):號后面的塊(即需要縮進的內(nèi)容)只有一條語句時，可以直接將此語句放在:后面。
]]>
]]>
最新版本:2.4.2
Windows
下載 Python-2.4.2.exe,運行安裝
http://www.python.org/ftp/python/2.4.2/python-2.4.2.msi
其它平臺
下載 Python-2.4.2.tgz 或 Python-2.4.2.tar.bz2,
tar -zxvf Python-2.4.2.tgz 或bzcat Python-2.4.2.tar.bz2 | tar -xf -
./configure
make
make install
二、語法
1、函數(shù)聲明
關(guān)鍵字 def 為函數(shù)聲明的開始，不區(qū)分有返回值的函數(shù)與無返回值的函數(shù)。它沒有子程序，全部都是函數(shù)。
函數(shù)沒有定義返回的數(shù)據(jù)類型。如果函數(shù)執(zhí)行了一個 return 語句，它將返回一個值，否則會返回 None (Python的空值)。
參數(shù) params 并不需要指明數(shù)據(jù)類型
2、文檔字符串
任何在三重雙引號中的東西都是函數(shù)的文檔字符串，它們用來說明函數(shù)可以做什么。
如果存在文檔字符串，它必須要在函數(shù)中的被首先定義(也就是說在冒號后面被定義)。
文檔字符串在運行時可作為函數(shù)的屬性。
3、在Python中每個東西都是對象
并且?guī)缀趺總€東西都有屬性和方法。
所有的函數(shù)都有一個內(nèi)置的屬性 __doc__，它會返回在函數(shù)源代碼中定義的文檔字符串。
4、縮排代碼
Python函數(shù)沒有明顯的 begin 或 end，或任何括號或大括號來標(biāo)識函數(shù)開始結(jié)束。唯一的分隔是通過一個冒號(:)和代碼本身的縮排來表示。
代碼塊(函數(shù)，if 語句，for 循環(huán)，等等)通過它們的縮排來定義。縮排表示塊的開始，非縮排表示結(jié)束，不存在明顯的括號，大括號，或關(guān)鍵字。這就意味著空白是有意義的，并且要一致。
5、if __name__
在 if 表達式周圍不需要小括號
象C語言一樣，Python使用 == 進行比較，使用 = 進行賦值。
模塊是對象，并且所有的模塊都有一個內(nèi)置屬性 __name__。如果 import 模塊，那么 __name__ 的值通常為模塊的文件名，不帶路徑或者文件擴展名。如果直接運行模塊， __name__ 的值將是一個特別的缺省值， __main__。
通過在程序中加入下一個if，就可以很簡單地實現(xiàn)單元測試。
if __name__ == "__main__":
6、字典
Python的內(nèi)置數(shù)據(jù)類型之一是字典，它在關(guān)鍵字與值之間定義了一對一的關(guān)系。這一點就象Perl中的關(guān)聯(lián)數(shù)組，Java中的 Map ，或VBScipt中的 Scripting.Dictionary 對象。如：
>>> d = {"server":"mpilgrim", "database":"master"}
1)每一個元素都是一個鍵-值對，整個元素集合用大括號括起來,賦值給變量d.
2)server 是一個鍵字，它所關(guān)聯(lián)的值為 mpilgrim，用 d["server"] 來引用.
3)你可以通過鍵字來得到值，但是不能通過值得到鍵字。
>>> d["database"] = "pubs"
4)可如上式一樣修改字典.
5)不能在一個字典中有重復(fù)的鍵字。給一個存在的鍵字賦值會抹掉原來的值。
6)可以在任何時候加入新的鍵-值對。這種語法同修改存在的值一樣。
7)字典沒有元素順序的概念。
8)字典的值可以是任意數(shù)據(jù)類型，包括字符串，整數(shù)，對象，或者甚至其它的字典。
9)字典的關(guān)鍵字要嚴(yán)格一些，但是它們可以是字符串，整數(shù)和幾種其它的類型
>>> del d['server']
10)可如上式一樣刪除元素
>>> d.clear()
11)可如上式一樣清空所有元素
7、列表
1)個列表是一個用方括號包括的有序元素集。
>>> li = ["a", "b", "mpilgrim", "z", "example"]
2)可如上式定義列表
3)一個列表可以象一個以0開始的數(shù)組一樣使用。任何一個非空列表的第一個元素總是 xxx[0]。
4)負(fù)數(shù)索引從列表的尾部開始向后計數(shù)存取元素。li[n] == li[n – len(li)]，如：
>>> li[-3]
結(jié)果為"mpilgrim"。
5)任何一個非空的列表最后一個元素總是 li[-1]。
6)你可以通過指定2個索引得到列表的子集，叫做一個“分片”。返回值是一個新的列表，它包含了列表中按順序從第一個分片索引開始，直到但是不包括第二個分片索引的所有元素。
7)如果一個或兩個分片索引是負(fù)數(shù)，分片也可以工作,但如果兩個索引的所代表的位置大者在前則返回空列表。
8)如果任一個分片索引為0，你可以將其省略，默認(rèn)為0。所以li[:3]同li[0:3] 一樣。
9)li[:n] 將總是返回前 n 個元素，而 li[n:] 將返回其它的元素。
10)如果兩個分片索引均省略，將包括列表的所有元素。但是與原始的列表 li 不是同一個，它是一個新的列表，恰好擁有與 li 全部一樣的元素。li[:] 是生成一個列表拷貝的縮寫。
11)append 增加單個元素到列表的尾部。如：
>>> li.append("new")
12)insert 在列表中插入單個元素。數(shù)值參數(shù)是使得列表增加的第一個元素的索引(注意，不是序號).如下：
>>> li.insert(2, "new")
13)列表元素不需要唯一
14)用extend 連接列表。注意不要用多個參數(shù)調(diào)用 extend ，要使用一個列表參數(shù)調(diào)用。如下：
>>> li.extend(["two", "elements"])
15)index 在列表中查找值第一次的出現(xiàn)并返回索引值
>>> li.index("example")
16)如果在列表中沒有找到值，Python會引發(fā)一個異常
17)要測試一個值是否在列表內(nèi)，使用 in，如果值找到了，它返回 1 ，或者沒找到則為 0 。(在Python中不存在布爾類型。在一個布爾上下文中(象 if 語句)，0 是假，所有其它的數(shù)值為真。這一點也可以擴展到其它類型。一個空串("")，一個空列表([])，和一個空字典({})都是假，所有其它的字符串，列表，和字典是真。)如：
>>> "new" in li
18)remove 從列表中除掉第一次出現(xiàn)的值。(僅第一次出現(xiàn)的值),如：
>>> li.remove("new")
19)如果在列表中沒有找到值，Python引發(fā)一個異常。它反映了 index 方法的行為。
20)用pop除掉列表的最后一個元素，然后返回除掉的值。注意這一點同 li[-1]不同，后者返回一個值但不改變列表，也不同于 li.remove(value)，后者改變列表但不返回值。如：
>>> li.pop()
21)列表也可以用 + 操作符連接起來。list = list + otherlist 相當(dāng)于 list.extend(otherlist)。但是 + 操作符將連接后的列表作為一個值返回，而 extend 僅修改存在的列表。如：
>>> li = li + ['example', 'new']
22)Python支持 += 操作符。li += ['two'] 相當(dāng)于 li = li + ['two']。+= 操作符可用于列表，字符串，和整數(shù)，并且它也可以在用戶定義類中被重載。
23)* 操作符作為一個重復(fù)符可用在列表上。li = [1, 2] * 3 相當(dāng)于 li = [1, 2] + [1, 2] + [1, 2]， 將三個列表連成一個。
8、序列
1)序列是不可變列表。一旦創(chuàng)建了一個序列就不能以任何方式改變它。
2)序列的定義同列表的定義方式相同，除了整個元素集是用小括號包圍的而不是方括號
3)當(dāng)分割一個列表時，會得到一個新的列表；當(dāng)分割一個序列時，會得到一個新的序列。
4)序列沒有方法,所以不能查找、刪除和增加元素，但可以用in來檢查元素是否在序列里。
5)序列比列表操作速度快。
6)序列可以在字典中被用作關(guān)鍵字，但是列表不行。
7)內(nèi)置的 tuple 函數(shù)接收一個列表，返回一個有著相同元素的序列。而 list 函數(shù)接收一個序列，返回一個列表。從效果上看，tuple 凍結(jié)一個列表，而 list 解凍一個序列。
8)序列用在字符串格式化.
9、變量
1)Python象大多數(shù)其它語言一樣有局部和全局變量，但是它沒有明顯的變量聲明。變量通過賦值產(chǎn)生，當(dāng)超出作用范圍時自動消滅。
2)當(dāng)一條命令用續(xù)行符(“\”)分割成多行時，后續(xù)的行可以以任何方式縮排，Python通常的嚴(yán)格的縮排規(guī)則不需遵守。
3)嚴(yán)格地講，在小括號，方括號或大括號中的表達式(如定義字典)可以用或者不用續(xù)行符(“\”)分割成多行。
4)Python不允許你引用一個未被賦值的變量，試圖這樣做會引發(fā)一個異常。
10、字符串格式化
1)基本語法如下：
"帶占位符的字符串" % (參數(shù)序列)
2)試圖將一個字符串同一個非字符串連接會引發(fā)一個異常。字符串連接只能在每個都是字符串時起作用。此時選擇格式化串會是個不錯的主意。
11、映射
1)基本語法如下：
[ 函數(shù)或表達式 for 循環(huán)變量 in 列表/序列 ]
2)映射是通過循環(huán)遍歷一個列表/序列，并對每個元素應(yīng)用一個函數(shù)，然后返回一個包含為計算后的值的新列表。
3)注意列表映射不改變被映射的列表。
4)新列表擁有與原有列表/序列擁有相同數(shù)量的元素數(shù)
]]>
]]>
健全的程序大凡都需要輸入的功能，所以要學(xué)習(xí)一下簡單的輸入：
輸入要使用的是raw_input或者input函數(shù)，區(qū)別是raw_input直接把你的輸入作為字符串返回，而input則在raw_input的基礎(chǔ)上把字符串轉(zhuǎn)換為數(shù)字返回（如果你輸入$@#$$怎么辦？自己試試看）。我們就利用這兩個輸入函數(shù)來作一些有趣的事情。
| your_name = raw_input("please input your name:") hint = "welcome! %s" % your_name print hint |
| 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（無窮循環(huán)，1總是真的，while總是執(zhí)行）。\n是換行，不會全部忘光了吧。
| from Tkinter import * root = Tk() w = Label(root, text="Hello, world!") w.pack() root.mainloop() |
呵呵，一次太超前了一點，不過也不是解釋不清楚。我干脆也不解釋了吧。給大家增進一點興趣。
－－－－－－－－－
還是解釋一下
fromt Tkinter import *
是引入一個模塊，這個模塊用來創(chuàng)建GUI（Graphic User Interface）窗口
Tk()創(chuàng)建了一個主窗口
Label()創(chuàng)建一個標(biāo)簽
Label的第一個參數(shù)是root表明Label是在這個主窗口中的。
w.pack()是指用缺省的方式把Label放置在主窗口中
root.mainloop()開始了一個循環(huán)，是等待你的輸入的循環(huán)。
Lesson 7 Python基本語法要素齊動員
現(xiàn)在的目的是盡量想出一個用的東西僅限于內(nèi)置的變量類型和語句的一個綜合的例子，我想還是那個聯(lián)系人表的例子吧
| ################ #呵呵，還忘記了講注釋 #第一個算是完整的程序 ################ 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，現(xiàn)在有%d和%s兩個，分別代表插入十進制數(shù)值和字符串于%x標(biāo)記的位置處。
然后是列表
列表是順序的序列，用append在后面附加，也能構(gòu)用索引值索引。所以我們完全可以用一個變量保存len(contact_list)得到的長度，然后一個個的遍歷，不過這里展示了另外一種非常方便的方法。而且值得注意的是append()中的參數(shù)，我使用了contact.copy()，你可以嘗試著把copy()給去掉，觀察結(jié)果你就知道了所謂的append是怎么干的了，特別是你對指針之類的東西很有感覺的話（但是在Python中是沒有指針這個概念的）
再來看看字典
字典是鍵（key）和值（value）的對應(yīng)組合成的無序的序列。所以你存的時候要指明鍵（name或者phone），而且取的時候也是一樣的。
接下來是判斷
if是很好用的，==表示判斷兩個是否相等，=表示把右邊的賦給左邊的。而且可以直接判斷字符串是否相等，這個太方便了，如果你曾經(jīng)用過strcpy()的話，就知道了。elif是表示else if的意思，如果if不滿足就判斷elif的條件是否滿足，最后是到else中去。
循環(huán)是個主體
while和for都是循環(huán)。不過這里while就沒什么說的了，又是很經(jīng)典的while 1，死循環(huán)，然后必須在里面用break來跳出。for和C中的for是不一樣的，for in才是一個完整的語句，指的是從一個能夠逐一取值的序列中（比如list），一個一個的取出值賦給for后面指定的變量中，直到取空，循環(huán)結(jié)束。其實回想一般用C中的for的經(jīng)歷，也大體如此。而且你還可以用for i in range(1,100)來指定一個范圍從多少到多少。可以說for in充分體現(xiàn)了python的體貼周到，用起來很直觀，不會繞彎。
接下來就是運行了，大家慢慢調(diào)試吧。下次可能是講異常處理，因為我覺得在深入到使用各種高級的要素之前，先要學(xué)會怎么去處理異常。最常見的異常應(yīng)該是input()，然后你給出的輸入是一個無法轉(zhuǎn)換為數(shù)字的字符串了，那么我們就要來處理它。
Lesson 8 Python中的錯誤檢測
寫程序什么最重要？完成功能最重要。但是程序中難免要有用戶的輸入，對于這些寫的時候未可預(yù)知的因素中間可能出現(xiàn)的錯誤，一般稱作異常。對于異常情況的處理，不同語言有不同的做法，比如檢查函數(shù)的返回值之類的，但是那種辦法會把代碼弄成一團漿糊。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處理之后取出來。
現(xiàn)在你實驗一下"sdfsdf”之后，你會發(fā)現(xiàn)提示你
| Traceback (most recent call last): ??File " ? ? input() ??File " NameError: name 'sdfsdf' is not defined |
如果輸入其他稀奇古怪的字符串還可能有其他的出錯提示，我們現(xiàn)在要做的就是捕捉這種由用戶輸入引起的錯誤。這么來作：
| try: ? ? print input() except: ? ? print 'there is an error in your input' |
這下你無論怎么輸入都不會有什么其他的提示了，就是自己設(shè)定的print語句作為提示。現(xiàn)在把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
還有更多的能夠捕捉的錯誤，自己查手冊吧（暫時看不了手冊沒關(guān)系，慢慢來嘛）。以后還能夠自己raise（引發(fā)）異常呢。不過那都是比較高級的應(yīng)用了，對于出錯處理從一開始就有這個印象，并牢記在心中對于以后寫大一些的軟件很有好處。
Lesson 9 走向模塊化的第一步
大規(guī)模的程序設(shè)計需要你把一個大的程序拆分成n個模塊。然后把模塊進行組合，交互成為一個完整的程序。你不可能像現(xiàn)在這樣，從頂寫到尾。。。
那么我們從函數(shù)開始。
| def square(x): ? ? return x**2 print square(5) |
簡單吧，這個是我看過的函數(shù)定義中最簡潔的。def表示這個開始定義一個函數(shù)，x是參數(shù)，參數(shù)是不需要類型的，因為python是不需要明確指出類型的。return是返回值，返回的值插入到調(diào)用函數(shù)的地方。再復(fù)雜一些
| def multiply(a, b): ? ? return a*b print multiply(1,2) |
這是兩個參數(shù)的函數(shù)。那么返回兩個值呢？
| 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 |
其實元組和列表非常像，但是列表的長度是可以變化的，而且成員是可以改變的。但是元組是什么都不能變的，是只讀的。
對于高級一點的話題：傳遞進來的參數(shù)是否可以被修改，這個問題取決于你傳遞了什么近來。如果是數(shù)字或者字符串，是不能夠改變的，但是如果是這樣的：
| def test_func(list_be_passed): ? ? list_be_passed[0] = 'towin' my_list = ['taowen'] print my_list test_func(my_list) print my_list |
就能夠改變傳遞近來的參數(shù)了，所以處理的時候要小心，必要的時候copy一下再傳遞。
函數(shù)簡單吧，但是很好用的。想起C中的函數(shù)那么那么多麻煩，真是感慨萬千啊。下面是應(yīng)該講GUI編程呢，還是面向?qū)ο竽兀克伎家幌?br />
Lesson 10 Python的文件操作
文件操作....是一個語言和外界聯(lián)系的主要方法....現(xiàn)在以txt為例簡單的講一下...
首先是建立關(guān)聯(lián)...假設(shè)在存在以下文件 c:\a.txt
| This is line #1 This is line #2 This is line #3 END |
| >>> xxx = file('c:\\a.txt', 'r') |
關(guān)鍵字的第一部分，是文件路徑及名稱。注意這里面，路徑需要用\\
第二部分，是對文件的模式或者叫權(quán)限，一般有以下3種 "r" (read)， "w" (write)和 "a"(append).
之后，就可以利用
xxx_content = infile.read()
xxx_content = infile.readlines()
來讀取文件內(nèi)容了
| >>> 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()的作用相當(dāng)于最后的存盤。
]]>
Python 的官方網(wǎng)址：
www.python.org
點擊下面連接就可以直接下載了，這里只提供了Windows下的Python。
http://www.python.org/ftp/python/2.4.2/python-2.4.2.msi
linux版本的我就不說了，因為如果你能夠使用linux并安裝好說明你可以一切自己搞定的。
Python入門教程順便也貼上來：http://lj0508.blogchina.com/inc/Python.rar
運行環(huán)境可以是linux或者是windows：
1、linux
redhat的linux安裝上去之后一定會有python的（必須的組件），在命令行中輸入python回車。這樣就可以進入一個
>>>的提示符
2、windows
安裝好了python之后，在開始菜單里面找到Python2.3->IDLE，運行也會進入一個有
>>>提示符的窗口
開始嘗試Python
1、輸入：
welcome = "Hello!"
回車
然后又回到了>>>
2、輸入：
print welcome
回車
然后就可以看到你自己輸入的問候了。
Lesson 2 搞定環(huán)境之后的前行
Python有一個交互式的命令行，大家已經(jīng)看到了吧。所以可以比較方便的學(xué)習(xí)和嘗試，不用“新建－存檔－編譯－調(diào)試”，非常適合快速的嘗試。
一開始從變量開始（其實說變量，更準(zhǔn)確的是對象，Python中什么都可以理解為對象）。
變量
welcome = "hello!"
welcome就是變量名，字符串就是變量的類型，hello!就是變量的內(nèi)容，""表示這個變量是字符串，""中間的是字符串的內(nèi)容。
熟悉其他語言的人，特別是編譯類型的語言，覺得沒有變量的聲明很奇怪。在python中用賦值來表示我要這么一個變量，即使你不知道要放什么內(nèi)容，只是要先弄一個地方來放你的東西，也要這么寫：
store = ""
不過這個還是說明了store是字符串，因為""的緣故。
have a try
代碼:
| tmp_storage = "" welcome = "hello!" tmp_storage = welcome print tmp_storage |
你會發(fā)現(xiàn)同樣的問候出現(xiàn)了。
字符串
字符串是用""標(biāo)記的，但是用''也可以（不要說你看不出一個是雙引號，一個是單引號），兩者之間是有一丁點區(qū)別，不過你可以不用理會。其實是差不多的。字符串有很多自己的操作，最常用的是這樣的：
代碼:
| welcome = "hello" you = "world!" print welcome+you |
運行之后就會發(fā)現(xiàn)她輸出了helloworld!。
更多變量
變量還有幾種類型。
數(shù)
字符串
列表
字典
文件
勿庸置疑，這些都是非常非常常用的。對于數(shù)字就不用講了那就是：
代碼:
| radius = 10 pi = 3.14 area = pi*radius**2 print "the area is", area |
下次講列表和字典
Lesson 3 Python中的數(shù)學(xué)結(jié)構(gòu)
數(shù)學(xué)中你學(xué)什么東西最多遍？我想根據(jù)我的一點淺薄經(jīng)驗（雖然我是數(shù)學(xué)系的），學(xué)得最多的是集合，無論什么數(shù)學(xué)書都從集合開始講起。然后講函數(shù)呢，又必然把映射再講一遍。可以說，集合和映射是數(shù)學(xué)中最基本的結(jié)構(gòu)了。
Python對于數(shù)據(jù)結(jié)構(gòu)非常明智的內(nèi)置了兩個，回想我寫C的程序，往往是一開始就是用struct拼一個鏈表出來（重復(fù)勞動）。Python中提供了列表（list）和字典（dict）兩種數(shù)據(jù)結(jié)構(gòu)。他們分別對應(yīng)的原型是集合和映射。這個你應(yīng)該明白了，只是表示方法有一點不一樣而已。
列表
列表的英文名是list嘛，所以我取一個名字叫
代碼:
| my_list = [] 這個就產(chǎn)生了一個空的列表。然后給它賦值 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 = {} |
這個產(chǎn)生了一個空字典，contact。然后往里面填充內(nèi)容：
代碼:
| contact={} contact["name"]="taowen" contact["phone"]=68942443 |
name就是你查字典的時候要查找的單詞，taowen就是查到的內(nèi)容。不過你現(xiàn)在不是查，而是在寫這個字典。同理添加了phone這個詞條。
現(xiàn)在添加好了，看看contact的內(nèi)容，怎么查看？自己想辦法吧。。。
如果你悟性夠，就會發(fā)現(xiàn)python很多操作是通用的，既然能夠print 1, print "", print my_list，那么其他數(shù)據(jù)類型的變量就沒有理由不能用了。
結(jié)合列表和字典
代碼:
| contact_list=[] contact1={} contact1['name']='taowen' contact1['phone']=68942443 contact_list.append(contact1) contact2={} contact2['name']='god' contact2['phone']=44448888 contact_list.append(contact2) |
呵呵，夠復(fù)雜的吧。你可以想出我為什么要用兩個contact字典呢？。。。
Lesson 4 用不同的方式來操作Python
到現(xiàn)在為止，我們用的都是交互式的命令行來操作的，的卻是很方便，是吧？不過，復(fù)雜一些的情況就不那么好使了，來換一種方式來操作Python
在IDLE中點擊File->New Window，出現(xiàn)一個新窗口（對于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 |
你會發(fā)現(xiàn)輸入:之后，自動會給縮進。而且也沒有在python中發(fā)現(xiàn)和C/C++中類似的{}標(biāo)記也沒有pascal中的begin end;，其實縮進就是python中表示一段代碼的從屬關(guān)系的標(biāo)記方法。表示n=n+1和i=i-1這兩句都是while的。程序的運行邏輯應(yīng)該不用解釋了吧。就是運行5+4+3+2+1的結(jié)果。
運行代碼
按F5，可能提示你沒有存盤，照著辦就是了。
發(fā)揮你的能力，計算從1到10的所有偶數(shù)的和（提示，可能沒有你想象的那么智能）。
]]>
什么是Python?
Python是一種即譯式的，互動的，面向?qū)ο蟮木幊陶Z言，它包含了模組式的操作，異常處理，動態(tài)資料形態(tài)，十分高層次的動態(tài)資料結(jié)構(gòu)，以及類別的使用。Python揉合了簡單的語法和強大的功能。它的語法表達優(yōu)美易讀。它具有很多優(yōu)秀的腳本語言的特點：解釋的，面向?qū)ο蟮模瑑?nèi)建的高級數(shù)據(jù)結(jié)構(gòu)，支持模塊和包，支持多種平臺，可擴展。而且它還支持交互式方式運行，圖形方式運行。它擁有眾多的編程界面支持各種操作系統(tǒng)平臺以及眾多的各類函數(shù)庫。利用C和C++可以對它進行擴充。個別的應(yīng)用軟件如果需要有一個可程序化界面也可以利用它來做為擴展語言用。最后，Python的可移植度非常高:它可以在許多的Unix類平臺上運行，在Mac,MS-DOS,視窗Windows，Windows NT，OS/2，BeOS，以至RISCOS上都有相關(guān)的Python版本。
簡單的說它具有以下一些特征：
是一種解釋性的，面向?qū)ο蟮模哂袆討B(tài)語義的程序設(shè)計語言。
適合快速開發(fā)。
能集成到其他流行的服務(wù)器，也自帶服務(wù)器。
提供清晰的數(shù)據(jù)/邏輯/表示的分離。
帶有可擴展的內(nèi)置對象和強大的集成安全模塊。
Python的歷史
Python的創(chuàng)始人為Guido van Rossum。1989年圣誕節(jié)期間，在阿姆斯特丹，Guido為了打發(fā)圣誕節(jié)的無趣，決心開發(fā)一個新的腳本解釋程序，做為ABC語言的一種繼承。之所以選中Python（大蟒蛇的意思）作為程序的名字，是因為他是一個Monty 大蟒蛇飛行馬戲團的愛好者。
ABC是由Guido參加設(shè)計的一種教學(xué)語言（沒聽說過）。就Guido本人看來，ABC這種語言非常優(yōu)美和強大，是專門為非專業(yè)程序員設(shè)計的。但是ABC語言并沒有成功，究其原因，Guido認(rèn)為是非開放造成的。Guido決心在Python中避免這一錯誤（的確如此，Python與其它的語言如C,C++和Java結(jié)合的非常好）。同時，他還想實現(xiàn)在ABC中閃現(xiàn)過但未曾實現(xiàn)的東西。
就這樣，Python在Guido手中誕生了（真要感謝他）。實際上，第一個實現(xiàn)是在Mac機上。可以說，Python是從ABC發(fā)展起來，主要受到了Modula-3（另一種相當(dāng)優(yōu)美且強大的語言，為小型團體所設(shè)計的）的影響。并且結(jié)合了Unix Shell和C的習(xí)慣。
Python可用在哪些地方?
Python可以用在許多場合。當(dāng)你需要大量的動態(tài)調(diào)整，要容易使用，功能強大并且富有彈性的情況，Python可以發(fā)揮很好的功效。
在處理文字方面，Python的核心功能（不需要任何擴充庫的情況下）比別的編程語言更為易用而且速度相當(dāng)。這使Python在需要處理字符串的工作（包括系統(tǒng)管理，CGI編程）上成為高效的語言。
當(dāng)Python加上它的標(biāo)準(zhǔn)擴充庫（如PIL,COM,Numeric,Oracledb,kjbuckets,tkinter,win32api,等等）或是特別擴充庫（你自己寫的，或是用SWING做的，或是利用ILU/COBRA/com的）后，它可以變成一個很好的“膠合語言”或者叫“指導(dǎo)語言”。就是指把不同的編程環(huán)境和互不相關(guān)的軟件功能整合的工具。例如把Numeric和Oracledb透過Python結(jié)合起來你就可以替你的資料庫數(shù)據(jù)做系統(tǒng)分析。Python的簡單、易用以及方便而強大的c/c++擴展方面使它成為一種十分優(yōu)秀的“膠合語言”。
許多開發(fā)人員也在寫圖形用戶界面時廣泛的采用了Python。如果在Windows下，如果想做一個圖形界面程序，那么Python可以勝任。可以去wxPython.org看一下，它是一個Python的擴展庫，可以用來實現(xiàn)跨平臺的圖形編程，它支持windows和unix/linux。在那個網(wǎng)站上有一些演示，可以學(xué)習(xí)一下。Python可以做CGI。有些主頁提供了對Python的CGI支持。現(xiàn)在還有一些用Python做的游戲。如果想了解更多的Python可以做什么，可以去SourceForge上查找有關(guān)Python的項目，上面有很多東西。
運行方式
Python可以以命令行方式運行，也可以交互式方式運行，還具有圖形集成環(huán)境，這樣開發(fā)Python就相當(dāng)方便。現(xiàn)在已經(jīng)出現(xiàn)了許多用Python編寫的可視化編程軟件，用于實現(xiàn)象Delphi一樣的功能。
面向?qū)ο?/P>
Python是一個真正的面向?qū)ο笳Z言。它甚至支持異常的處理。如果學(xué)過Java，應(yīng)該對這個不陌生。但其它的腳本語言，如PHP，好象就沒有。這使得程序的編寫更加清晰，而不需要許多的錯誤檢查了。
模塊和包
這一點更象是Java。對于Java的支持，大家可以了解JPython。JPython是用Java寫的Python，它完全支持Java，在這個環(huán)境下使用Python可以隨意地使用Java的類庫。語言擴展可以用C、C++或Java為Python編寫新的新言模塊，如函數(shù)。或者與Python直接編譯在一起，或者采用動態(tài)庫裝入方式實現(xiàn)。也專門有人編寫了一個工具，可以實現(xiàn)為Python自動實現(xiàn)函數(shù)接口封裝，這就是SWIG（Simplified Wrapper and Interface Generator)，或稱做簡單封裝和接口生成器(可以在http://sourceforge.net/projects/swig/)。
有趣的語法
Guido認(rèn)為Python的語法是非常優(yōu)美的。其中一點就是，塊語句的表示不是C語言常用的{}對，或其它符號對，而是采用縮近表示法！有趣吧。就這一點來說，Guido的解釋是：首先，使用縮近表示法減少了視覺上的混亂，并且使程序變短，這樣就減少了需要對基本代碼單元注意的范圍；其次，它減少了程序員的自由度，更有利于統(tǒng)一風(fēng)格，使得閱讀別人的程序更容易。感覺還是不錯的，就C語言來說，在if語句后面大括號的寫法就好幾種，不同的人喜歡不同的樣子，還不如統(tǒng)一起來，都不會看得別扭。
在每個類或函數(shù)的定義后面，第一行可以是說明語句，根本不需要注釋符標(biāo)記。對于后面跟塊語句的語句，后面應(yīng)跟上一個冒號。一行語句不能太長，因為沒有行結(jié)束符，如果超長則要使用續(xù)行符(\)。還有一些有趣的比如說，象下面的一個比較處理，用C語言為：
if (2<a&&a<5)
用Python可以表示為
if (2<a<5) :
什么是Zope?
Zope是一個開放源代碼的Web應(yīng)用服務(wù)器，采用Python語言開發(fā)，使用它您可以方便的構(gòu)建內(nèi)容管理、內(nèi)部網(wǎng)、門戶網(wǎng)站、和其他的定制應(yīng)用。
高度面向?qū)ο蟮腤eb開發(fā)平臺,采用Python語言開發(fā)。
可以運行在幾乎所有流行的操作系統(tǒng)上,支持多語言。
能集成到其他流行的服務(wù)器，也自帶服務(wù)器。
提供清晰的數(shù)據(jù)/邏輯/表示的分離 。
帶有可擴展的內(nèi)置對象和強大的集成安全模塊。
什么是Plone?
Pone是一個Zope上的一個用戶友好、功能強大的開放源代碼內(nèi)容管理系統(tǒng)。Plone適合用作內(nèi)部網(wǎng)/外部網(wǎng)的服務(wù)器、文檔發(fā)布系統(tǒng)、門戶服務(wù)器和異地協(xié)同群件工具，到目前，Plone其實已經(jīng)發(fā)展成為了一個應(yīng)用開發(fā)平臺。
是一種功能強大的開放源碼(Open Source)內(nèi)容管理系統(tǒng)(CMS) 。
通過Web瀏覽器來訪問、編輯內(nèi)容和管理,易于更新內(nèi)容 。
無需編程，即可創(chuàng)建新的內(nèi)容類型 。
協(xié)同的編輯和發(fā)布機制 。
Python的IDE開發(fā)環(huán)境:
Wingide:http:// www.wingide.com
ipython: http://ipython.scipy.org/
參考資料：
Python中文社區(qū)：http://python.cn
Zope/Plone中文社區(qū)：http://zope.cn
Zope官方網(wǎng)站：http://www.zope.org
中文Zope用戶組：http://www.czug.org/
Python類庫: http://www.pypackage.org/
Python中文論壇：http://www.linuxforum.net/
O'Reilly： http://www.oreillynet.com
wxPython.org： http://www.wxPython.org
Jpython.org: http://jython.org
]]>
]]>
]]>
]]>