存儲器 eval total start 計算 env 命名 比較 dna

一、基本概念

　　1. python中數有四種類型：整數、長整數、浮點數和復數。

• 整數， 如 1
• 長整數 是比較大的整數
• 浮點數 如 1.23、3E-2
• 復數 如 1 + 2j、 1.1 + 2.2j

　　2. 字符串（字符的序列）

• python中單引號和雙引號使用完全相同。
• 使用三引號(‘‘‘或""")可以指定一個多行字符串。
• 轉義符 ‘\‘
• 自然字符串， 通過在字符串前加r或R。 如 r"this is a line with \n" 則\n會顯示，並不是換行。
• python允許處理unicode字符串，加前綴u或U， 如 u"this is an unicode string"。
• 字符串是不可變的。
• 按字面意義級聯字符串，如"this " "is " "string"會被自動轉換為this is string。

　　3. 標識符的命名

• 第一個字符必須是字母表中字母或下劃線‘_‘。
• 標識符的其他的部分有字母、數字和下劃線組成。
• 標識符對大小寫敏感。

　　4. 對象

　　　　python程序中用到的任何“東西”都成為“對象”。

　　5. 邏輯行和物理行

　　　　物理行是我們在編寫程序時看到的，邏輯行則是python看到的。

　　　　python中分號;標識一個邏輯行的結束，但是實際中一般每個物理行只寫一個邏輯行，可以避免使用分號。

　　　　多個物理行中可以寫一個邏輯行，如下：

s = "peter is \

writing this article"

　　　　上面\的使用被稱為‘明確的行連接’， 又如：

print "peter"

　　6. 縮進

　　　　空白在python是非常重要的，行首的空白是最重要的，又稱為縮進。行首的空白（空格和制表符）用來決定邏輯行的縮進層次，從而決定語句

　　分組。這意味著同一層次的語句必須有相同的縮進，每一組這樣的語句稱為一個塊。

　　註意：不要混合使用空格和制表符來縮進，因為在跨越不同的平臺時無法正常工作。

二、運算符與表達式

　　1. 運算符與其用法

運算符	名稱	說明	例子
+	加	兩個對象相加	3 + 5得到8。‘a‘ + ‘b‘得到‘ab‘。
-	減	得到負數或是一個數減去另一個數	-5.2得到一個負數。50 - 24得到26。
*	乘	兩個數相乘或是返回一個被重復若幹次的字符串	2 * 3得到6。‘la‘ * 3得到‘lalala‘。
**	冪	返回x的y次冪	3 ** 4得到81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3得到1（整數的除法得到整數結果）。4.0/3或4/3.0得到1.3333333333333333
//	取整除	返回商的整數部分	4 // 3.0得到1.0
%	取模	返回除法的余數	8%3得到2。-25.5%2.25得到1.5
<<	左移	把一個數的比特向左移一定數目（每個數在內存中都表示為比特或二進制數字，即0和1）	2 << 2得到8。——2按比特表示為10
>>	右移	把一個數的比特向右移一定數目	11 >> 1得到5。——11按比特表示為1011，向右移動1比特後得到101，即十進制的5。
&	按位與	數的按位與	5 & 3得到1。
|	按位或	數的按位或	5 | 3得到7。
^	按位異或	數的按位異或	5 ^ 3得到6
~	按位翻轉	x的按位翻轉是-(x+1)	~5得到6。
<	小於	返回x是否小於y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。註意，這些變量名的大寫。	5 < 3返回0（即False）而3 < 5返回1（即True）。比較可以被任意連接：3 < 5 < 7返回True。
>	大於	返回x是否大於y	5 > 3返回True。如果兩個操作數都是數字，它們首先被轉換為一個共同的類型。否則，它總是返回False。
<=	小於等於	返回x是否小於等於y	x = 3; y = 6; x <= y返回True。
>=	大於等於	返回x是否大於等於y	x = 4; y = 3; x >= y返回True。
==	等於	比較對象是否相等	x = 2; y = 2; x == y返回True。x = ‘str‘; y = ‘stR‘; x == y返回False。x = ‘str‘; y = ‘str‘; x == y返回True。
!=	不等於	比較兩個對象是否不相等	x = 2; y = 3; x != y返回True。
not	布爾“非”	如果x為True，返回False。如果x為False，它返回True。	x = True; not y返回False。
and	布爾“與”	如果x為False，x and y返回False，否則它返回y的計算值。	x = False; y = True; x and y，由於x是False，返回False。在這裏，Python不會計算y，因為它知道這個表達式的值肯定是False（因為x是False）。這個現象稱為短路計算。
or	布爾“或”	如果x是True，它返回True，否則它返回y的計算值。	x = True; y = False; x or y返回True。短路計算在這裏也適用。

　　2. 運算符優先級（從低到高）

運算符	描述
lambda	Lambda表達式
or	布爾“或”
and	布爾“與”
not x	布爾“非”
in，not in	成員測試
is，is not	同一性測試
<，<=，>，>=，!=，==	比較
|	按位或
^	按位異或
&	按位與
<<，>>	移位
+，-	加法與減法
*，/，%	乘法、除法與取余
+x，-x	正負號
~x	按位翻轉
**	指數
x.attribute	屬性參考
x[index]	下標
x[index:index]	尋址段
f(arguments...)	函數調用
(experession,...)	綁定或元組顯示
[expression,...]	列表顯示
{key:datum,...}	字典顯示
‘expression,...‘	字符串轉換

　　3. python 控制臺輸出 使用print

print "abc"  　　#打印abc並換行
print "abc%s" % "d"  　　#打印abcd
print "abc%sef%s" % ("d", "g")  　　#打印abcdefg

三、控制流

　　1. if 語句

i = 10
n = int(raw_input("enter a number:"))

if n == i:
    print "equal"
elif n < i:
    print "lower"
else:
    print "higher"

　　2. while語句

while True:
    pass
else:
    pass
#else語句可選，當while為False時，else語句被執行。 pass是空語句。

　　3. for 循環 for..in

for i in range(0, 5):
    print i
else:
    pass
# 打印0到4

　　註：當for循環結束後執行else語句；

　　　　range(a, b)返回一個序列，從a開始到b為止，但不包括b，range默認步長為1，可以指定步長，range(0,10,2)；

　　4. break語句

　　　　終止循環語句，如果從for或while中終止，任何對應循環的else將不執行。

　　5. continue語句

　　　　continue語句用來調過當前循環的剩余語句，然後繼續下一輪循環。

四、函數

　　函數通過def定義。def關鍵字後跟函數的標識符名稱，然後跟一對圓括號，括號之內可以包含一些變量名，該行以冒號結尾；接下來是一塊語句，即函數體。

def sumOf(a, b):
    return a + b

　　1. 函數形參

　　　　函數中的參數名稱為‘形參’，調用函數時傳遞的值為‘實參’

　　2. 局部變量

　　　　在函數內定義的變量與函數外具有相同名稱的其他變量沒有任何關系，即變量名稱對於函數來說是局部的。這稱為變量的作用域。

　　　　global語句， 為定義在函數外的變量賦值時使用global語句。

def func():
    global x
    print "x is ", x
    x = 1

x = 3
func()
print x

#3
#1 

　　3. 默認參數

　　　　通過使用默認參數可以使函數的一些參數是‘可選的’。

def say(msg, times =  1):
    print msg * times

say("peter")
say("peter", 3)

　　　　註意：只有在形參表末尾的那些參數可以有默認參數值，即不能在聲明函數形參的時候，先聲明有默認值的形參而後聲明沒有默認值的形參，只是因為賦給形參的值是根據位置而賦值的。

　　4. 關鍵參數

　　　　如果某個函數有很多參數，而現在只想指定其中的部分，那麽可以通過命名為這些參數賦值（稱為‘關鍵參數’）。

　　　　優點：不必擔心參數的順序，使函數變的更加簡單；假設其他參數都有默認值，可以只給我們想要的那些參數賦值。

def func(a, b=2, c=3):
    print "a is %s, b is %s, c is %s" % (a, b, c)

func(1) #a is 1, b is 2, c is 3
func(1, 5) #a is 1, b is 5, c is 3
func(1, c = 10) #a is 1, b is 2, c is 10
func(c = 20, a = 30) #a is 30, b is 2, c is 20

　　5. return 語句

　　　　return語句用來從一個函數返回，即跳出函數。可從函數返回一個值。

　　　　沒有返回值的return語句等價於return None。None表示沒有任何東西的特殊類型。

　　6. DocStrings (文檔字符串)

def func():
    ‘‘‘This is self-defined function

Do nothing‘‘‘
    pass

print func.__doc__

#This is self-defined function
#
#Do nothing

五、模塊

　　模塊就是一個包含了所有你定義的函數和變量的文件，模塊必須以.py為擴展名。模塊可以從其他程序中‘輸入’(import)以便利用它的功能。

　　在python程序中導入其他模塊使用‘import‘, 所導入的模塊必須在sys.path所列的目錄中，因為sys.path第一個字符串是空串‘‘即當前目錄，所以程序中可導入當前目錄的模塊。

　　1. 字節編譯的.pyc文件

　　　　導入模塊比較費時，python做了優化，以便導入模塊更快些。一種方法是創建字節編譯的文件，這些文件以.pyc為擴展名。

　　　　pyc是一種二進制文件，是py文件經編譯後產生的一種byte code，而且是跨平臺的（平臺無關）字節碼，是有python虛擬機執行的，類似於

　　java或.net虛擬機的概念。pyc的內容，是跟python的版本相關的，不同版本編譯後的pyc文件是不同的。

　　2. from .. import

　　　　如果想直接使用其他模塊的變量或其他，而不加‘模塊名+.‘前綴，可以使用from .. import。

　　　　例如想直接使用sys的argv，from sys import argv 或 from sys import *

　　3. 模塊的__name__

　　　　每個模塊都有一個名稱，py文件對應模塊名默認為py文件名，也可在py文件中為__name__賦值；如果是__name__，說明這個模塊被用戶

　　單獨運行。

　　4. dir()函數

　　　　dir(sys)返回sys模塊的名稱列表；如果不提供參數，即dir()，則返回當前模塊中定義名稱列表。

　　　　del -> 刪除一個變量/名稱，del之後，該變量就不能再使用。

六、數據結構

　　python有三種內建的數據結構：列表、元組和字典。

　　1. 列表

　　　　list是處理一組有序項目的數據結構，列表是可變的數據結構。列表的項目包含在方括號[]中，eg: [1, 2, 3]， 空列表[]。判斷列表中是否包含某項可以使用in， 比如 l = [1, 2, 3]; print 1 in l; #True；支持索引和切片操作；索引時若超出範圍，則IndexError；使用函數len()查看長度；使用del可以刪除列表中的項，eg: del l[0] # 如果超出範圍，則IndexError

　　　　list函數如下：

　　　　append（value）　　---向列表尾添加項value

l = [1, 2, 2]
l.append(3) #[1, 2, 2, 3]

　　　　count(value)　　---返回列表中值為value的項的個數

l = [1, 2, 2]
print l.count(2) # 2

　　　　extend(list2)　　---向列表尾添加列表list2

l = [1, 2, 2]
l1 = [10, 20]
l.extend(l1)
print l   #[1, 2, 2, 10, 20]

　　　　index(value, [start, [stop]])　　---返回列表中第一個出現的值為value的索引，如果沒有，則異常 ValueError

l = [1, 2, 2]
a = 4
try:
    print l.index(a)
except ValueError, ve:
    print "there is no %d in list" % a

　　　　insert(i, value)　　---向列表i位置插入項vlaue，如果沒有i，則添加到列表尾部

l = [1, 2, 2]

l.insert(1, 100)
print l #[1, 100, 2, 2]

l.insert(100, 1000)
print l #[1, 100, 2, 2, 1000]

　　　　pop([i])　　---返回i位置項，並從列表中刪除；如果不提供參數，則刪除最後一個項；如果提供，但是i超出索引範圍，則異常IndexError

l = [0, 1, 2, 3, 4, 5]

print l.pop() # 5
print l #[0, 1, 2, 3, 4]

print l.pop(1) #1
print l #[0, 2, 3, 4]

try:
    l.pop(100)
except IndexError, ie:
    print "index out of range"

　　　　remove(value)　　---刪除列表中第一次出現的value，如果列表中沒有vlaue，則異常ValueError

l = [1, 2, 3, 1, 2, 3]

l.remove(2)
print l #[1, 3, 1, 2, 3]

try:
    l.remove(10)
except ValueError, ve:
    print "there is no 10 in list"

　　　　reverse()　　---列表反轉

l = [1, 2, 3]
l.reverse()
print l #[3, 2, 1]

　　　　sort(cmp=None, key=None, reverse=False)　　---列表排序

【Python Library Reference】
cmp:cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument:
"cmp=lambda x,y: cmp(x.lower(), y.lower())"
key:key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse:reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.In general, the key and reverse conversion processes are much faster than specifying an
equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.

l5 = [10, 5, 20, 1, 30]
l5.sort()
print l5 #[1, 5, 10, 20, 30]

l6 = ["bcd", "abc", "cde", "bbb"]
l6.sort(cmp = lambda s1, s2: cmp(s1[0],s2[1]))
print l6 #[‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]

l7 = ["bcd", "abc", "cde", "bbb", "faf"]
l7.sort(key = lambda s: s[1])
print l7 #[‘faf‘, ‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]

　　2. 元組

　　　　tuple和list十分相似，但是tuple是不可變的，即不能修改tuple，元組通過圓括號中用逗號分割的項定義；支持索引和切片操作；可以使用 in

　　查看一個元素是否在tuple中。空元組()；只含有一個元素的元組("a",) #需要加個逗號

　　　　優點：tuple比list速度快；對不需要修改的數據進行‘寫保護’，可以是代碼更安全

　　　　tuple與list可以相互轉換，使用內置的函數list()和tuple()。

l = [1, 2, 3]
print l # [1, 2, 3]

t = tuple(l)
print t # (1, 2, 3)

l1 = list(t)
print l1 #[1, 2, 3]

　　　　元組最通常的用法是用在打印語句，如下例：

name = "Peter Zhang"
age = 25
print "Name: %s; Age: %d" % (name, age)
# Name: Peter Zhang; Age: 25

　　　　函數如下：

　　　　count(value)　　---返回元組中值為value的元素的個數

t = (1, 2, 3, 1, 2, 3)

print t.count(2) # 2

　　　　index(value, [start, [stop]])　　---返回列表中第一個出現的值為value的索引，如果沒有，則異常 ValueError

t = (1, 2, 3, 1, 2, 3)

print t.index(3) # 2
try:
    print t.index(4)
except ValueError, ve:
    print "there is no 4 in tuple"  # there is no 4 in tuple

　　3. 字典

　　　　字典由鍵值對組成，鍵必須是唯一的；eg: d = {key1:value1, key2:value2}；空字典用{}表示；字典中的鍵值對是沒有順序的，如果想要

　　一個特定的順序，那麽使用前需要對它們排序；d[key] = value，如果字典中已有key，則為其賦值為value，否則添加新的鍵值對key/value；使

　　用del d[key] 可以刪除鍵值對；判斷字典中是否有某鍵，可以使用in 或 not in；

d = {}
d["1"] = "one"
d["2"] = "two"
d["3"] = "three"

del d["3"]

for key, value in d.items():
    print "%s --> %s" % (key, value)
#1 --> one
#2 --> two

　　　　dict函數如下:

　　　　clear()　　---刪除字典中所有元素

d1 = {"1":"one", "2":"two"}
d1.clear()

print d1 # {}

　　　　copy()　　---返回字典的一個副本(淺復制)

d1 = {"1":"one", "2":"two"}
d2 = d1.copy()

print d2 #{‘1‘: ‘one‘, ‘2‘: ‘two‘}

　　　　dict.fromkeys(seq,val=None) ---創建並返回一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值(默認為None)

l = [1, 2, 3]
t = (1, 2, 3)

d3 = {}.fromkeys(l)
print d3 #{1: None, 2: None, 3: None}

d4 = {}.fromkeys(t, "default")
print d4 #{1: ‘default‘, 2: ‘default‘, 3: ‘default‘}

　　　　get(key,[default])　　---返回字典dict中鍵key對應值，如果字典中不存在此鍵，則返回default 的值(default默認值為None)

d5 = {1:"one", 2:"two", 3:"three"}

print d5.get(1) #one
print d5.get(5) #None
print d5.get(5, "test") #test

　　　　has_key(key)　　---判斷字典中是否有鍵key

d6 = {1:"one", 2:"two", 3:"three"}

print d6.has_key(1)  #True
print d6.has_key(5)  #False

　　　　items()　　---返回一個包含字典中(鍵, 值)對元組的列表

d7 = {1:"one", 2:"two", 3:"three"}

for item in d7.items():
    print item
#(1, ‘one‘)
#(2, ‘two‘)
#(3, ‘three‘)

for key, value in d7.items():
    print "%s -- %s" % (key, value)
#1 -- one
#2 -- two
#3 -- three

　　　　keys()　　---返回一個包含字典中所有鍵的列表

d8 = {1:"one", 2:"two", 3:"three"}

for key in d8.keys():
    print key
#1
#2
#3

　　　　values()　　---返回一個包含字典中所有值的列表

d8 = {1:"one", 2:"two", 3:"three"}

for value in d8.values():
    print value
#one
#two
#three

　　　　pop(key, [default])　　---若字典中key鍵存在，刪除並返回dict[key]，若不存在，且未給出default值，引發KeyError異常

d9 = {1:"one", 2:"two", 3:"three"}
print d9.pop(1) #one
print d9 #{2: ‘two‘, 3: ‘three‘}
print d9.pop(5, None) #None
try:
    d9.pop(5)  # raise KeyError
except KeyError, ke:
    print  "KeyError:", ke #KeyError:5

　　　　popitem()　　---刪除任意鍵值對，並返回該鍵值對，如果字典為空，則產生異常KeyError

d10 = {1:"one", 2:"two", 3:"three"}

print d10.popitem()  #(1, ‘one‘)
print d10  #{2: ‘two‘, 3: ‘three‘}

　　　　setdefault(key,[default])　　---若字典中有key，則返回vlaue值，若沒有key，則加上該key，值為default，默認None

d = {1:"one", 2:"two", 3:"three"}

print d.setdefault(1)  #one
print d.setdefault(5)  #None
print d  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None}
print d.setdefault(6, "six") #six
print d  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None, 6: ‘six‘}

　　　　update(dict2)　　---把dict2的元素加入到dict中去，鍵字重復時會覆蓋dict中的鍵值

d = {1:"one", 2:"two", 3:"three"}
d2 = {1:"first", 4:"forth"}

d.update(d2)
print d  #{1: ‘first‘, 2: ‘two‘, 3: ‘three‘, 4: ‘forth‘}

　　　　viewitems()　　---返回一個view對象，（key, value）pair的列表，類似於視圖。優點是，如果字典發生變化，view會同步發生變化。在

　　叠代過程中，字典不允許改變，否則會報異常

d = {1:"one", 2:"two", 3:"three"}
for key, value in d.viewitems():
    print "%s - %s" % (key, value)
#1 - one
#2 - two
#3 - three

　　　　viewkeys()　　---返回一個view對象，key的列表

d = {1:"one", 2:"two", 3:"three"}
for key in d.viewkeys():
    print key
#1
#2
#3

　　　　viewvalues()　　---返回一個view對象，value的列表

d = {1:"one", 2:"two", 3:"three"}
for value in d.viewvalues():
    print value
#one
#two
#three

　　4. 序列

　　　　序列類型是指容器內的元素從0開始的索引順序訪問，一次可以訪問一個或者多個元素；列表、元組和字符串都是序列；序列的兩個主要特點是

　　索引操作符和切片操作符；索引可以得到特定元素；切片可以得到部分序列；

 1 numbers = ["zero", "one", "two", "three", "four"]
 2 
 3 print numbers[1] # one
 4 print numbers[-1] # four
 5 #print numbers[5] # raise IndexError
 6 
 7 print numbers[:] # [‘zero‘, ‘one‘, ‘two‘, ‘three‘, ‘four‘]
 8 print numbers[3:] # [‘three‘, ‘four‘]
 9 print numbers[:2] # [‘zero‘, ‘one‘]
10 print numbers[2:4] # [‘two‘, ‘three‘]
11 print numbers[1:-1] # [‘one‘, ‘two‘, ‘three‘] 

　　　　切片操作符中的第一個數（冒號之前）表示切片開始的位置，第二個數（冒號之後）表示切片到哪裏結束。 如果不指定第一個數，Python就從

　　序列首開始。如果沒有指定第二個數，則Python會停止在序列尾。 註意，返回的序列從開始位置 開始 ，剛好在結束位置之前 結束。即開始位置是

　　包含在序列切片中的，而結束位置被排斥在切片外。 可以用負數做切片。負數用在從序列尾開始計算的位置。
　　5. 綁定

　　　　當創建一個對象並給它賦一個變量的時候，這個變量僅僅“指向”那個對象，而不是表示這個對象本身！ 也就是說，變量名指向計算機中存儲那個

　　對象的內存，這被稱作名稱到對象的綁定。

　　　　如果要復制一個列表或者類似的序列或者其他復雜的對象（不是如整數那樣的簡單對象），那麽必須使用切片操作符來取得拷貝。

七、面向對象編程

　　python支持面向對象編程；類和對象是面向對象編程的兩個主要方面，類創建一個新的類型，對象是這個類的實例。

　　對象可以使用普通的屬於對象的變量存儲數據，屬於對象或類的變量被稱為域；對象也可以使用屬於類的函數，這樣的函數稱為類的方法；域和方法可以合稱為類的屬性。

　　域有兩種類型--屬於實例的或屬於類本身；它們分別被稱為實例變量和類變量。

　　類使用關鍵字class創建，類的域和方法被列在一個縮進塊中。

　　類的方法必須有一個額外的第一個參數，但是在調用時不為這個參數賦值，這個特殊變量指對象本身，按照慣例它的名稱是self，類似C#中的this。

class Animal:
    pass #empty block

　　__init__方法　　在類的一個對象被創建時調用該方法；相當於c++中的構造函數。

　　__del__方法　　在類的對象被銷毀時調用該方法；相當於c++中的析構函數。在使用del刪除一個對象時也就調用__del__方法。

　　Python中所有的類成員(包括數據成員)都是public的；只有一個例外，如果使用的數據成員以雙下劃線為前綴，則為私有變量。

class Person:
    Count = 0
    def __init__(self, name, age):
        Person.Count += 1
        self.name = name
        self.__age = age

p = Person("peter", 25)
p1 = Person("john", 20)

print Person.Count #2
print p.name #peter
print p.__age #AttributeError: Person instance has no attribute ‘__age‘

　　繼承：為了使用繼承，基類的名稱作為一個元組跟在類名稱的後面；python支持多重繼承。下面是一個關於繼承的例子：

 1 class SchoolMember:
 2     ‘‘‘Represent any school member.‘‘‘
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6         print "Initializing a school member."
 7     
 8     def tell(self):
 9         ‘‘‘Tell my details‘‘‘
10         print "Name: %s, Age: %s, " % (self.name, self.age),
11 
12 class Teacher(SchoolMember):
13     ‘‘‘Represent a teacher.‘‘‘
14     def __init__(self, name, age, salary):
15         SchoolMember.__init__(self, name, age)
16         self.salary = salary
17         print "Initializing a teacher"
18 
19     def tell(self):
20         SchoolMember.tell(self)
21         print "Salary: %d" % self.salary
22 
23 class Student(SchoolMember):
24     ‘‘‘Represent a student.‘‘‘
25     def __init__(self, name, age, marks):
26         SchoolMember.__init__(self, name, age)
27         self.marks = marks
28         print "Initializing a student"
29 
30     def tell(self):
31         SchoolMember.tell(self)
32         print "Marks: %d" % self.marks
33 
34 print SchoolMember.__doc__
35 print Teacher.__doc__
36 print Student.__doc__
37 
38 t = Teacher("Mr. Li", 30, 9000)
39 s = Student("Peter", 25, 90)
40 
41 members = [t, s]
42 
43 for m in members:
44     m.tell()

　　程序輸出如下：

Represent any school member.
Represent a teacher.
Represent a student.
Initializing a school member.
Initializing a teacher
Initializing a school member.
Initializing a student
Name: Mr. Li, Age: 30,  Salary: 9000
Name: Peter, Age: 25,  Marks: 90

八、輸入/輸出

　　程序與用戶的交互需要使用輸入/輸出，主要包括控制臺和文件；對於控制臺可以使用raw_input和print，也可使用str類。raw_input(xxx)輸入xxx然後讀取用戶的輸入並返回。

　　1. 文件輸入/輸出

　　　　可以使用file類打開一個文件，使用file的read、readline和write來恰當的讀寫文件。對文件讀寫能力取決於打開文件時使用的模式，常用模式

　　有讀模式("r")、寫模式("w")、追加模式("a")，文件操作之後需要調用close方法來關閉文件。

 1 test = ‘‘‘ 2 This is a program about file I/O.
 3 
 4 Author: Peter Zhange
 5 Date: 2011/12/25
 6 ‘‘‘
 7 
 8 f = file("test.txt", "w") # open for writing, the file will be created if the file doesn‘t exist
 9 f.write(test) # write text to file
10 f.close() # close the file
11 
12 f = file("test.txt") # if no mode is specified, the default mode is readonly.
13 
14 while True:
15     line = f.readline()
16     if len(line) == 0:  # zero length indicates the EOF of the file
17         break
18     print line,
19 
20 f.close()

　　2. 存儲器

　　　　python提供一個標準的模塊，成為pickle，使用它可以在一個文件中存儲任何python對象，之後可以完整的取出來，這被稱為持久地存儲對象；還有另外一個模塊成為cPickle，它的功能和pickle完全一樣，只不過它是用c寫的，要比pickle速度快(大約快1000倍)。

import cPickle

datafile = "data.data"

namelist = ["peter", "john", "king"]

f = file(datafile, "w")
cPickle.dump(namelist, f)
f.close()

del namelist

f = file(datafile)
storednamelist = cPickle.load(f)

print storednamelist
#[‘peter‘, ‘john‘, ‘king‘]

九、異常

　　當程序中出現某些異常的狀況時，異常就發生了。python中可以使用try ... except 處理。

try:
    print 1/0
except ZeroDivisionError, e:
    print e
except:
    print "error or exception occurred."

#integer division or modulo by zero

　　可以讓try ... except 關聯上一個else，當沒有異常時則執行else。

　　我們可以定義自己的異常類，需要繼承Error或Exception。

class ShortInputException(Exception):
    ‘‘‘A user-defined exception class‘‘‘
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input("enter someting-->")
    if len(s) < 3:
        raise ShortInputException(len(s), 3)
except EOFError:
    print "why you input an EOF?"
except ShortInputException, ex:
    print "The lenght of input is %d, was expecting at the least %d" % (ex.length, ex.atleast)
else:
    print "no exception"
#The lenght of input is 1, was expecting at the least 3

　　try...finally

try:
    f = file("test.txt")
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        time.sleep(2)
        print line,
finally:
    f.close()
    print "Cleaning up..."

十、Python標準庫

　　Python標準庫是隨Pthon附帶安裝的，包含了大量極其有用的模塊。

　　1. sys模塊　　sys模塊包含系統對應的功能

• sys.argv　　---包含命令行參數，第一個參數是py的文件名
• sys.platform　　---返回平臺類型
• sys.exit([status])　　---退出程序，可選的status(範圍：0-127)：0表示正常退出，其他表示不正常，可拋異常事件供捕獲
• sys.path　　　　---程序中導入模塊對應的文件必須放在sys.path包含的目錄中，使用sys.path.append添加自己的模塊路徑
• sys.modules　　---This is a dictionary that maps module names to modules which have already been loaded
• sys.stdin,sys.stdout,sys.stderr　　---包含與標準I/O 流對應的流對象

s = sys.stdin.readline()

sys.stdout.write(s)

　　2. os模塊　　該模塊包含普遍的操作系統功能

• os.name字符串指示你正在使用的平臺。比如對於Windows，它是‘nt‘，而對於Linux/Unix用戶，它是‘posix‘
• os.getcwd()函數得到當前工作目錄，即當前Python腳本工作的目錄路徑
• os.getenv()和os.putenv()函數分別用來讀取和設置環境變量
• os.listdir()返回指定目錄下的所有文件和目錄名
• os.remove()函數用來刪除一個文件
• os.system()函數用來運行shell命令
• os.linesep字符串給出當前平臺使用的行終止符。例如，Windows使用‘\r\n‘，Linux使用‘\n‘而Mac使用‘\r‘
• os.sep 操作系統特定的路徑分割符
• os.path.split()函數返回一個路徑的目錄名和文件名
• os.path.isfile()和os.path.isdir()函數分別檢驗給出的路徑是一個文件還是目錄
• os.path.existe()函數用來檢驗給出的路徑是否真地存在

十一、其他

　　1. 一些特殊的方法

名稱	說明
__init__(self,...)	這個方法在新建對象恰好要被返回使用之前被調用。
__del__(self)	恰好在對象要被刪除之前調用。
__str__(self)	在我們對對象使用print語句或是使用str()的時候調用。
__lt__(self,other)	當使用 小於 運算符（<）的時候調用。類似地，對於所有的運算符（+，>等等）都有特殊的方法。
__getitem__(self,key)	使用x[key]索引操作符的時候調用。
__len__(self)	對序列對象使用內建的len()函數的時候調用。

　　下面的類中定義了上表中的方法：

class Array:
    __list = []

    def __init__(self):
        print "constructor"

    def __del__(self):
        print "destructor"

    def __str__(self):
        return "this self-defined array class"

    def __getitem__(self, key):
        return self.__list[key]

    def __len__(self):
        return len(self.__list)

    def Add(self, value):
        self.__list.append(value)

    def Remove(self, index):
        del self.__list[index]

    def DisplayItems(self):
        print "show all items----"
        for item in self.__list:
            print item

arr = Array()   #constructor
print arr    #this self-defined array class
print len(arr)   #0
arr.Add(1)
arr.Add(2)
arr.Add(3)
print len(arr)   #3
print arr[0]   #1
arr.DisplayItems()
#show all items----
#1
#2
#3
arr.Remove(1)
arr.DisplayItems()
#show all items----
#1
#3
#destructor

　　2. 綜合列表

　　　　通過列表綜合，可以從一個已有的列表導出一個新的列表。

list1 = [1, 2, 3, 4, 5]
list2 = [i*2 for i in list1 if i > 3]

print list1  #[1, 2, 3, 4, 5]
print list2  #[8, 10]

　　3. 函數接收元組/列表/字典

　　　　當函數接收元組或字典形式的參數的時候，有一種特殊的方法，使用*和**前綴。該方法在函數需要獲取可變數量的參數的時候特別有用。

　　　　由於在args變量前有*前綴，所有多余的函數參數都會作為一個元組存儲在args中。如果使用的是**前綴，多余的參數則會被認為是一個字典

　　的鍵/值對。

def powersum(power, *args):
    total = 0
    for i in args:
        total += pow(i, power)
    return total

print powersum(2, 1, 2, 3)   #14 

def displaydic(**args):
    for key,value in args.items():
        print "key:%s;value:%s" % (key, value)


displaydic(a="one", b="two", c="three")
#key:a;value:one
#key:c;value:three
#key:b;value:two

　　4. lambda

　　　　lambda語句被用來創建新的函數對象，並在運行時返回它們。lambda需要一個參數，後面僅跟單個表達式作為函數體，而表達式的值被這個

　　新建的函數返回。 註意，即便是print語句也不能用在lambda形式中，只能使用表達式。

func = lambda s: s * 3
print func("peter ")  #peter peter peter

func2 = lambda a, b: a * b
print func2(2, 3)  #6

　　5. exec/eval

　　　　exec語句用來執行儲存在字符串或文件中的Python語句；eval語句用來計算存儲在字符串中的有效Python表達式。

cmd = "print ‘hello world‘"
exec cmd   #hello world

expression = "10 * 2 + 5"
print eval(expression)    #25

　　6. assert

　　　　assert語句用來斷言某個條件是真的，並且在它非真的時候引發一個錯誤--AssertionError。

flag = True

assert flag == True

try:
    assert flag == False
except AssertionError, err:
    print "failed"
else:
    print "pass"

　　7. repr函數

　　　　repr函數用來取得對象的規範字符串表示。反引號（也稱轉換符）可以完成相同的功能。

　　　　註意，在大多數時候有eval(repr(object)) == object。

　　　　可以通過定義類的__repr__方法來控制對象在被repr函數調用的時候返回的內容。

arr = [1, 2, 3]
print `arr`    #[1, 2, 3]
print repr(arr)    #[1, 2, 3]

Python 基本語法