目錄
__slots__
不是在class中創建方法而是創建了一個鏈接把外部的set_age 方法用鏈接指到Student內
公共部分：
from types import MethodType
#創建一個方法
def set_age(self, arg):
self.age = arg
#創建一個類
class Student(object):
pass
給實例綁定一個屬性：
>>> s = Student()
>>> s.name = 'Michael' # 動態給實例綁定一個屬性
>>> print(s.name)
Michael
給實例綁定一個方法：
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 給實例綁定一個方法
>>> s.set_age(25) # 調用實例方法
>>> s.age # 測試結果
25
給一個實例綁定的方法，對另一個實例是不起作用的
爲了給所有實例都綁定方法，可以給class綁定方法：
Student.set_score = set_score
Student.set_age = MethodType(set_age,Student)
如果我們想要限制實例的屬性，定義class的時候，定義一個特殊的__slots__變量，來限制該class實例能添加的屬性：
class Student(object):
__slots__ = ('name', 'age') # 用tuple定義允許綁定的屬性名稱
>>> s = Student() # 創建新的實例
>>> s.name = 'Michael' # 綁定屬性'name'
>>> s.age = 25 # 綁定屬性'age'
>>> s.score = 99 # 綁定屬性'score'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
__slots__定義的屬性僅對當前類實例起作用，對繼承的子類是不起作用的：
除非在子類中也定義__slots__，這樣，子類實例允許定義的屬性就是自身的__slots__加上父類的__slots__。
使用@property
爲了限制score的範圍，可以通過一個set_score()方法來設置成績，再通過一個get_score()來獲取成績，這樣，在set_score()方法裏，就可以檢查參數：
class Student(object):
def get_score(self):
return self._score
def set_score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
上面的調用方法又略顯複雜，沒有直接用屬性這麼直接簡單。對於類的方法，裝飾器一樣起作用。Python內置的@property裝飾器就是負責把一個方法變成屬性調用的：
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
#使用
>>> s = Student()
>>> s.score = 60 # OK，實際轉化爲s.set_score(60)
>>> s.score # OK，實際轉化爲s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又創建了另一個裝飾器@score.setter，負責把一個setter方法變成屬性賦值，於是，我們就擁有一個可控的屬性操作
還可以定義只讀屬性，只定義getter方法，不定義setter方法就是一個只讀屬性：
class Student(object):
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2014 - self._birth
上面的birth是可讀寫屬性，而age就是一個只讀屬性
__str__和__repr__()
定義一個Student類，打印一個實例：
>>> class Student(object):
... def __init__(self, name):
... self.name = name
...
>>> print(Student('Michael'))
<__main__.Student object at 0x109afb190>
打印出一堆<__main__.Student object at 0x109afb190>，不好看。
怎麼才能打印得好看呢？只需要定義好__str__()方法，返回一個好看的字符串就可以了：
>>> class Student(object):
... def __init__(self, name):
... self.name = name
... def __str__(self):
... return 'Student object (name: %s)' % self.name
...
>>> print(Student('Michael'))
Student object (name: Michael)
但是直接敲變量，不用print 打印出的也不好看，因爲直接顯示變量調用__repr__()，兩者的區別是__str__()返回用戶看到的字符串，而__repr__()返回程序開發者看到的字符串，也就是說，__repr__()是爲調試服務的。
可在代碼中加入
__repr__ = __str__
__iter__和__next__
如果一個類想被用於for ... in循環，類似list或tuple那樣，就必須實現一個__iter__()方法，該方法返回一個迭代對象，然後，Python的for循環就會不斷調用該迭代對象的__next__()方法拿到循環的下一個值，直到遇到StopIteration錯誤時退出循環
以斐波那契數列爲例，寫一個Fib類，可以作用於for循環：
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化兩個計數器a，b
def __iter__(self):
return self # 實例本身就是迭代對象，故返回自己
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 計算下一個值
if self.a > 100000: # 退出循環的條件
raise StopIteration()
return self.a # 返回下一個值
#使用
>>> for n in Fib():
... print(n)
1
1
2
3
5
...
46368
75025
__getitem__
Fib實例雖然能作用於for循環，但把它當成list來使用還是不行，比如，取第5個元素：
>>> Fib()[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'Fib' object does not support indexing
要表現得像list那樣按照下標取出元素，需要實現__getitem__()方法：
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
#使用
>>> f = Fib()
>>> f[0]
1
但是list的切片方法：對於Fib卻報錯。原因是__getitem__()傳入的參數可能是一個int，也可能是一個切片對象slice，所以要做判斷：
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
#使用
>>> f = Fib()
>>> f[0:5]
[1, 1, 2, 3, 5]
此外，如果把對象看成dict，__getitem__()的參數也可能是一個可以作key的object。例如str，
與之對應的是__setitem__()方法，把對象視作list或dict來對集合賦值。最後，還有一個__delitem__()方法，用於刪除某個元素。
總之，通過上面的方法，我們自己定義的類表現得和Python自帶的list、tuple、dict沒什麼區別
__getattr__
當我們調用類的方法或屬性時，如果不存在，就會報錯.要避免這個錯誤，除了可以加上一個score屬性外，那就是寫一個__getattr__()方法，動態返回一個屬性,返回函數也是完全可以的：
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
注意，只有在沒有找到屬性的情況下，才調用__getattr__
注意到任意調用如s.abc都會返回None，這是因爲我們定義的__getattr__默認返回就是None。要讓class只響應特定的幾個屬性，我們就要按照約定，拋出AttributeError的錯誤：
class Student(object):
def __getattr__(self, attr):
if attr=='age':
return lambda: 25
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
如果要寫SDK，給每個URL對應的API都寫一個方法，那得累死，而且，API一旦改動，SDK也要改。
利用完全動態的__getattr__，我們可以寫出一個鏈式調用：
class Chain(object):
def __init__(self, path=''):
self._path = path
def __getattr__(self, path):
return Chain('%s/%s' % (self._path, path))
def __str__(self):
return self._path
__repr__ = __str__
>>> Chain().status.user.timeline.list
'/status/user/timeline/list'
還有些REST API會把參數放到URL中，比如GitHub的API：
GET /users/:user/repos
調用時，需要把:user替換爲實際用戶名。如果我們能寫出這樣的鏈式調用：
Chain().users('michael').repos
__call__
任何類，只需要定義一個__call__()方法，就可以直接對實例進行調用。請看示例：
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
調用方式如下：
>>> s = Student('Michael')
>>> s() # self參數不要傳入
My name is Michael.
__call__()還可以定義參數。對實例進行直接調用就好比對一個函數進行調用一樣
通過callable()函數，我們就可以判斷一個對象是否是“可調用”對象，比如函數和我們上面定義的帶有__call__()的類實例：
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False