Python：Python學習總結

背景

PHP的$和->讓人輸入的手疼（PHP確實非常簡潔和強大，適合WEB程式設計），Ruby的#、@、@@也好不到哪裡（OO人員最該學習的一門語言）。

Python應該是寫起來最舒服的動態語言了，一下是一些讀書筆記，最後會介紹一下高階的用法：Mixin、Open Class、Meta Programming和AOP。

文中有些地方是用2.7開發的，如果您安裝的是3.x，有幾點需要注意：

• print "xxx" 要換成 print("xxx")
• __metaclass__ = type 刪除掉。

型別和表示式部分

你好，世界！

1 # coding=utf-8
2 
3 print "你好，世界。"

乘方

1 print 2**10

變數

1 var = 1
2 print var
3 
4 var  = "段光偉"
5 print var

注：這裡的var = xxxx不叫變數賦值，而叫變數繫結，python維護了一個符號表（變數名）以及符合對應的值，這個對應關係就叫做繫結，一個符號可以繫結任意型別的值。

獲取使用者輸入

1 #獲取使用者輸入
2 x = input("x:")
3 y = input("y:")
4 
5 print x*y

注：input接受的是Python程式碼，輸入中可以訪問當前執行環境中的變數，如果想獲取原始輸入需要使用raw_input。

函式定義

1 def say_b():
2     print "b"

強型別

Javascript和Php是弱型別的，Python和Ruby是強型別的。弱型別允許不安全的型別轉換，強型別則不允許。

1 #1 + “1” 這行程式碼在Python中會報錯。
2 print 1 + int("1")
3 print str(1) + "1"

字串

1 #字串
2 print ''''    段
3             光
4             偉'''
5 print r'C:\log.txt'
6 print 'C:\\log.txt'

序列

這裡先介紹三種序列：列表、元祖和字串。

序列通用操作

 1 seq = "0123456789"
 2 print seq[0] #從0開始編碼。
 3 print seq[-1] #支援倒著數數，-1代表倒數第一。
 4 print seq[1:5] #支援分片操作，seq[start:end]，start會包含在結果中，end不會包含在結果中。
 5 print seq[7:] #seq[start:end]中的end可以省略。
 6 print seq[-3:] #分片也支援負數。
 7 print seq[:3] #seq[start:end]中的start也可以省略。
 8 print seq[:] #全部省略會複製整個序列。
 9 print seq[::2] #支援步長。
10 print seq[::-2] #支援負步長。
11 print seq[9:1:-1] #支援負步長。
12 print [1, 2, 3] + [4, 5, 6] # 序列支援相加，這解釋了為啥字串可以相加。
13 print [1, 2, 3] * 3 #序列支援相乘，這解釋了為啥字串可以相稱。
14 print [None] * 10 #生成一個空序列。
15 print 1 in [1, 2, 3] #成員判斷。

可變的列表

 1 data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 2 
 3 data[0] = "a" #修改元素。
 4 print data
 5 data[0] = 0
 6 
 7 del data[10] #刪除元素。
 8 print data
 9 
10 del data[8:] #分片刪除。
11 print data
12 
13 data[8:] = [8, 9, 10] #分片賦值
14 print data

不可變的元祖

1 print (1, 2) #元祖以小括號形式宣告。
2 print (1,) #一個元素的元祖。

字串格式化

1 print "% 10s" % "----"
2 
3 print '''
4 %(title)s
5 %(body)s
6 ''' % {"title": "標題", "body": "內容"}

字典

1 print {"title": "title", "body": "body"}
2 print dict(title = "title", body = "body")
3 print dict([("title", "title"), ("body", "body")])

1 dic = {"title": "title", "body": "body"};
2 print dic["title"]
3 del dic["title"]
4 print dic

print 語句

1 print 'a', 'b' #print可以接受多個引數，引數的輸出之間以空格相隔。
2 print 'a', #如果逗號之後沒有引數，則不會換行。
3 print 'b'

序列解包

1 x, y, z = 1, 2, 3
2 print x, y, z
3 (x, y, z) = (1, 2, 3)
4 print x, y, z
5 (x, y, z) = [1, 2, 3]
6 print x, y, z

bool值

 1 #下面的輸入全部返回False。
 2 print(bool(None))
 3 print(bool(()))
 4 print(bool([]))
 5 print(bool({}))
 6 print(bool(""))
 7 print(bool(0))
 8 
 9 #雖然這些值在條件運算中會當做False，但是本身不等於False。
10 print(True and "")
11 print(not "")
12 print(False == "")
13 print(False == 0) #0除外，bool型別的內部表示就是int型別。

bool運算

1 print(0 < 1 < 10)
2 print(0 < 1 and 1 < 10)
3 print(not(0 > 1 > 10))
4 print(not(0 > 1 or 1 > 10))

語句塊

:開始語句快，縮排的所有內容都是一個語句塊。

1 if(10 > 1):
2     print("10 > 1")
3 else:
4     print("不可能發生")

三元運算子

1 print("10 > 1" if 10 > 1 else "不可能發生")

相等比較

1 #== 和 is的差別，==比較的是內容，is比較的是引用。
2 x = [1, 2, 3]
3 y = x
4 z = [1, 2, 3]
5 print(x == y)
6 print(x == z)
7 print(x is y)
8 print(x is z)

迴圈

 1 #for迴圈類似C#的foreach，注意for後面是沒有括號的，python真是能簡潔就儘量簡潔。
 2 for x in range(1, 10):
 3     print(x)
 4 
 5 for key in {"x":"xxx"}:
 6     print(key)
 7 
 8 for key, value in {"x":"xxx"}.items():
 9     print(key, value)
10 
11 for x, y, z in [["a", 1, "A"],["b", 2, "B"]]:
12     print(x, y, z)

 1 #帶索引的遍歷
 2 for index, value in enumerate(range(0, 10)):
 3     print(index, value)
 4 
 5 #好用的zip方法
 6 for x, y in zip(range(1, 10), range(1, 10)):
 7     print(x, y)
 8 
 9 #迴圈中的的else子句
10 from math import sqrt
11 for item in range(99, 1, -1):
12     root = sqrt(item)
13     if(root == int(root)):
14         print(item)
15         break
16 else:
17     print("沒有執行break語句。")

pass、exec和eval

1 #pass、exec、eval
2 if(1 == 1):
3     pass
4 
5 exec('print(x)', {"x": "abc"})
6 print(eval('x*2', {"x": 5}))

函式部分

形參和實參之間是按值傳遞的，當然有些型別的值是引用（物件、列表和字典等）。

 1 # 基本函式定義。
 2 def func():
 3     print("func")
 4 
 5 func()
 6 
 7 # 帶返回值的函式。
 8 def func_with_return():
 9     return ("func_with_return")
10 
11 print(func_with_return())
12 
13 # 帶多個返回值的函式。
14 def func_with_muti_return():
15     return ("func_with_muti_return", "func_with_muti_return")
16 
17 print(func_with_muti_return())
18 
19 # 位置引數
20 def func_with_parameters(x, y):
21     print(x, y)
22 
23 func_with_parameters(1, 2)
24 
25 # 收集多餘的位置引數
26 def func_with_collection_rest_parameters(x, y, *rest):
27     print(x, y)
28     print(rest)
29 
30 func_with_collection_rest_parameters(1, 2, 3, 4, 5)
31 
32 #命名引數
33 def func_with_named_parameters(x, y, z):
34     print(x, y, z)
35 
36 func_with_named_parameters(z = 1, y = 2, x = 3)
37 
38 #預設值引數
39 def func_with_default_value_parameters(x, y, z = 3):
40     print(x, y, z)
41 
42 func_with_default_value_parameters(y = 2, x = 1)
43 
44 #收集命名引數
45 def func_with_collection_rest_naned_parameters(*args, **named_agrs):
46     print(args)
47     print(named_agrs)
48 
49 func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)
50 
51 #集合扁平化
52 func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4, "y": 4, "z": 6}) #這會導致args[0]指向第一個實參，args[1]指向第二個實參。
53 func_with_collection_rest_naned_parameters(*[1, 2, 3], **{"x": 4, "y": 4, "z": 6}) #這裡的執行相當於func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)。

作用域

 1 # coding=utf-8
 2 
 3 # 只有函式執行才會開啟一個作用域。
 4 if(2 > 1):
 5     x = 1
 6 
 7 print(x) # 會輸出1。
 8 
 9 
10 # 使用vars()函式可以訪問當前作用域包含的變數。
11 x = 1
12 print(vars()["x"])
13 
14 # 使用globals()函式可以訪問全域性作用域。
15 x = 1
16 
17 def func():
18     print(globals()["x"])
19 
20 func()
21 
22 # 使用locals()函式可以訪問區域性作用域。
23 def func():
24     x = 2
25     print(locals()["x"])
26 
27 func()
28 
29 # 每個函式定義時都會記住所在的作用域。
30 # 函式執行的時候會開啟一個新的作用域，函式內變數訪問的規則是：先訪問當前作用域，如果沒有就訪問函式定義時的作用域，遞迴直到全域性作用域。
31 x = 1
32 
33 def func():
34     y = 2
35     print(x, y) # 輸出1 2
36 
37 func()
38 
39 
40 # 變數賦值始終訪問的是當前作用域。
41 x = 1
42 
43 def func():
44     x = 2
45     y = 2
46     print(x, y) # 輸出2 2
47 
48 func()
49 print(x) #輸出 1
50 
51 # 區域性變數會覆蓋隱藏全域性變數，想訪問全域性變數可以採用global關鍵字或globals()函式。
52 x = 1
53 
54 def func():
55     global x
56     x = 2
57     y = 2
58     print(x, y) # 輸出2 2
59 
60 func()
61 print(x) #輸出 2

 1 # python支援閉包
 2 def func(x):
 3     def inner_func(y):
 4         print(x + y)
 5 
 6     return inner_func
 7 
 8 inner_func = func(10)
 9 inner_func(1)
10 inner_func(2)

1 #函式作為物件
2 def func(fn, arg):
3     fn(arg)
4 
5 func(print, "hello")
6 func(lambda arg : print(arg), "hello")

模組

幾個模組相關的規則：

• 一個檔案代表一個模組。
• 可以用import module匯入模組，也可以用form module import member匯入模組的成員。
• 如果匯入的是module，必須使用module.member進行訪問；如果匯入的member，可以直接訪問member。
• 匯入的module或member都會變成當前module的member。

b.py

1 # coding=utf-8
2 
3 print __name__
4 
5 def say_b():
6     print "b"

a.py

1 # coding=utf-8
2 
3 import b
4 from b import *
5 
6 print __name__
7 
8 def say_a():
9     print "a"

test.py

1 # coding=utf-8
2 
3 import a
4 
5 print __name__
6 
7 a.say_a();
8 a.say_b();
9 a.b.say_b()

輸出

1 b
2 a
3 __main__
4 a
5 b
6 b

異常管理

 1 # coding=utf-8
 2 
 3 # 自定義異常
 4 class HappyException(Exception):
 5     pass
 6 
 7 # 引發和捕獲異常
 8 try:
 9     raise HappyException
10 except:
11     print("HappyException")
12 
13 try:
14     raise HappyException()
15 except:
16     print("HappyException")
17 
18 # 捕獲多種異常
19 try:
20     raise HappyException
21 except (HappyException, TypeError):
22     print("HappyException")
23 
24 # 重新引發異常
25 try:
26     try:
27         raise HappyException
28     except (HappyException, TypeError):
29         raise
30 except:
31     print("HappyException")
32 
33 #訪問異常例項
34 try:
35     raise HappyException("都是我的錯")
36 except (HappyException, TypeError), e:
37     print(e)
38 
39 #按型別捕獲
40 try:
41     raise HappyException
42 except HappyException:
43     print("HappyException")
44 except TypeError:
45     print("TypeError")
46 
47 #全面捕獲
48 try:
49     raise HappyException
50 except:
51     print("HappyException")
52 
53 #沒有異常的else
54 try:
55     pass
56 except:
57     print("HappyException")
58 else:
59     print("沒有異常")
60 
61 #總會執行的final
62 try:
63     pass
64 except:
65     print("HappyException")
66 else:
67     print("沒有異常")
68 finally:
69     print("總會執行")

面向物件

先上一張圖

幾個規則：

1. 一切都是物件，python中一切都是物件，每個物件都包含一個__class__屬性以標記其所屬型別。
2. 每個物件（記得一切都是物件啊）都包含一個__dict__屬性以儲存所有屬性和方法。
3. 每個型別都包含一個__bases__屬性以標記其父類。
4. 屬性和方法的訪問規則：依次搜尋instance、子類、父類、父類的父類、直到object的__dict__，如果找到就返回。
5. 屬性和方法的設定規則：直接設定instance.__dict__。
6. 以上屬性和方法訪問或設定規則沒有考慮“魔法方法”，下文會解釋。

示例

 1 # coding=utf-8
 2 
 3 __metaclass__ = type
 4 
 5 # 型別定義
 6 # 例項方法必的第一個引數代表型別例項，類似其他語言的this。
 7 class Animal:
 8     name = "未知" # 屬性定義。
 9 
10     def __init__(self, name): #構造方法定義。
11         self.name = name
12 
13     def getName(self): # 例項方法定義。
14         return self.name
15 
16     def setName(self, value):
17         self.name = value
18 
19 print(Animal.name) # 未知
20 print(Animal.__dict__["name"]) # 未知
21 
22 animal = Animal("狗狗")
23 print(animal.name) # 狗狗
24 print(animal.__dict__["name"]) # 狗狗
25 print(Animal.name) # 未知
26 print(Animal.__dict__["name"]) # 未知
27 print(animal.__class__.name) # 未知
28 print(animal.__class__.__dict__["name"]) # 未知

1 # 型別定義中的程式碼會執行，是一個獨立的作用域。
2 class TestClass:
3     print("型別定義中") #型別定義中

繫結方法和未繫結方法

 1 class TestClass:
 2     def method(self):
 3         print("測試方法")
 4 
 5 test = TestClass()
 6 print(TestClass.method) #<unbound method TestClass.method>
 7 print(test.method) #<bound method TestClass.method of <__main__.TestClass object at 0x021B46D0>>
 8 
 9 TestClass.method(test) #測試方法
10 test.method() #測試方法

繫結方法已經綁定了物件示例，呼叫的時刻不用也不能傳入self引數了。

注：使用物件訪問例項方法為何會返回繫結方法？這個還得等到學完“魔法方法”才能解釋，內部其實是攔截對方法成員的訪問，返回了一個Callable物件。

私有成員

1 # 私有成員
2 class TestClass:
3     __private_property = 1
4 
5     def __private_method():
6         pass
7 
8 print(TestClass.__dict__) # {'__module__': '__main__', '_TestClass__private_method': <function __private_method at 0x0212B970>, '_TestClass__private_property': 1

難怪訪問不了了，名稱已經被修改了，增加了訪問的難度而已。

多重繼承

 1 #多重繼承
 2 class Base1:
 3     pass
 4 
 5 class Base2:
 6     pass
 7 
 8 class Child(Base2, Base1):
 9     pass
10 
11 child = Child()
12 print(isinstance(child, Child)) # True
13 print(isinstance(child, Base2)) # True
14 print(isinstance(child, Base1)) # True

如果繼承的多個型別之間有重名的成員，左側的基類優先順序要高，上例子Base2會勝出。

介面那裡去了，鴨子型別比介面更好用。

 1 class TestClass1:
 2     def say(self):
 3         print("我是鴨子1")
 4 
 5 class TestClass2:
 6     def say(self):
 7         print("我是鴨子2")
 8 
 9 def duck_say(duck):
10     duck.say()
11 
12 duck_say(TestClass1()) # 我是鴨子1
13 duck_say(TestClass2()) # 我是鴨子2

呼叫父類

 1 # 呼叫父類
 2 class Base:
 3     def say(self):
 4         print("Base")
 5 
 6 class Child(Base):
 7     def say(self):
 8         Base.say(self)
 9         super(Child, self).say()
10         print("Child")
11 
12 child = Child()
13 child.say()

魔法方法

詳細內容參考：http://www.rafekettler.com/magicmethods.html。

物件構造相關：__new__、__init__、__del__。

 1 from os.path import join
 2 
 3 class FileObject:
 4     '''Wrapper for file objects to make sure the file gets closed on deletion.'''
 5 
 6     def __init__(self, filepath='~', filename='sample.txt'):
 7         # open a file filename in filepath in read and write mode
 8         self.file = open(join(filepath, filename), 'r+')
 9 
10     def __del__(self):
11         self.file.close()
12         del self.file

運算子過載：所有運算子都能過載。

 1 class Word(str):
 2     '''Class for words, defining comparison based on word length.'''
 3 
 4     def __new__(cls, word):
 5         # Note that we have to use __new__. This is because str is an immutable
 6         # type, so we have to initialize it early (at creation)
 7         if ' ' in word:
 8             print "Value contains spaces. Truncating to first space."
 9             word = word[:word.index(' ')] # Word is now all chars before first space
10         return str.__new__(cls, word)
11 
12     def __gt__(self, other):
13         return len(self) > len(other)
14 
15     def __lt__(self, other):
16         return len(self) < len(other)
17 
18     def __ge__(self, other):
19         return len(self) >= len(other)
20 
21     def __le__(self, other):
22         return len(self) <= len(other)
23 
24 print(Word("duan") > Word("wei"))

屬性訪問。

 1 class AccessCounter:
 2     '''A class that contains a value and implements an access counter.
 3     The counter increments each time the value is changed.'''
 4 
 5     def __init__(self, value):
 6         super(AccessCounter, self).__setattr__('counter', 0)
 7         super(AccessCounter, self).__setattr__('value', value)
 8 
 9     def __setattr__(self, name, value):
10         if name == 'value':
11             super(AccessCounter, self).__setattr__('counter', self.counter + 1)
12         # Make this unconditional.
13         # If you want to prevent other attributes to be set, raise AttributeError(name)
14         super(AccessCounter, self).__setattr__(name, value)
15 
16     def __delattr__(self, name):
17         if name == 'value':
18             super(AccessCounter, self).__setattr__('counter', self.counter + 1)
19         super(AccessCounter, self).__delattr__(name)

集合實現。

 1 class FunctionalList:
 2     '''A class wrapping a list with some extra functional magic, like head,
 3     tail, init, last, drop, and take.'''
 4 
 5     def __init__(self, values=None):
 6         if values is None:
 7             self.values = []
 8         else:
 9             self.values = values
10 
11     def __len__(self):
12         return len(self.values)
13 
14     def __getitem__(self, key):
15         # if key is of invalid type or value, the list values will raise the error
16         return self.values[key]
17 
18     def __setitem__(self, key, value):
19         self.values[key] = value
20 
21     def __delitem__(self, key):
22         del self.values[key]
23 
24     def __iter__(self):
25         return iter(self.values)
26 
27     def __reversed__(self):
28         return FunctionalList(reversed(self.values))
29 
30     def append(self, value):
31         self.values.append(value)
32     def head(self):
33         # get the first element
34         return self.values[0]
35     def tail(self):
36         # get all elements after the first
37         return self.values[1:]
38     def init(self):
39         # get elements up to the last
40         return self.values[:-1]
41     def last(self):
42         # get last element
43         return self.values[-1]
44     def drop(self, n):
45         # get all elements except first n
46         return self.values[n:]
47     def take(self, n):
48         # get first n elements
49         return self.values[:n]

可呼叫物件，像方法一樣呼叫物件。

 1 class Entity:
 2     '''Class to represent an entity. Callable to update the entity's position.'''
 3 
 4     def __init__(self, size, x, y):
 5         self.x, self.y = x, y
 6         self.size = size
 7 
 8     def __call__(self, x, y):
 9         '''Change the position of the entity.'''
10         self.x, self.y = x, y
11         print(x, y)
12 
13 entity = Entity(5, 1, 1)
14 entity(2, 2)

資源管理

 1 class Closer:
 2     def __enter__(self):
 3         return self
 4 
 5     def __exit__(self, exception_type, exception_val, trace):
 6         print("清理完成")
 7         return True;
 8 
 9 with Closer() as closer:
10     pass

物件描述符。

 1 class Meter(object):
 2     '''Descriptor for a meter.'''
 3 
 4     def __init__(self, value=0.0):
 5         self.value = float(value)
 6     def __get__(self, instance, owner):
 7         return self.value
 8     def __set__(self, instance, value):
 9         self.value = float(value)
10 
11 class Foot(object):
12     '''Descriptor for a foot.'''
13 
14     def __get__(self, instance, owner):
15         return instance.meter * 3.2808
16     def __set__(self, instance, value):
17         instance.meter = float(value) / 3.2808
18 
19 class Distance(object):
20     '''Class to represent distance holding two descriptors for feet and
21     meters.'''
22     meter = Meter()
23     foot = Foot()

Mixin（也叫摻入）

摻入模組：playable.py

1 # coding=utf-8
2 
3 def paly(self):
4     print("遊戲中...")

摻入目標模組：test.py

1 # coding=utf-8
2 
3 class Animal:
4     from playable import paly
5 
6 animal = Animal()
7 animal.paly() # 遊戲中...

Open Class（開啟型別，從新定義成員）

 1 #coding:utf-8
 2 
 3 class TestClass:
 4     def method1(self):
 5         print("方法1")
 6 
 7 def method2(self):
 8     print("方法2")
 9 
10 TestClass.method2 = method2
11 
12 test = TestClass()
13 test.method1() # 方法1
14 test.method2() # 方法2

Meta Programming（超程式設計）

1 TestClass = type("TestClass", (object,), {
2     "say": lambda self : print("你好啊")
3 })
4 
5 test = TestClass()
6 test.say()

 1 def getter(name):
 2     def getterMethod(self):
 3         return self.__getattribute__(name)
 4     return getterMethod
 5 
 6 def setter(name):
 7     def setterMethod(self, value):
 8         self.__setattr__(name, value)
 9     return setterMethod    
10 
11 class TestClass:
12     getName = getter("name")
13     setName = setter("name")
14 
15 test = TestClass()
16 test.setName("段光偉")
17 print(test.getName())

AOP（面向切面程式設計）

內容比較多，單獨寫了一篇文章：http://www.cnblogs.com/happyframework/p/3260233.html。

備註

Python在作用域方面非常接近Javascript，型別和物件系統也有幾份相似（雖然Javascript是基於原型的），Javascript、PHP、Python和Ruby這幾門語言交叉學習會帶來意想不到的收穫。