一、面向?qū)ο缶幊袒A(chǔ)
1、python之定義類并創(chuàng)建實例
在Python中，類通過 class 關(guān)鍵字定義综慎。以 Person 為例，定義一個Person類如下：
class Person(object):
pass
按照 Python 的編程習(xí)慣勤庐，類名以大寫字母開頭示惊，緊接著是(object)，表示該類是從哪個類繼承下來的愉镰。類的繼承將在后面的章節(jié)講解米罚，現(xiàn)在我們只需要簡單地從object類繼承。
有了Person類的定義岛杀，就可以創(chuàng)建出具體的xiaoming阔拳、xiaohong等實例。創(chuàng)建實例使用 類名+()类嗤，類似函數(shù)調(diào)用的形式創(chuàng)建：
xiaoming = Person()
xiaohong = Person()
注：要打印實例糊肠，直接使用print語句；要比較兩個實例是否相等遗锣，用==操作符货裹。
2、python中創(chuàng)建實例屬性
雖然可以通過Person類創(chuàng)建出xiaoming精偿、xiaohong等實例弧圆，但是這些實例看上除了地址不同外，沒有什么其他不同笔咽。在現(xiàn)實世界中搔预，區(qū)分xiaoming、xiaohong要依靠他們各自的名字叶组、性別拯田、生日等屬性。
如何讓每個實例擁有各自不同的屬性甩十？由于Python是動態(tài)語言船庇，對每一個實例吭产，都可以直接給他們的屬性賦值，例如鸭轮，給xiaoming這個實例加上name臣淤、gender和birth屬性：
xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'
給xiaohong加上的屬性不一定要和xiaoming相同：
xiaohong = Person()
xiaohong.name = 'Xiao Hong'
xiaohong.school = 'No. 1 High School'
xiaohong.grade = 2
實例的屬性可以像普通變量一樣進(jìn)行操作：
xiaohong.grade = xiaohong.grade + 1
3、python中初始化實例屬性
雖然我們可以自由地給一個實例綁定各種屬性窃爷，但是邑蒋，現(xiàn)實世界中，一種類型的實例應(yīng)該擁有相同名字的屬性吞鸭。例如寺董，Person類應(yīng)該在創(chuàng)建的時候就擁有 name覆糟、gender 和 birth 屬性刻剥，怎么辦？
在定義 Person 類時滩字，可以為Person類添加一個特殊的__init__()方法造虏，當(dāng)創(chuàng)建實例時，__init__()方法被自動調(diào)用麦箍，我們就能在此為每個實例都統(tǒng)一加上以下屬性：
class Person(object):
def __init__(self, name, gender, birth):
self.name = name
self.gender = gender
self.birth = birth
__init__() 方法的第一個參數(shù)必須是 self（也可以用別的名字漓藕，但建議使用習(xí)慣用法），后續(xù)參數(shù)則可以自由指定挟裂，和定義函數(shù)沒有任何區(qū)別享钞。
相應(yīng)地，創(chuàng)建實例時诀蓉，就必須要提供除 self 以外的參數(shù)：
xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
有了__init__()方法栗竖，每個Person實例在創(chuàng)建時，都會有 name渠啤、gender 和 birth 這3個屬性狐肢，并且，被賦予不同的屬性值沥曹，訪問屬性使用.操作符：
print xiaoming.name
# 輸出 'Xiao Ming'
print xiaohong.birth
# 輸出 '1992-2-2'
要特別注意的是份名，初學(xué)者定義__init__()方法常常忘記了 self 參數(shù)：
>>> class Person(object):
... def __init__(name, gender, birth):
... pass
...
>>> xiaoming = Person('Xiao Ming', 'Male', '1990-1-1')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 3 arguments (4 given)
這會導(dǎo)致創(chuàng)建失敗或運行不正常，因為第一個參數(shù)name被Python解釋器傳入了實例的引用妓美，從而導(dǎo)致整個方法的調(diào)用參數(shù)位置全部沒有對上僵腺。
4、python中訪問限制
我們可以給一個實例綁定很多屬性壶栋，如果有些屬性不希望被外部訪問到怎么辦辰如？
Python對屬性權(quán)限的控制是通過屬性名來實現(xiàn)的，如果一個屬性由雙下劃線開頭(__)委刘，該屬性就無法被外部訪問丧没∮ソ罚看例子：
class Person(object):
def __init__(self, name):
self.name = name
self._title = 'Mr'
self.__job = 'Student'
p = Person('Bob')
print p.name
# => Bob
print p._title
# => Mr
print p.__job
# => Error
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute '__job'
可見，只有以雙下劃線開頭的"__job"不能直接被外部訪問呕童。
但是漆际，如果一個屬性以"__xxx__"的形式定義，那它又可以被外部訪問了夺饲，以"__xxx__"定義的屬性在Python的類中被稱為特殊屬性奸汇，有很多預(yù)定義的特殊屬性可以使用，通常我們不要把普通屬性用"__xxx__"定義往声。
以單下劃線開頭的屬性"_xxx"雖然也可以被外部訪問擂找，但是，按照習(xí)慣浩销，他們不應(yīng)該被外部訪問贯涎。
5、python中創(chuàng)建類屬性
類是模板慢洋，而實例則是根據(jù)類創(chuàng)建的對象塘雳。
綁定在一個實例上的屬性不會影響其他實例，但是普筹，類本身也是一個對象败明，如果在類上綁定一個屬性，則所有實例都可以訪問類的屬性太防，并且妻顶，所有實例訪問的類屬性都是同一個！也就是說蜒车，實例屬性每個實例各自擁有讳嘱，互相獨立，而類屬性有且只有一份醇王。
定義類屬性可以直接在 class 中定義：
class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name
因為類屬性是直接綁定在類上的呢燥，所以，訪問類屬性不需要創(chuàng)建實例寓娩，就可以直接訪問：
print Person.address
# => Earth
對一個實例調(diào)用類的屬性也是可以訪問的叛氨，所有實例都可以訪問到它所屬的類的屬性：
p1 = Person('Bob')
p2 = Person('Alice')
print p1.address
# => Earth
print p2.address
# => Earth
由于Python是動態(tài)語言，類屬性也是可以動態(tài)添加和修改的：
Person.address = 'China'
print p1.address
# => 'China'
print p2.address
# => 'China'
因為類屬性只有一份棘伴，所以寞埠，當(dāng)Person類的address改變時，所有實例訪問到的類屬性都改變了焊夸。
6仁连、python中類屬性和實例屬性名字沖突怎么辦
修改類屬性會導(dǎo)致所有實例訪問到的類屬性全部都受影響，但是，如果在實例變量上修改類屬性會發(fā)生什么問題呢饭冬？
class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name
p1 = Person('Bob')
p2 = Person('Alice')
print 'Person.address = ' + Person.address
p1.address = 'China'
print 'p1.address = ' + p1.address
print 'Person.address = ' + Person.address
print 'p2.address = ' + p2.address
結(jié)果如下：
Person.address = Earth
p1.address = China
Person.address = Earth
p2.address = Earth
我們發(fā)現(xiàn)使鹅，在設(shè)置了 p1.address = 'China'后，p1訪問 address 確實變成了 'China'昌抠，但是患朱，Person.address和p2.address仍然是'Earch'，怎么回事炊苫？
原因是 p1.address = 'China'并沒有改變 Person 的 address裁厅，而是給 p1這個實例綁定了實例屬性address ，對p1來說侨艾，它有一個實例屬性address（值是'China'）执虹，而它所屬的類Person也有一個類屬性address，所以:
訪問 p1.address 時唠梨，優(yōu)先查找實例屬性袋励，返回'China'。
訪問 p2.address 時姻成，p2沒有實例屬性address插龄，但是有類屬性address，因此返回'Earth'科展。
可見，當(dāng)實例屬性和類屬性重名時糠雨，實例屬性優(yōu)先級高才睹，它將屏蔽掉對類屬性的訪問。
當(dāng)我們把 p1 的 address 實例屬性刪除后甘邀，訪問 p1.address 就又返回類屬性的值 'Earth'了：
del p1.address
print p1.address
# => Earth
可見琅攘，千萬不要在實例上修改類屬性，它實際上并沒有修改類屬性松邪，而是給實例綁定了一個實例屬性坞琴。
7、python中定義實例方法
一個實例的私有屬性就是以‘“__”開頭的屬性逗抑，無法被外部訪問剧辐，那這些屬性定義有什么用？
雖然私有屬性無法從外部訪問邮府，但是荧关，從類的內(nèi)部是可以訪問的。除了可以定義實例的屬性外褂傀，還可以定義實例的方法忍啤。
實例的方法就是在類中定義的函數(shù)，它的第一個參數(shù)永遠(yuǎn)是 self仙辟，指向調(diào)用該方法的實例本身同波，其他參數(shù)和一個普通函數(shù)是完全一樣的：
class Person(object):
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name
get_name(self)就是一個實例方法鳄梅，它的第一個參數(shù)是self。init(self, name)其實也可看做是一個特殊的實例方法未檩。
調(diào)用實例方法必須在實例上調(diào)用：
p1 = Person('Bob')
print p1.get_name() # self不需要顯式傳入
# => Bob
在實例方法內(nèi)部卫枝，可以訪問所有實例屬性，這樣讹挎，如果外部需要訪問私有屬性校赤，可以通過方法調(diào)用獲得，這種數(shù)據(jù)封裝的形式除了能保護(hù)內(nèi)部數(shù)據(jù)一致性外筒溃，還可以簡化外部調(diào)用的難度马篮。
8、python中方法也是屬性
我們在 class 中定義的實例方法其實也是屬性怜奖，它實際上是一個函數(shù)對象：
class Person(object):
def __init__(self, name, score):
self.name = name
self.score = score
def get_grade(self):
return 'A'
p1 = Person('Bob', 90)
print p1.get_grade
# => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
print p1.get_grade()
# => A
也就是說浑测，p1.get_grade返回的是一個函數(shù)對象，但這個函數(shù)是一個綁定到實例的函數(shù)歪玲，p1.get_grade()才是方法調(diào)用迁央。
因為方法也是一個屬性，所以滥崩，它也可以動態(tài)地添加到實例上岖圈，只是需要用 types.MethodType() 把一個函數(shù)變?yōu)橐粋€方法：
import types
def fn_get_grade(self):
if self.score >= 80:
return 'A'
if self.score >= 60:
return 'B'
return 'C'
class Person(object):
def __init__(self, name, score):
self.name = name
self.score = score
p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()
# => A
p2 = Person('Alice', 65)
print p2.get_grade()
# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 因為p2實例并沒有綁定get_grade
給一個實例動態(tài)添加方法并不常見，直接在class中定義要更直觀钙皮。
9蜂科、python中定義類方法
和屬性類似，方法也分實例方法和類方法短条。
在class中定義的全部是實例方法导匣，實例方法第一個參數(shù) self 是實例本身。
要在class中定義類方法茸时，需要這么寫：
class Person(object):
count = 0
@classmethod
def how_many(cls):
return cls.count
def __init__(self, name):
self.name = name
Person.count = Person.count + 1
print Person.how_many()
p1 = Person('Bob')
print Person.how_many()
通過標(biāo)記一個 @classmethod贡定，該方法將綁定到 Person 類上，而非類的實例可都。類方法的第一個參數(shù)將傳入類本身缓待，通常將參數(shù)名命名為 cls，上面的 cls.count 實際上相當(dāng)于 Person.count汹粤。
因為是在類上調(diào)用命斧，而非實例上調(diào)用，因此類方法無法獲得任何實例變量嘱兼，只能獲得類的引用国葬。
二、類的繼承
1、python中什么是繼承
繼承：新類不必從頭編寫汇四，可以直接從現(xiàn)有類繼承接奈，就自動擁有了現(xiàn)有類的所有功能，只需要編寫需要的新功能即可通孽。
繼承優(yōu)點：復(fù)用已有代碼序宦，自動擁有了現(xiàn)有類的所有功能，可精簡代碼背苦。
1互捌、如果一個實例屬于一個子類，則它也屬于一個父類行剂；如果實例屬于父類秕噪，則它不一定屬于子類。
2厚宰、子類和父類是is關(guān)系
is關(guān)系指的是：黃鸝是鳥腌巾，卻不能說鳥是黃鸝
has關(guān)系指的是：學(xué)生有一本書，不能說學(xué)生是一本書
兩個has關(guān)系的類不能繼承铲觉，只能以屬性組合到類中澈蝙，如使用Book類的bookName-> self.book=Book(bookName)
繼承特點：
1、總是從某個類繼承撵幽，沒有合適的類時使用object類繼承
2灯荧、調(diào)用super().__init__方法（初始化父類）
如Student類從父類繼承name和gender：super(Student,self).init(name,gender)
2、python中繼承一個類
如果已經(jīng)定義了Person類并齐，需要定義新的Student和Teacher類時漏麦，可以直接從Person類繼承：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
定義Student類時，只需要把額外的屬性加上况褪，例如score：
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
一定要用 super(Student, self).__init__(name, gender) 去初始化父類，否則更耻，繼承自 Person 的 Student 將沒有 name 和 gender测垛。
函數(shù)super(Student, self)將返回當(dāng)前類繼承的父類，即 Person 秧均，然后調(diào)用__init__()方法食侮，注意self參數(shù)已在super()中傳入，在__init__()中將隱式傳遞目胡，不需要寫出（也不能寫）锯七。
3、python中判斷類型
函數(shù)isinstance()可以判斷一個變量的類型誉己，既可以用在Python內(nèi)置的數(shù)據(jù)類型如str眉尸、list、dict，也可以用在我們自定義的類噪猾，它們本質(zhì)上都是數(shù)據(jù)類型霉祸。
假設(shè)有如下的 Person、Student 和 Teacher 的定義及繼承關(guān)系如下：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
class Teacher(Person):
def __init__(self, name, gender, course):
super(Teacher, self).__init__(name, gender)
self.course = course
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
當(dāng)我們拿到變量 p袱蜡、s丝蹭、t 時，可以使用 isinstance 判斷類型：
>>> isinstance(p, Person)
True # p是Person類型
>>> isinstance(p, Student)
False # p不是Student類型
>>> isinstance(p, Teacher)
False # p不是Teacher類型
這說明在繼承鏈上坪蚁，一個父類的實例不能是子類類型奔穿，因為子類比父類多了一些屬性和方法。
我們再考察 s ：
>>> isinstance(s, Person)
True # s是Person類型
>>> isinstance(s, Student)
True # s是Student類型
>>> isinstance(s, Teacher)
False # s不是Teacher類型
s 是Student類型敏晤，不是Teacher類型贱田，這很容易理解。但是茵典，s 也是Person類型湘换，因為Student繼承自Person，雖然它比Person多了一些屬性和方法统阿，但是彩倚，把 s 看成Person的實例也是可以的。
這說明在一條繼承鏈上扶平，一個實例可以看成它本身的類型帆离，也可以看成它父類的類型。
4结澄、python中多態(tài)
類具有繼承關(guān)系哥谷，并且子類類型可以向上轉(zhuǎn)型看做父類類型，如果我們從 Person 派生出 Student和Teacher 麻献，并都寫了一個 whoAmI() 方法：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def whoAmI(self):
return 'I am a Person, my name is %s' % self.name
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
def whoAmI(self):
return 'I am a Student, my name is %s' % self.name
class Teacher(Person):
def __init__(self, name, gender, course):
super(Teacher, self).__init__(name, gender)
self.course = course
def whoAmI(self):
return 'I am a Teacher, my name is %s' % self.name
在一個函數(shù)中们妥，如果我們接收一個變量 x，則無論該 x 是 Person勉吻、Student還是 Teacher监婶，都可以正確打印出結(jié)果：
def who_am_i(x):
print x.whoAmI()
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
who_am_i(p)
who_am_i(s)
who_am_i(t)
運行結(jié)果：
I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice
這種行為稱為多態(tài)。也就是說齿桃，方法調(diào)用將作用在 x 的實際類型上惑惶。s 是Student類型，它實際上擁有自己的 whoAmI()方法以及從 Person繼承的 whoAmI方法短纵，但調(diào)用 s.whoAmI()總是先查找它自身的定義带污，如果沒有定義，則順著繼承鏈向上查找香到，直到在某個父類中找到為止鱼冀。
由于Python是動態(tài)語言报破，所以，傳遞給函數(shù) who_am_i(x)的參數(shù) x 不一定是 Person 或 Person 的子類型雷绢。任何數(shù)據(jù)類型的實例都可以泛烙，只要它有一個whoAmI()的方法即可：
class Book(object):
def whoAmI(self):
return 'I am a book'
這是動態(tài)語言和靜態(tài)語言（例如Java）最大的差別之一。動態(tài)語言調(diào)用實例方法翘紊，不檢查類型蔽氨，只要方法存在，參數(shù)正確帆疟，就可以調(diào)用鹉究。
5、python中多重繼承
除了從一個父類繼承外踪宠，Python允許從多個父類繼承自赔，稱為多重繼承。
多重繼承的繼承鏈就不是一棵樹了柳琢，它像這樣：
class A(object):
def __init__(self, a):
print 'init A...'
self.a = a
class B(A):
def __init__(self, a):
super(B, self).__init__(a)
print 'init B...'
class C(A):
def __init__(self, a):
super(C, self).__init__(a)
print 'init C...'
class D(B, C):
def __init__(self, a):
super(D, self).__init__(a)
print 'init D...'</pre>
看下圖:
像這樣绍妨，D 同時繼承自 B 和 C，也就是 D 擁有了 A柬脸、B他去、C 的全部功能。多重繼承通過 super()調(diào)用init()方法時倒堕，A 雖然被繼承了兩次灾测，但init()只調(diào)用一次：
>>> d = D('d')
init A...
init C...
init B...
init D...</pre>
多重繼承的目的是從兩種繼承樹中分別選擇并繼承出子類，以便組合功能使用垦巴。
舉個例子媳搪，Python的網(wǎng)絡(luò)服務(wù)器有TCPServer、UDPServer骤宣、UnixStreamServer秦爆、UnixDatagramServer，而服務(wù)器運行模式有 多進(jìn)程ForkingMixin 和 多線程ThreadingMixin兩種憔披。
要創(chuàng)建多進(jìn)程模式的 TCPServer：
class MyTCPServer(TCPServer, ForkingMixin):
要創(chuàng)建多線程模式的 UDPServer：
class MyUDPServer(UDPServer, ThreadingMixin):
如果沒有多重繼承鲜结，要實現(xiàn)上述所有可能的組合需要 4x2=8 個子類。
6活逆、python中獲取對象信息
拿到一個變量，除了用 isinstance() 判斷它是否是某種類型的實例外拗胜，還有沒有別的方法獲取到更多的信息呢蔗候？
例如，已有定義：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
def whoAmI(self):
return 'I am a Student, my name is %s' % self.name
首先可以用 type() 函數(shù)獲取變量的類型埂软，它返回一個 Type 對象：
>>> type(123)
<type 'int'>
>>> s = Student('Bob', 'Male', 88)
>>> type(s)
<class '__main__.Student'>
其次锈遥，可以用 dir() 函數(shù)獲取變量的所有屬性：
>>> dir(123) # 整數(shù)也有很多屬性...
['__abs__', '__add__', '__and__', '__class__', '__cmp__', ...]
>>> dir(s)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'gender', 'name', 'score', 'whoAmI']
對于實例變量纫事，dir()返回所有實例屬性，包括__class__這類有特殊意義的屬性所灸。注意到方法whoAmI也是 s 的一個屬性丽惶。
如何去掉__xxx__這類的特殊屬性，只保留我們自己定義的屬性爬立？回顧一下filter()函數(shù)的用法钾唬。
dir()返回的屬性是字符串列表，如果已知一個屬性名稱侠驯，要獲取或者設(shè)置對象的屬性抡秆，就需要用 getattr() 和 setattr()函數(shù)了：
>>> getattr(s, 'name') # 獲取name屬性
'Bob'
>>> setattr(s, 'name', 'Adam') # 設(shè)置新的name屬性
>>> s.name
'Adam'
>>> getattr(s, 'age') # 獲取age屬性，但是屬性不存在吟策，報錯：
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'
>>> getattr(s, 'age', 20) # 獲取age屬性儒士，如果屬性不存在，就返回默認(rèn)值20：
20
三檩坚、定制類
1着撩、python中的特殊方法
1.python能夠?qū)⑷我庾兞孔兂蓅tr是因為任何數(shù)據(jù)類型的實例都有一個特殊方法：__str__()，其類似java中的toString()方法匾委。
2.python的特殊方法：
(1)特殊方法定義在class中
(2)不需要直接調(diào)用
(3)python的某些函數(shù)或操作符會自動調(diào)用對應(yīng)的特殊方法拖叙。
3.正確實現(xiàn)特殊方法：
(1)只需編寫用到的特殊方法
(2)有關(guān)聯(lián)性的特殊方法都必須實現(xiàn) 如：
__getattr__
__setattr__
__delattr__
這三個方法需要同時編寫。
2剩檀、python中 str和repr
如果要把一個類的實例變成 str憋沿，就需要實現(xiàn)特殊方法__str__()：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def __str__(self):
return '(Person: %s, %s)' % (self.name, self.gender)
現(xiàn)在，在交互式命令行下用 print 試試：
>>> p = Person('Bob', 'male')
>>> print p
(Person: Bob, male)
但是沪猴，如果直接敲變量 p：
>>> p
<main.Person object at 0x10c941890>
似乎str() 不會被調(diào)用辐啄。
因為 Python 定義了__str__()和__repr__()兩種方法，__str__()用于顯示給用戶运嗜，而__repr__()用于顯示給開發(fā)人員壶辜。
有一個偷懶的定義__repr__的方法：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def __str__(self):
return '(Person: %s, %s)' % (self.name, self.gender)
__repr__ = __str__
3、python中 cmp
對 int担租、str 等內(nèi)置數(shù)據(jù)類型排序時砸民，Python的 sorted() 按照默認(rèn)的比較函數(shù) cmp 排序，但是奋救，如果對一組 Student 類的實例排序時岭参，就必須提供我們自己的特殊方法 __cmp__()：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def __str__(self):
return '(%s: %s)' % (self.name, self.score)
__repr__ = __str__
def __cmp__(self, s):
if self.name < s.name:
return -1
elif self.name > s.name:
return 1
else:
return 0
上述 Student 類實現(xiàn)了__cmp__()方法，__cmp__用實例自身self和傳入的實例 s 進(jìn)行比較尝艘，如果 self 應(yīng)該排在前面演侯，就返回 -1，如果 s 應(yīng)該排在前面背亥，就返回1秒际，如果兩者相當(dāng)悬赏，返回 0。
Student類實現(xiàn)了按name進(jìn)行排序：
>>> L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 77)]
>>> print sorted(L)
[(Alice: 77), (Bob: 88), (Tim: 99)]
注意: 如果list不僅僅包含 Student 類娄徊，則__cmp__可能會報錯：
L = [Student('Tim', 99), Student('Bob', 88), 100, 'Hello']
print sorted(L)
請思考如何解決闽颇。
4、python中 len
如果一個類表現(xiàn)得像一個list寄锐，要獲取有多少個元素兵多，就得用len() 函數(shù)。
要讓 len() 函數(shù)工作正常锐峭，類必須提供一個特殊方法__len__()中鼠，它返回元素的個數(shù)。
例如沿癞，我們寫一個 Students 類援雇，把名字傳進(jìn)去：
class Students(object):
def __init__(self, *args):
self.names = args
def __len__(self):
return len(self.names)
只要正確實現(xiàn)了__len__()方法，就可以用len()函數(shù)返回Students實例的“長度”：
>>> ss = Students('Bob', 'Alice', 'Tim')
>>> print len(ss)
3
