類代碼編寫細節
一、class語句
一般形式
class??? <name>(superclass,...):
??? data=value
??? def mothod(self,...):
??? ??? self.member=value
在class語句內，任何賦值語句都會產生類屬性。
類幾乎就是命名空間，也就是定義變量名(屬性)的工具，把數據和邏輯導出給客戶端。
怎么樣從class語句得到命名空間的呢？
過程如下。就像模塊文件，位于class語句主體中的語句會建立起屬性。當python執行class語句時（不是調用類）
會從頭到尾執行其主體內的所有語句。在這個過程中，進行賦值運算會在這個類的作用域中創建變量名，從而成為對應
類對象中的屬性。因為，類就像模塊和函數:
*就像函數一樣。class語句是作用域，由內嵌的賦值語句建立變量名，就存在這個本地作用域內。
*就像模塊內的變量名，在class語句內賦值的變量名會變成類對象中的屬性。
class是復合語句，任何種類的語句都可以位于其主體內：print ,=,if,def等。當class語句自身運行時，class語句內的所有
語句都會執行。在class語句內賦值的變量名會創建類屬性，而內嵌的def語句則會創建類方法，其他的賦值語句也可以制作屬性。
class頂層的賦值語句定義的屬性可以用于管理貫穿所有實例的信息。

二、方法
方法位于class語句的主體內是由def語句建立的函數對象。抽象角度，方法替實例對象提供了要繼承的行為。程序角度，
方法的工作方式與簡單函數完全一致，只有一個重要差異:方法的第一個參數總是接受方法調用的隱形主體，也就是實例對象。
Python會自動把實例方法的調用對應到類方法函數。
方法調用需要通過實例，如：
instance.method(arg...)
這會自動翻譯成以下形式的類方法函數調用：
class.method(instance,args...)
class通過Python繼承搜索流程找出方法名稱所在之處。事實上，這兩種調用形式在Python都有效。
類方法的第一個參數通常稱為self。這個參數提供方法一個鉤子，從而返回調用的主體，也就是實例對象：
因為類可以產生許多實例對象，所以需要這個參數來管理每個實例彼此各不相同的數據。
Python中self一定要在程序代碼中明確地寫出：方法一定要通過self來取出或修改由當前方法調用或正在處理的實例屬性。
這個變量名的存在，會讓你明確腳本中使用的是實例屬性名稱，而不是本地作用域或全局作用域中的變量名。

1、調用超類的構造器
方法一般是通過實例調用的。不過通過類調用【class.method(instance實例,args...)】方法也扮演了一些特殊角色。
常見的如構造器方法。像其他屬性一樣___init__方法是由繼承進行查找。也就是說，在構造時,Python會找出并且只調用
一個__init__。如果要保證子類的構造方法也會執行超類構造器的邏輯，一般都必須通過類明確地調用超類的__init__方法。
class Super:
??? def __init__(self,x):
??? ??? ...default code...
class Sub(Super):
??? def __init__(self,x,y):
??? ??? Super.__init__(self,x)? ###還是有用到的地方。
??? ??? ...custom code...
I=Sub(1,2)
疑問：子類__init__方法不會繼承超類的嗎？需要是明確手動繼承?這個是重載吧？
動手驗證
>>> class Super:
...???? def __init__(self):
...???????????? self.name='diege'
...
>>> class Sub(Super):
...???? def setage(self,age):
...???????????? self.age=age
...
>>> x=Sub()?
>>> x.name
'diege
實驗證明子類的__init__方法也會繼承，沒有任何特殊，超類的任何屬性子類都會繼承，前面的例子是重載。
前面的例子是代碼有可能直接調用運算符重載方法的環境之一。
如果真的想運行超類的構造方法并做適當的修改，自然只能用這種方法進行調用：沒有這樣的調用，子類會
完全取代（覆蓋）超類的構造器，或者子類沒有設置__init__構造器的情況下完全繼承超類的構造器方法。

2、其他方法調用的可能。
這種通過類調用方法的模式（類中調用類的方法（不一定自己）），是擴展繼承方法行為（而不是完全取代）的
一般基礎。Python2.2新增的選項：靜態方法、可以編寫不預期第一個參數為實例對象的方法。這類方法可像簡單
的無實例的函數那樣運作，其變量名屬于其所在類的作用域。不過，這是高級的選用擴展功能。通常情況，一定要
為方法傳入實例，無論通過實例還是類調用。

3、繼承
像class語句這樣的命名空間工具的重點就是支持變量名繼承。這里擴展關于屬性繼承的一些機制和角色。
在Python中，當對對象進行點號運算時，就會發生繼承，而且涉及到搜索屬性定義樹（一或多個命名空間）。每次
使用obecj.attr形式的表達式時（objecj是實例或類對象），Python會從頭到尾搜索命名空間樹，先從對象開始，
找到第一個attr為止。這包括在方法中對self屬性的引用。因為樹中較低的定義會覆蓋較高的定義，繼承構成了
專有化的基礎。

4、屬性樹的構造
命名空間樹構造以及填入變量名的方式，通常來說：
【*】實例屬性是由對方法內self屬性進行賦值運算而生成的
【*】類屬性是通過class語句內頂層的語句（賦值語句）而生成的
【*】超類鏈接通過class語句首行的括號內列出類而生成的。

5、繼承方法的專有化
繼承樹搜索模式，變成了將系統專有化的最好方式。因為繼承會先在子類尋找變量名，然后才查找超類，子類就可以對超類的屬性重新定義來取代默認的行為。把系統做成類的層次，再新增外部的子類來對其進行擴展，而不是在原處修改已存在的邏輯。重新定義繼承變量名的概念因出了各種專有化技術。
>>> class Super:
...???? def method(self):
...???????????? print 'in Super.method'
...
>>> class Sub(Super):?????????????????
...???? def method(self):?????????????
...???????????? print 'start Sub.method'
...???????????? Super.method(self)??? #直接調用超類的方法
...???????????? print 'ending Sub.method'????
...
>>> Z=Super()
>>> Z.method()
in Super.metho
>>> X=Sub()
>>> X.method()
start Sub.method
in Super.method
ending Sub.method
直接調用超類的方法是這里的重點。Sub類以其專有化的版本取代了Super的方法函數。但是取代時，Sub又回調了Super所導出的版本，從而實現了默認的行為，換句話說，Sub.mothod只是擴展了Super.mothod的行為，而不是完全取代他。這種擴展編碼模式常常用于構造器方法。
6、類接口技術
class Super:
??????? def method(self):
??????????????? print "in Super.method"
??????? def delegate(self):
??????????????? self.action()
class Inheritor(Super):
??????? pass
class Replacer(Super):
??????? def method(self):
??????????????? print "in Replacer.method"
class Extender(Super):
??????? def method(self):
??????????????? print "starting Extender.method"
??????????????? Super.method(self)
??????????????? print "ending Extender.method"
class Provider(Super):
??????? def action(self):
??????????????? print "in Provider.method"
if __name__=='__main__':
??????? for C in (Inheritor,Replacer,Extender):
??????????????? print '\n'+C.__name__+'...'
??????????????? C().method() ??? #C后面的括號表面是類時實例，這里是創建實例和方法調用一起了。分解C=Inheritor(),C.method()
??? ??? ??? ???
??????????????? print '\nProvider...'
??????????????? x=Provider()??? #創建實例對象
??????????????? x.delegate()??? #實例對象條用delegate方法，delegate方法通過實例的action方法實現
結果
Inheritor...
in Super.method
Provider...
in Provider.method
Replacer...
in Replacer.method
Provider...
in Provider.method
Extender...
starting Extender.method
in Super.method
ending Extender.method
Provider...
in Provider.method
說明
Super
??? 定義了一個method函數和一個delegate函數
Inheritor
??? 沒有提供任何新的變量名，因此獲得Super中定義的一切內容
Replacer
??? 用自己的版本覆蓋Super的method
Extender
??? 覆蓋并回調默認的method，從而定制Super的method
Provider
??? 現實Super的delegate方法預期的action方法.這里有點不好理解
Provider繼承了Super的method和delegate方法并增加了action方法，而delegate方法是調用實例的action方法實現的。
尾部的自我測試程序代碼在for循環中建立了三個不同的實例。因為類是對象，可以將他們放入元組中，并可以通過這樣的方式創建實例。類有特殊的屬性__name__類的名字，就像模塊一樣有__name__屬性模塊的名字。類中默認為類行首行中的類名稱的字符串。
7、抽象超類
上例中Provider類如何工作的？當通過Provider類的實例調用delegate方法時,兩個獨立的繼承搜索會發生：
（1）最初x.delegate的調用中，Pythn會搜索Provider實例和它上層的對象。知道在Super中找到delegate方法。實例x
會像往常一樣傳遞給這個方法self參數
（2）Super.delegate方法中,self.action會對self及其它上層的對象啟動新的獨立繼承搜索，因為self指的是Provider
實例，就會找到Provider中的action方法。
抽象類就是會調用方法的類，但沒有繼承或定義該方法，而是期待該方法由子類填補。當行為無法預測，非得等到更為具體的子類編寫時才知道，可用這種方式把類通用化。這種“填空”的代碼結構一般就是OOP軟件的框架。從delegate方法的角度來看，這個例子中的超類有時也稱作是抽象類--也就是類的部分行為默認是由其子類所提供的。如果預期的方法沒有在子類定義，當繼承搜索失敗時，Python會引發為定義
變量名的異常。類的編寫者偶爾會使用assert語句，使這種子類需求更為明顯，或者引發內置的異常NotImplementedError
class Super:
??????? def method(self):
??????????????? print "in Super.method"
??????? def delegate(self):
??????????????? self.action()
??? ??? def action(self):
??????????????? assert 0, 'action must be defind'
如果表達式運算結構為假，就會引發帶有錯誤信息的異常。在這里表達式總是為假(0）。因為如果沒有方法重新定義，
繼承就會找到這里的版本，觸發錯誤信息。

三、運算符重載
重載的關鍵概念
*運算符重載讓類攔截常規的Python運算。
*類可重載所有Python表達式運算。
*類可重載打印，函數調用，屬性點號運算等運算。
*重載使類實例的行為像內置類型。
*重載是通過提供特殊名稱的類方法來實現的。
如果類中提供了某些特殊名稱的方法，當類實例出現在運算有關的表達式的時候，Python就會自動調用這些方法。
類Number放到number.py模塊中：
class Number():
??????? def __init__(self,start):
??????????????? self.data=start
??????? def __sub__(self,other):
??????????????? return Number(self.data-other)
>>> from number import Number
>>> X=Number(5)
>>> Y=X-2??????
>>> Y.data
3
>>> Z=X+5
Traceback (most recent call last):
? File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'instance' and 'int'
這個例子Number類提供一個方法來攔截實例的構造器(__init__),此外還有一個方法捕捉減法表達式（__sub__).
這種特殊的方法是鉤子，可與內置運算相綁定。
1、 常見的運算符重載方法
方法??? ??? 重載??? ??? 調用
__init__??? 構造器方法??? 對象建立：X=Class()
__del__??? ??? 析構方法??? 對象收回
__add__??? ??? 運算符+??? ??? X+Y,X+=Y
__sub__??? ??? 運算符-??? ??? X-Y,X-=Y
__or__??? ??? 運算符|(位OR)??? X|Y X|=Y
__repr__,__str__ 打印，轉換??? print X、repr(X)、str(X)
__call__??? 函數調用??? X()
__getattr__??? 點號運算??? X.undefined
__setattr__??? 屬性賦值語句??? X.any=Value
__getitem__??? 索引運算??? X[key],沒有__iter__時的for循環和其他迭代器
__setitem__??? 索引賦值語句??? X[key]=value
__len__??? ??? 長度??? ??? ??? len(X),真值測試
__cmp__??? ??? 比較??? ??? ??? X==Y,X
__lt__??? ??? 特定的比較??? ??? X<Y(or else __cmp__)
__eq__??? ??? 特定的比較??? ??? X==Y(or else __cmp__)
__radd__??? 左側加法 +??? ??? Noninstance + X
__iadd__??? 實地（增強的）的加法??? X+=Y（or else __add__)
__iter__??? 迭代環境??? ??? 用于循環，測試，理解，列表，映射及其他
所有重載方法的名稱前后都有兩個下劃線字符，以便把同類中定義的變量名區別開來。特殊方法名稱和表達式或運算的映射關系，是由Python語言預先定義好的。
所有運算符重載的方法都是選用的：如果沒有寫某個方法，那么定義的類就不支持該運算。多數重載方法只用在需要對象行為表現得就像內置函數一樣的高級程序中。然而，__init__構造方法常出現在絕大多數類中。
__getitem__攔截索引運算
__getitem__方法攔截實例的索引運算。當實例X出現X[i]這樣的索引運算中時，Python會調用這個實例繼承的__getitem__方法。
（如果有），把X作為第一個參數傳遞，并且放括號內的索引值傳遞給第二個參數。
>>> class index:
...???? def __getitem__(self,index):
...???????????? return index**2?
...
>>> X=index()
>>> X[2]
4
>>> for i in range(5):
...???? print?? X[i],
...
0 1 4 9 16
__getitem__和__iter__實現迭代
for循環的作用是從0到更大的索引值，重復對序列進行索引運算，直到檢測到超出邊界的異常。
__getitem__也可以是Python中一種重載迭代的方式，如果定義了這個方法，for循環每次循環時都會調用類的__getitem__
>>> class stepper:
...???? def __getitem__(self,i):
...???????????? return self.data[i]
...
>>> X=stepper
>>> X=stepper()
>>> X.data='diege'
>>> X[1]
'i'
>>> for item in X:
...???? print item,
...
d i e g e
任何支持for循環的類也會自動支持Python所有迭代環境，包括成員關系測試in,列表解析，內置函數map，列表和元組賦值運算以及類型構造方法也會自動調用__getitem__(如果定義的話）。如今，Python中所有的迭代環境都會先嘗試__iter__方法，再嘗試__getitem__。如果對象不支持迭代協議，就會嘗試索引運算。
從技術角度來將，迭代環境是通過調用內置函數iter去嘗試尋找__iter__方法來實現的，而這種方法應該返回一個迭代器對象。
如果已經提供了，Python就會重復調用這個迭代器對象的next方法，直到發生StopIteration異常。如果沒有找到__iter__方法
,Python會改用__getitem__機制，就像之前那樣通過偏移量重復索引，直到引發IndexError異常。
class Squares:
??????? def __init__(self,start,stop):
??????????????? self.value=start-1
??????????????? self.stop=stop
??????? def __iter__(self):
??????????????? return self
??????? def next(self):
??????????????? if self.value==self.stop:
??????????????????????? raise StopIteration
??????????????? self.value+=1
??????????????? return self.value**2
>>> from test29 import Squares
>>> for i in Squares(1,5):???
...???? print i,?????????
...
1 4 9 16 25
迭代器對象就是實例self，因為next方法是這個類的一部分。在較為復雜的的場景中,迭代器對象可定義為個別的類或對象，有自己的狀態信息，對相同數據支持多種迭代。以Python raise語句發出信號表示迭代結束。__iter__對象會在調用過程中明確地保留狀態信息。所以比__getitem__具體更好的通用性。__iter__迭代器比__getitem__更復雜和難用。迭代器是用來迭代，不是隨機的索引運算。事實上，迭代器根本沒有重載索引表達式.
>>> X=Squares(1,5)
>>> X[1]
Traceback (most recent call last):
? File "<stdin>", line 1, in <module>
AttributeError: Squares instance has no attribute '__getitem__'
__iter__機制是在__getitem__中所見到的其他所有迭代環境的實現方式（成員關系測試，類型構造器，序列賦值運算）。和__getitem__不同的是，__iter__只循環一次，而不是循環多次，循環之后就變為空，每次新的循環，都得創建一個新的。
>>> X=Squares(1,5)
>>> [n for n in X]
[1, 4, 9, 16, 25]
>>> [n for n in X]
[]
如果使用生成器函數編寫，這個例子可能更簡單
>>> from __future__ import generators
>>> def gsquares(start,stop):???????
...???? for i in range(start,stop+1):
...???????????? yield i**2???????????
...
>>> for i in gsquares(1,5):
...???? print i,??????????
...
1 4 9 16 25
和類不同的是，這個函數會自動在迭代中存儲存其狀態。這是假設的例子，實際上，可以跳過這兩種技術，只用for循環,map或列表解析
一次創建這個列表。
>>> [x**2 for x in range(1,6)]
[1, 4, 9, 16, 25
有多個迭代器的對象。
__getattr__和__setattr__捕捉屬性的引用。
__getattr__方法是攔截屬性點號運算。__getattr__可以作為鉤子來通過通用的方式相應屬性請求。
>>> class empty:
...???? def __getattr__(self,attrname):
...???????????? if attrname=="age":
...???????????????????? return 40
...???????????? else:
...???????????????????? raise AttributeError,attrname
...
>>> X=empty()
>>> X.age
40
這里，empty類和其實例X本身并沒有屬性。所以對X.age的存取會轉換至__getattr__方法，self則賦值為實例(X),
而attrname則賦值為未定義的屬性名稱字符串("age"),這個類傳回一個實際值作為X.age點號表達式的結果（40），
讓age看起來像實際的屬性。實際上，age變成了動態計算的屬性。
__setattr__會攔截所有賦值語句，一般不用。
__repr__,__str__ 打印，轉換??? print X、repr(X)、str(X)
__call__攔截調用：如果定義了，Python就會為實例應用函數調用表達式運行__call__方法。
當需要為函數的API編寫接口時，__call__就變得很用有：這可以編寫遵循所需要的函數來調用接口對象。
函數接口和回調代碼
__del__是析構器
每當實例產生時，就會調用__init__構造方法，每當實例空間被收回執行__del__方法。

>>> x.__class__
<class trac.wrapper at 0x28503f8c>
>>> x.__class__.__name__
'wrapper'
每個實例都有內置的__class__屬性，引用了它所繼承的類，而每個類都有__name__屬性，用用了首行中的變量名，所以self.__class__.__name__
是取出實例的類的名稱
四、命名空間:完整的內容
點號和無點號的變量，會用不同的方式處理，而有些作用域是用于對對象命名空間做初始設定的。
*無點號運算的變量名（例如，X）與作用域相對應
*點號的屬性名（如object.X)使用的是對象的命名空間。
*有些作用域會對對象的命名空間進行初始化（模塊和類）
1、簡單變量名：如果賦值就不是全局變量
無點號的簡單運算名遵循函數LEGB作用域法則：
賦值語句（X=value)
??? 使變量名為本地變量：在當前作用域內，創建或改變變量名X，除非聲明它是全局變量。如在函數的內的賦值語句。
引用（X）
??? 在當前作用域內搜索變量名X,之后是在任何以及所有的嵌套函數中，然后是在當前的全局作用域中搜索，最后在內置作用域中搜索。
2、屬性名稱：對象命名空間
點號的屬性名稱指的是特定對象的屬性，并且遵守模塊和類的規則。就類和實例對象而言，引用規則增加了繼承搜索這個流程。
賦值語句（object.X=value)
??? 在進行點號運算的對象的命名空間內創建或修改屬性名X，并沒有其他作用。繼承樹的搜索只發生在屬性引用時，而不是屬性的賦值運算時
引用（object.X)
??? 就基于類的對象而言，會在對象內搜索屬性名X，然后是其上所有可讀取的類（使用繼承搜索流程）.對于不是基于類的對象而言，例如模塊，則是從對象中直接讀取X(可能是的屬性包括，變量名，函數，類）。
3、命名空間：賦值將變量名分類
在Python中，賦值變量名的場所相當重要：這完全決定了變量名所在作用域或對象。一下實例總結了命名空間的概念。
# vim manynames.py
X=11??? #模塊屬性 全局
def f():
??????? print X? #函數（本地）作用域內沒有X，嵌套函數沒有X變量，當前全局作用域（模塊的命名空間內）有，顯示全局
def g():
??????? X=22? #定義本地作用域變量X
??????? print X #搜索函數（本地）作用域內變量X，有打印
class C:
??????? X=33 ??? #定義的類屬性，類的命名空間
??????? def m(self）:
??????????????? X=44??? #貌似在這里沒有什么意義
??????????????? self.X=55 #定義類實例的屬性，實例的命名空間
if __name__=='__main__':
??????? print X??? #打印模塊屬性 結果11
??????? f()??? #調用f(),f()返回模塊全局變量的X 11
??????? g()??? #調用g(),g()返回函數內局部變量X 22
??????? print X #打印 模塊全局變量的里變量，模塊的屬性 11

??????? obj=C()??? #調用類的方法產生實例
??????? print obj.X #打印實例的屬性X X繼承類的屬性，所以為33

??????? obj.m() #實例調用類的m方法，
??????? print obj.X #顯示這個X屬性 因為上一步m方法設置了實例的屬性X，為55
# python manynames.py
11
11
22
11
33
55
作用域總是由源代碼中賦值語句的位置來決定，而且絕不會受到其導入關系的影響。屬性就像是變量，在賦值之后才會存在。而不是在賦值前。通常情況下，創建實例屬性的方法是在類的__init__構造器方法內賦值。通常說來，在腳本內不應該讓每個變量使用相同的命變量名。
4、命名空間字典
模塊的命名空間實際上是以字典的形式實現的，并且可以由內置屬性__dict__顯示這一點。類和實例對象也是如此：屬性點號運算其內部就是字典的索引運算，而屬性繼承其實就是搜索鏈接的字典而已。實際上，實例和類對象就是Python中帶有鏈接的字典而已，
>>> class Super():
...???? def hello(self):
...???????????? self.data1='diege'
...
>>> class Sub(Super):
...???? def hola(self):
...???????????? self.data2='eggs'
...
制作子類的實例時，該實例一開始會是空的命名空間字典，但是有鏈接會指向它的類，讓繼承搜索能順著尋找。實際上，繼承樹可在特殊的屬性中看到，你可以進行查看。實例中有個__class__屬性鏈接到了它的類，而類有個__base__屬性。就是元組，其中包含了通往更高的超類的連接。
>>> X=Sub()?????????????????????
>>> X.__dict__
{}
>>> X.__class__
<class __main__.Sub at 0x2850353c>
>>> Y=Super()
>>> Y.__dict__
{}
>>> Y.__class__
<class __main__.Super at 0x285034ac>
>>> Sub.__bases__
(<class __main__.Super at 0x285034ac>,)
>>> Super.__bases__???
()
當類為self屬性賦值時，會填入實例對象。也就是說，屬性最后會位于實例的屬性命名空間字典內，而不是類的。實例對象的命名空間保存了數據，會隨實例的不同而不同，而self正是進入其命名空間的鉤子。
>>> Y=Sub()
>>> X.hello()
>>> X.__dict__
{'data1': 'diege'}
>>> X.hola()???
>>> X.__dict__
{'data1': 'diege', 'data2': 'eggs'}
>>> Sub.__dict__
{'__module__': '__main__', '__doc__': None, 'hola': <function hola at 0x284954c4>}
>>> Super.__dict__
{'__module__': '__main__', 'hello': <function hello at 0x28495f0c>, '__doc__': None}
>>> Sub.__dict__.keys(),Super.__dict__.keys()
(['__module__', '__doc__', 'hola'], ['__module__', 'hello', '__doc__'])
>>> Y.__dict__
{}
Y是這個類的第2個實例。即時X的字典已由方法內的賦值語句做了填充，Y還是空的命名空間字典。每個實例都有獨立的命名空間字典，一開始是空的，可以記錄和相同類的其他實例命名空間字典中屬性，完全不同的屬性。
因為屬性實際上是python的字典鍵，其實有兩種方式可以讀取并對其進行賦值：通過點號運算，或通過鍵索引運算。
>>> X.data1,X.__dict__['data1']
('diege', 'diege')
>>> X.data3='lily'
>>> X.__dict__????????????????
{'data1': 'diege', 'data3': 'lily', 'data2': 'eggs'}
>>> dir(X)
['__doc__', '__module__', 'data1', 'data2', 'data3', 'hello', 'hola']
>>> dir(Sub)
['__doc__', '__module__', 'hello', 'hola']
>>> dir(Super)
['__doc__', '__module__', 'hello']
對實例賦值，只影響實例，不會影響實例的類和超類
5、命名空間連接
__class__和__bases__這些屬性可以在程序代碼內查看繼承層次。可以用他來顯示類樹
6、一個較復雜的例子
vim person.py
class GenericDisplay:
??????? def gatherAttrs(self):
??????????????? attrs='\n'
??????????????? for key in self.__dict__:
??????????????????????? attrs+='\t%s=%s\n' % (key,self.__dict__[key])
??????????????? return attrs
??????? def __str__(self):
??????????????? return '<%s:%s>' % (self.__class__.__name__,self.gatherAttrs())

class Person(GenericDisplay):
??????? def __init__(self,name,age):
??????????????? self.name=name
??????????????? self.age=age
??????? def lastName(self):
??????????????? return self.name.split()[-1]
??????? def birthDay(self):
??????????????? self.age+=1
class Employee(Person):
??????? def __init__(self,name,age,job=None,pay=0):
??????????????? Person.__init__(self,name,age)
??????????????? self.job=job
??????????????? self.pay=pay
??????? def birthDay(self):
??????????????? self.age+=2
??????? def giveRaise(self,percent):
??????????????? self.pay*=(1.0+percent)
if __name__=='__main__':
??????? diege=Person('diege wang',18)
??????? print diege
??????? print diege.lastName()
??????? diege.birthDay()
??? ??? print diege

??????? sue=Employee('Sue Jones',44,job='dev',pay=1000)
??????? print sue
??????? print sue.lastName()
??????? sue.birthDay()
??????? sue.giveRaise(.10)
??????? print sue
# python person.py
<Person:
??????? age=18
??????? name=diege wang
>
wang
<Employee:
??????? job=dev
??????? pay=1000
??????? age=44
??????? name=Sue Jones
>
Jones
<Employee:
??????? job=dev
??????? pay=1100.0
??????? age=46
??????? name=Sue Jones
>
可以作為模塊導入測試
>>> from person import Person
>>> dir(Person)
['__doc__', '__init__', '__module__', '__str__', 'birthDay', 'gatherAttrs', 'lastName']
>>> diege.__dict__
>>> diege=Person('diege wang',18)
{'age': 18, 'name': 'diege wang'}
>>> print diege
<Person:
??????? age=18
??????? name=diege wang
>
>>> print diege.lastName()
wang
>>> diege.age
18
>>> diege.birthDay()
>>> diege.age
19

轉載于:https://blog.51cto.com/ipseek/800522

總結

以上是生活随笔為你收集整理的Python学习笔记整理(十五)类的编写细节的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。