一、面向?qū)ο缶幊袒A(chǔ)
1、python之定義類并創(chuàng)建實例
在Python中，類通過 class 關(guān)鍵字定義。以 Person 為例，定義一個Person類如下：
class Person(object):
pass
按照 Python 的編程習慣，類名以大寫字母開頭，緊接著是(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
實例的屬性可以像普通變量一樣進行操作：
xiaohong.grade = xiaohong.grade + 1
3、python中初始化實例屬性
雖然我們可以自由地給一個實例綁定各種屬性，但是，現(xiàn)實世界中，一種類型的實例應該擁有相同名字的屬性。例如，Person類應該在創(chuàng)建的時候就擁有 name、gender 和 birth 屬性，怎么辦？
在定義 Person 類時，可以為Person類添加一個特殊的__init__()方法，當創(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ù)參數(shù)則可以自由指定，和定義函數(shù)沒有任何區(qū)別。
相應地，創(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'
要特別注意的是，初學者定義__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)
這會導致創(chuàng)建失敗或運行不正常，因為第一個參數(shù)name被Python解釋器傳入了實例的引用，從而導致整個方法的調(diào)用參數(shù)位置全部沒有對上。
4、python中訪問限制
我們可以給一個實例綁定很多屬性，如果有些屬性不希望被外部訪問到怎么辦？
Python對屬性權(quán)限的控制是通過屬性名來實現(xiàn)的，如果一個屬性由雙下劃線開頭(__)，該屬性就無法被外部訪問?？蠢樱?/p>
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的類中被稱為特殊屬性，有很多預定義的特殊屬性可以使用，通常我們不要把普通屬性用"__xxx__"定義。
以單下劃線開頭的屬性"_xxx"雖然也可以被外部訪問，但是，按照習慣，他們不應該被外部訪問。
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'
因為類屬性只有一份，所以，當Person類的address改變時，所有實例訪問到的類屬性都改變了。
6、python中類屬性和實例屬性名字沖突怎么辦
修改類屬性會導致所有實例訪問到的類屬性全部都受影響，但是，如果在實例變量上修改類屬性會發(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'。
可見，當實例屬性和類屬性重名時，實例屬性優(yōu)先級高，它將屏蔽掉對類屬性的訪問。
當我們把 p1 的 address 實例屬性刪除后，訪問 p1.address 就又返回類屬性的值 'Earth'了：
del p1.address
print p1.address
# => Earth
可見，千萬不要在實例上修改類屬性，它實際上并沒有修改類屬性，而是給實例綁定了一個實例屬性。
7、python中定義實例方法
一個實例的私有屬性就是以‘“__”開頭的屬性，無法被外部訪問，那這些屬性定義有什么用？
雖然私有屬性無法從外部訪問，但是，從類的內(nèi)部是可以訪問的。除了可以定義實例的屬性外，還可以定義實例的方法。
實例的方法就是在類中定義的函數(shù)，它的第一個參數(shù)永遠是 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ù)封裝的形式除了能保護內(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()
通過標記一個 @classmethod，該方法將綁定到 Person 類上，而非類的實例。類方法的第一個參數(shù)將傳入類本身，通常將參數(shù)名命名為 cls，上面的 cls.count 實際上相當于 Person.count。
因為是在類上調(diào)用，而非實例上調(diào)用，因此類方法無法獲得任何實例變量，只能獲得類的引用。
二、類的繼承
1、python中什么是繼承
繼承：新類不必從頭編寫，可以直接從現(xiàn)有類繼承，就自動擁有了現(xiàn)有類的所有功能，只需要編寫需要的新功能即可。
繼承優(yōu)點：復用已有代碼，自動擁有了現(xiàn)有類的所有功能，可精簡代碼。
1、如果一個實例屬于一個子類，則它也屬于一個父類；如果實例屬于父類，則它不一定屬于子類。
2、子類和父類是is關(guān)系
is關(guān)系指的是：黃鸝是鳥，卻不能說鳥是黃鸝
has關(guān)系指的是：學生有一本書，不能說學生是一本書
兩個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)將返回當前類繼承的父類，即 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')
當我們拿到變量 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ò)服務器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服務器運行模式有 多進程ForkingMixin 和 多線程ThreadingMixin兩種。
要創(chuàng)建多進程模式的 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屬性，如果屬性不存在，就返回默認值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)用對應的特殊方法。
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() 按照默認的比較函數(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 進行比較，如果 self 應該排在前面，就返回 -1，如果 s 應該排在前面，就返回1，如果兩者相當，返回 0。
Student類實現(xiàn)了按name進行排序：
>>> 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 類，把名字傳進去：
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
