]]>
]]>
]]>
]]>
23、類屬性
1)類屬性是一個類的屬性，在創建任何類實例之前就有效了。類屬性既可以通過直接對類的引用，也可以通過對類的任意實例的引用來使用。
2)類屬性可以作為類級別的常量來使用，但是它們不是真正的常量，可以修改它們。
3)__class__ 是每個類實例的一個內置屬性(也是每個類的),它是一個類的引用，而 self 是一個類的實例
24、私有
1)python有私有函數、私有類方法和私有屬性，它們不能被從模塊外（或類外）調用。
2)如果一個Python函數的名字，類方法，或屬性以兩個下劃線開始(但不是結束)，它是私有的；其它所有的都是公有的。
3)Python沒有類方法保護的概念(只能用于它們自已的類和子父中)。類方法要不私有(只能在它們自已的類中使用)要不公有(任何地方都可使用)。
25、異常
1)一個 try...except ,try后面的塊是要監聽的塊，有異常時執行except后的塊。還可以有一條 else 子句，就象 if 語句。如果在 try 塊中沒有異常引發，然后 else 子句被執行。
2)一個try ... finally，finally后的塊總被執行。
26、文件對象
1)Python有一個內置函數open，用來打開在磁盤上的文件。open 返回一個文件對象，它擁有一些方法和屬性，可以得到打開文件的信息，和對打開文件進行操作。
2)open 方法可以接收三個參數：文件名，模式，和緩沖區參數。只有第一個參數，文件名，是必須的；其它兩個是可選的。如果沒有指定，文件以文本方式打開。
3)文件對象的mode屬性，標明文件屬性以何種方式被打開
4)文件對象的 name 屬性標明文件對象所打開的文件名。
5)文件對象的 tell 方法指明在打開文件中的當前位置
6)文件對象的 seek 方法在打開文件中移動到另一個位置。第二個參數指出第一個參數是什么意思：0 表示移動到一個絕對位置(從文件開始算起)，1 表示移到一個相對位置(從當前位置算起)，還有 2 表示對于文件尾的一個相對位置。
7)read 方法從打開文件中讀取指定個數的字節，并且返回含有讀取數據的字符串。可選參數指定了讀取的最大字節數。如果沒有指定參數，read 將讀到文件末尾。
8)文件對象的 closed 屬性表示對象是否打開或關閉了文件
9)調用文件對象的 close 方法來關閉一個文件，以釋放掉你加在文件上的鎖(如果有的話)，刷新被緩沖的系統確實還未寫入的輸出(如果有的話)，并且翻放系統資源。closed 屬性證實了文件被關閉了。
10)當文件被關閉后，文件對象所對應的變量仍然存在，直到超出作用域，或被刪除，此時所有的對文件的操作（close除外）都會拋出異常，close只是靜靜地失敗。
27、python有for循環
28、賦值
1)使用一個序列或列表一次給多個變量賦值，如下例
>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v
>>> (x, y, z) = range(3)
2)內置函數range接受一個表示上限的參數，返回一個從0開始的整數列表。
3)如果一個函數返回一個序列或列表，則可將它組賦值給一組變量，就象函數一次返回一組值一樣。如：
>>> (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)父類放在類名后的小括號內；
2)類可以有文檔字符串
3)__init__函數在對象被創建后被自動調用的第一個函數，可以指定任何個數的參數。
4)慣例，__init__應為類中第一個定義的方法，其第一個參數指向類的當前實例的第一個引用，且應命之為self。__init__中要顯式地調用父類的__init__方法。
5)__init__無返回值。
6)__init__的定義是可選的，一旦定義必須顯式調用父類的__init__方法。
7)除了可自由定義的普通的類方法，還有一些可以定義的專用方法。專用方法是在特殊情況下或當使用特別語法時由Python替你調用的，而不是在代碼中直接調用(象普通的方法那樣)。也就是說，python提供了一種方法，可以將非方法調用語法映射到方法調用上。最常見是__getitem__和__setitem__方法。例如，在上例中增加兩個方法的定義，就可以實現方便的取值和賦值：
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__專用函數，返回一個對象的字符串表示。Python用內置函數repr來顯示變量的值，如果repr的參數是某個對象時，那用它的類的__repr__返回對象的字符串表示。
9)__cmp__專用函數，在比較類實例時被調用。即當作==比較時，被調用。
10)__len__專用函數，當調用內置函數len(instance)時被調用，對字符串返回字符的個數，對字典返回關鍵字的個數，對序列或列表返回元素個數。對自由定義的類，可自由定義返回的len的值的含義。：)
11)__delitem__專用函數， 在調用 del instance[key]被調用。
12)__setitem__,__getitem__,__cmp__,__len__,等方法加入到類的定義中后，可以使任何類看起來象“字典”。還有其它的一些專用方法，可以使類看起來象數值一樣可以對它進行運行。
21、類的實例化和清除
1)象調用函數一樣調用類，就可以實例化一個類，傳入的參數是__init__定義的參數(參數是以從右向左的順序傳遞給__init__的，python會自動添加self)，返回一個實例對象。
2)一個類的所有實例，共享類的文檔字符串，
3)python采用引用計數的技術進行垃圾回收，因而維護著對第一個創建的實例的引用的列表，當計數為0時，實例自動被破壞。
4)不用顯式的釋放一個實例，因為當變量超出作用域時自動失效，而至其所對應的實例的引用數減一。
5)在Python中，你不能子類化象字符串、列表和字典的內置數據類型。作為補償，Python附帶了封裝類，可以模擬這些內置的數據類型的行為： UserString，UserList，和 UserDict。
6)子類中定義的方法覆蓋父類的方法，python不支持函數重載。由此，子類的__init__與父類的__init__的參數序列可以有較大的不同。
7)python支持數據屬性，即C++中所謂的“數據成員”，對其值的引用需要以"實例名.屬性名"的方式。注意，數據屬性是類實例擁有的屬性，還有一種屬性是叫屬性，是類所擁有的
8)
22、當:號后面的塊(即需要縮進的內容)只有一條語句時，可以直接將此語句放在:后面。
]]>
]]>
最新版本: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、函數聲明
關鍵字 def 為函數聲明的開始，不區分有返回值的函數與無返回值的函數。它沒有子程序，全部都是函數。
函數沒有定義返回的數據類型。如果函數執行了一個 return 語句，它將返回一個值，否則會返回 None (Python的空值)。
參數 params 并不需要指明數據類型
2、文檔字符串
任何在三重雙引號中的東西都是函數的文檔字符串，它們用來說明函數可以做什么。
如果存在文檔字符串，它必須要在函數中的被首先定義(也就是說在冒號后面被定義)。
文檔字符串在運行時可作為函數的屬性。
3、在Python中每個東西都是對象
并且幾乎每個東西都有屬性和方法。
所有的函數都有一個內置的屬性 __doc__，它會返回在函數源代碼中定義的文檔字符串。
4、縮排代碼
Python函數沒有明顯的 begin 或 end，或任何括號或大括號來標識函數開始結束。唯一的分隔是通過一個冒號(:)和代碼本身的縮排來表示。
代碼塊(函數，if 語句，for 循環，等等)通過它們的縮排來定義。縮排表示塊的開始，非縮排表示結束，不存在明顯的括號，大括號，或關鍵字。這就意味著空白是有意義的，并且要一致。
5、if __name__
在 if 表達式周圍不需要小括號
象C語言一樣，Python使用 == 進行比較，使用 = 進行賦值。
模塊是對象，并且所有的模塊都有一個內置屬性 __name__。如果 import 模塊，那么 __name__ 的值通常為模塊的文件名，不帶路徑或者文件擴展名。如果直接運行模塊， __name__ 的值將是一個特別的缺省值， __main__。
通過在程序中加入下一個if，就可以很簡單地實現單元測試。
if __name__ == "__main__":
6、字典
Python的內置數據類型之一是字典，它在關鍵字與值之間定義了一對一的關系。這一點就象Perl中的關聯數組，Java中的 Map ，或VBScipt中的 Scripting.Dictionary 對象。如：
>>> d = {"server":"mpilgrim", "database":"master"}
1)每一個元素都是一個鍵-值對，整個元素集合用大括號括起來,賦值給變量d.
2)server 是一個鍵字，它所關聯的值為 mpilgrim，用 d["server"] 來引用.
3)你可以通過鍵字來得到值，但是不能通過值得到鍵字。
>>> d["database"] = "pubs"
4)可如上式一樣修改字典.
5)不能在一個字典中有重復的鍵字。給一個存在的鍵字賦值會抹掉原來的值。
6)可以在任何時候加入新的鍵-值對。這種語法同修改存在的值一樣。
7)字典沒有元素順序的概念。
8)字典的值可以是任意數據類型，包括字符串，整數，對象，或者甚至其它的字典。
9)字典的關鍵字要嚴格一些，但是它們可以是字符串，整數和幾種其它的類型
>>> del d['server']
10)可如上式一樣刪除元素
>>> d.clear()
11)可如上式一樣清空所有元素
7、列表
1)個列表是一個用方括號包括的有序元素集。
>>> li = ["a", "b", "mpilgrim", "z", "example"]
2)可如上式定義列表
3)一個列表可以象一個以0開始的數組一樣使用。任何一個非空列表的第一個元素總是 xxx[0]。
4)負數索引從列表的尾部開始向后計數存取元素。li[n] == li[n – len(li)]，如：
>>> li[-3]
結果為"mpilgrim"。
5)任何一個非空的列表最后一個元素總是 li[-1]。
6)你可以通過指定2個索引得到列表的子集，叫做一個“分片”。返回值是一個新的列表，它包含了列表中按順序從第一個分片索引開始，直到但是不包括第二個分片索引的所有元素。
7)如果一個或兩個分片索引是負數，分片也可以工作,但如果兩個索引的所代表的位置大者在前則返回空列表。
8)如果任一個分片索引為0，你可以將其省略，默認為0。所以li[:3]同li[0:3] 一樣。
9)li[:n] 將總是返回前 n 個元素，而 li[n:] 將返回其它的元素。
10)如果兩個分片索引均省略，將包括列表的所有元素。但是與原始的列表 li 不是同一個，它是一個新的列表，恰好擁有與 li 全部一樣的元素。li[:] 是生成一個列表拷貝的縮寫。
11)append 增加單個元素到列表的尾部。如：
>>> li.append("new")
12)insert 在列表中插入單個元素。數值參數是使得列表增加的第一個元素的索引(注意，不是序號).如下：
>>> li.insert(2, "new")
13)列表元素不需要唯一
14)用extend 連接列表。注意不要用多個參數調用 extend ，要使用一個列表參數調用。如下：
>>> li.extend(["two", "elements"])
15)index 在列表中查找值第一次的出現并返回索引值
>>> li.index("example")
16)如果在列表中沒有找到值，Python會引發一個異常
17)要測試一個值是否在列表內，使用 in，如果值找到了，它返回 1 ，或者沒找到則為 0 。(在Python中不存在布爾類型。在一個布爾上下文中(象 if 語句)，0 是假，所有其它的數值為真。這一點也可以擴展到其它類型。一個空串("")，一個空列表([])，和一個空字典({})都是假，所有其它的字符串，列表，和字典是真。)如：
>>> "new" in li
18)remove 從列表中除掉第一次出現的值。(僅第一次出現的值),如：
>>> li.remove("new")
19)如果在列表中沒有找到值，Python引發一個異常。它反映了 index 方法的行為。
20)用pop除掉列表的最后一個元素，然后返回除掉的值。注意這一點同 li[-1]不同，后者返回一個值但不改變列表，也不同于 li.remove(value)，后者改變列表但不返回值。如：
>>> li.pop()
21)列表也可以用 + 操作符連接起來。list = list + otherlist 相當于 list.extend(otherlist)。但是 + 操作符將連接后的列表作為一個值返回，而 extend 僅修改存在的列表。如：
>>> li = li + ['example', 'new']
22)Python支持 += 操作符。li += ['two'] 相當于 li = li + ['two']。+= 操作符可用于列表，字符串，和整數，并且它也可以在用戶定義類中被重載。
23)* 操作符作為一個重復符可用在列表上。li = [1, 2] * 3 相當于 li = [1, 2] + [1, 2] + [1, 2]， 將三個列表連成一個。
8、序列
1)序列是不可變列表。一旦創建了一個序列就不能以任何方式改變它。
2)序列的定義同列表的定義方式相同，除了整個元素集是用小括號包圍的而不是方括號
3)當分割一個列表時，會得到一個新的列表；當分割一個序列時，會得到一個新的序列。
4)序列沒有方法,所以不能查找、刪除和增加元素，但可以用in來檢查元素是否在序列里。
5)序列比列表操作速度快。
6)序列可以在字典中被用作關鍵字，但是列表不行。
7)內置的 tuple 函數接收一個列表，返回一個有著相同元素的序列。而 list 函數接收一個序列，返回一個列表。從效果上看，tuple 凍結一個列表，而 list 解凍一個序列。
8)序列用在字符串格式化.
9、變量
1)Python象大多數其它語言一樣有局部和全局變量，但是它沒有明顯的變量聲明。變量通過賦值產生，當超出作用范圍時自動消滅。
2)當一條命令用續行符(“\”)分割成多行時，后續的行可以以任何方式縮排，Python通常的嚴格的縮排規則不需遵守。
3)嚴格地講，在小括號，方括號或大括號中的表達式(如定義字典)可以用或者不用續行符(“\”)分割成多行。
4)Python不允許你引用一個未被賦值的變量，試圖這樣做會引發一個異常。
10、字符串格式化
1)基本語法如下：
"帶占位符的字符串" % (參數序列)
2)試圖將一個字符串同一個非字符串連接會引發一個異常。字符串連接只能在每個都是字符串時起作用。此時選擇格式化串會是個不錯的主意。
11、映射
1)基本語法如下：
[ 函數或表達式 for 循環變量 in 列表/序列 ]
2)映射是通過循環遍歷一個列表/序列，并對每個元素應用一個函數，然后返回一個包含為計算后的值的新列表。
3)注意列表映射不改變被映射的列表。
4)新列表擁有與原有列表/序列擁有相同數量的元素數
]]>
]]>
健全的程序大凡都需要輸入的功能，所以要學習一下簡單的輸入：
輸入要使用的是raw_input或者input函數，區別是raw_input直接把你的輸入作為字符串返回，而input則在raw_input的基礎上把字符串轉換為數字返回（如果你輸入$@#$$怎么辦？自己試試看）。我們就利用這兩個輸入函數來作一些有趣的事情。
| 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（無窮循環，1總是真的，while總是執行）。\n是換行，不會全部忘光了吧。
| 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 " ? ? input() ??File " 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()的作用相當于最后的存盤。
]]>
Python 的官方網址：
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
運行環境可以是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的所有偶數的和（提示，可能沒有你想象的那么智能）。
]]>
什么是Python?
Python是一種即譯式的，互動的，面向對象的編程語言，它包含了模組式的操作，異常處理，動態資料形態，十分高層次的動態資料結構，以及類別的使用。Python揉合了簡單的語法和強大的功能。它的語法表達優美易讀。它具有很多優秀的腳本語言的特點：解釋的，面向對象的，內建的高級數據結構，支持模塊和包，支持多種平臺，可擴展。而且它還支持交互式方式運行，圖形方式運行。它擁有眾多的編程界面支持各種操作系統平臺以及眾多的各類函數庫。利用C和C++可以對它進行擴充。個別的應用軟件如果需要有一個可程序化界面也可以利用它來做為擴展語言用。最后，Python的可移植度非常高:它可以在許多的Unix類平臺上運行，在Mac,MS-DOS,視窗Windows，Windows NT，OS/2，BeOS，以至RISCOS上都有相關的Python版本。
簡單的說它具有以下一些特征：
是一種解釋性的，面向對象的，具有動態語義的程序設計語言。
適合快速開發。
能集成到其他流行的服務器，也自帶服務器。
提供清晰的數據/邏輯/表示的分離。
帶有可擴展的內置對象和強大的集成安全模塊。
Python的歷史
Python的創始人為Guido van Rossum。1989年圣誕節期間，在阿姆斯特丹，Guido為了打發圣誕節的無趣，決心開發一個新的腳本解釋程序，做為ABC語言的一種繼承。之所以選中Python（大蟒蛇的意思）作為程序的名字，是因為他是一個Monty 大蟒蛇飛行馬戲團的愛好者。
ABC是由Guido參加設計的一種教學語言（沒聽說過）。就Guido本人看來，ABC這種語言非常優美和強大，是專門為非專業程序員設計的。但是ABC語言并沒有成功，究其原因，Guido認為是非開放造成的。Guido決心在Python中避免這一錯誤（的確如此，Python與其它的語言如C,C++和Java結合的非常好）。同時，他還想實現在ABC中閃現過但未曾實現的東西。
就這樣，Python在Guido手中誕生了（真要感謝他）。實際上，第一個實現是在Mac機上。可以說，Python是從ABC發展起來，主要受到了Modula-3（另一種相當優美且強大的語言，為小型團體所設計的）的影響。并且結合了Unix Shell和C的習慣。
Python可用在哪些地方?
Python可以用在許多場合。當你需要大量的動態調整，要容易使用，功能強大并且富有彈性的情況，Python可以發揮很好的功效。
在處理文字方面，Python的核心功能（不需要任何擴充庫的情況下）比別的編程語言更為易用而且速度相當。這使Python在需要處理字符串的工作（包括系統管理，CGI編程）上成為高效的語言。
當Python加上它的標準擴充庫（如PIL,COM,Numeric,Oracledb,kjbuckets,tkinter,win32api,等等）或是特別擴充庫（你自己寫的，或是用SWING做的，或是利用ILU/COBRA/com的）后，它可以變成一個很好的“膠合語言”或者叫“指導語言”。就是指把不同的編程環境和互不相關的軟件功能整合的工具。例如把Numeric和Oracledb透過Python結合起來你就可以替你的資料庫數據做系統分析。Python的簡單、易用以及方便而強大的c/c++擴展方面使它成為一種十分優秀的“膠合語言”。
許多開發人員也在寫圖形用戶界面時廣泛的采用了Python。如果在Windows下，如果想做一個圖形界面程序，那么Python可以勝任。可以去wxPython.org看一下，它是一個Python的擴展庫，可以用來實現跨平臺的圖形編程，它支持windows和unix/linux。在那個網站上有一些演示，可以學習一下。Python可以做CGI。有些主頁提供了對Python的CGI支持。現在還有一些用Python做的游戲。如果想了解更多的Python可以做什么，可以去SourceForge上查找有關Python的項目，上面有很多東西。
運行方式
Python可以以命令行方式運行，也可以交互式方式運行，還具有圖形集成環境，這樣開發Python就相當方便。現在已經出現了許多用Python編寫的可視化編程軟件，用于實現象Delphi一樣的功能。
面向對象
Python是一個真正的面向對象語言。它甚至支持異常的處理。如果學過Java，應該對這個不陌生。但其它的腳本語言，如PHP，好象就沒有。這使得程序的編寫更加清晰，而不需要許多的錯誤檢查了。
模塊和包
這一點更象是Java。對于Java的支持，大家可以了解JPython。JPython是用Java寫的Python，它完全支持Java，在這個環境下使用Python可以隨意地使用Java的類庫。語言擴展可以用C、C++或Java為Python編寫新的新言模塊，如函數。或者與Python直接編譯在一起，或者采用動態庫裝入方式實現。也專門有人編寫了一個工具，可以實現為Python自動實現函數接口封裝，這就是SWIG（Simplified Wrapper and Interface Generator)，或稱做簡單封裝和接口生成器(可以在http://sourceforge.net/projects/swig/)。
有趣的語法
Guido認為Python的語法是非常優美的。其中一點就是，塊語句的表示不是C語言常用的{}對，或其它符號對，而是采用縮近表示法！有趣吧。就這一點來說，Guido的解釋是：首先，使用縮近表示法減少了視覺上的混亂，并且使程序變短，這樣就減少了需要對基本代碼單元注意的范圍；其次，它減少了程序員的自由度，更有利于統一風格，使得閱讀別人的程序更容易。感覺還是不錯的，就C語言來說，在if語句后面大括號的寫法就好幾種，不同的人喜歡不同的樣子，還不如統一起來，都不會看得別扭。
在每個類或函數的定義后面，第一行可以是說明語句，根本不需要注釋符標記。對于后面跟塊語句的語句，后面應跟上一個冒號。一行語句不能太長，因為沒有行結束符，如果超長則要使用續行符(\)。還有一些有趣的比如說，象下面的一個比較處理，用C語言為：
if (2<a&&a<5)
用Python可以表示為
if (2<a<5) :
什么是Zope?
Zope是一個開放源代碼的Web應用服務器，采用Python語言開發，使用它您可以方便的構建內容管理、內部網、門戶網站、和其他的定制應用。
高度面向對象的Web開發平臺,采用Python語言開發。
可以運行在幾乎所有流行的操作系統上,支持多語言。
能集成到其他流行的服務器，也自帶服務器。
提供清晰的數據/邏輯/表示的分離 。
帶有可擴展的內置對象和強大的集成安全模塊。
什么是Plone?
Pone是一個Zope上的一個用戶友好、功能強大的開放源代碼內容管理系統。Plone適合用作內部網/外部網的服務器、文檔發布系統、門戶服務器和異地協同群件工具，到目前，Plone其實已經發展成為了一個應用開發平臺。
是一種功能強大的開放源碼(Open Source)內容管理系統(CMS) 。
通過Web瀏覽器來訪問、編輯內容和管理,易于更新內容 。
無需編程，即可創建新的內容類型 。
協同的編輯和發布機制 。
Python的IDE開發環境:
Wingide:http:// www.wingide.com
ipython: http://ipython.scipy.org/
參考資料：
Python中文社區：http://python.cn
Zope/Plone中文社區：http://zope.cn
Zope官方網站：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
]]>
]]>
]]>
]]>