#encoding=utf-8 ### *************** 面向對象編程 ******************** #*********** Part 1: 面向對象編程 *********************** #面向對象編程踩上了進化的步伐，增強了結構化編程，實現了數據與動作的融合：數據層和邏 #輯層現在由一個可用以創建這些對象的簡單抽象層來描述。現實世界中的問題和實體完全暴露了本 #質，從中提供的一種抽象，可以用來進行相似編碼，或者編入能與系統中對象進行交互的對象中。 #類提供了這樣一些對象的定義，實例即是這些定義的實現。二者對面向對象設計（object-oriented #design，OOD）來說都是重要的，OOD 僅意味來創建你采用面向對象方式架構來創建系統。 ## 1.1 面向對象設計與面向對象編程的關系 #面向對象設計（OOD）不會特別要求面向對象編程語言。事實上，OOD 可以由純結構化語言來實 #現，比如C，但如果想要構造具備對象性質和特點的數據類型，就需要在程序上作更多的努力。當一 #門語言內建OO 特性，OO 編程開發就會更加方便高效。 # #另一方面，一門面向對象的語言不一定會強制你寫OO 方面的程序。例如C++可以被認為“更好 #的C”；而Java，則要求萬物皆類，此外還規定，一個源文件對應一個類定義。然而，在Python 中， #類和OOP 都不是日常編程所必需的。盡管它從一開始設計就是面向對象的，并且結構上支持OOP，但 #Python 沒有限定或要求你在你的應用中寫OO 的代碼。OOP 是一門強大的工具，不管你是準備進入， #學習，過渡，或是轉向OOP，都可以任意支配。 ## 1.2 現實世界中的問題 #考慮用OOD 來工作的一個最重要的原因，在于它直接提供建模和解決現實世界問題和情形的途 #徑。比如，讓你來試著模擬一臺汽車維修店，可以讓你停車進行維修。我們需要建兩個一般實體： #處在一個“系統”中并與其交互的人類，和一個修理店，它定義了物理位置，用于人類活動。因為 #前者有更多不同的類型，我將首先對它進行描述，然后描述后者。在此類活動中，一個名為Person #的類被創建以用來表示所有的人。Person 的實例可以包括消費者(Customer)，技工(Mechanic)，還 #可能是出納員(Cashier)。這些實例具有相似的行為，也有獨一無二的行為。比如，他們能用聲音進 #行交流，都有talk()方法，還有drive_car()方法。不同的是，技工有repair_car()方法，而出納 #有ring_sale()方法。技工有一個repair_certification 屬性，而所有人都有一個drivers_license #屬性。 # #最后，所有這些實例都是一個檢查(overseeing)類RepairShop 的參與者，后者具有一個叫 #operating_hours 的數據屬性，它通過時間函數來確定何時顧客來修車，何時職員技工和出納員來上 #班。RepairShop 可能還有一個AutoBay 類，擁有SmogZone,TireBrakeZone 等實例，也許還有一個叫 #GeneralRepair 的實例。 # #我們所編的RepairShop 的一個關鍵點是要展示類和實例加上它們的行為是如何用來對現實生活 #場景建模的。同樣，你可以把諸如機場，餐廳，晶蕊，醫院，其至一個郵訂音樂公司想像為類，它 #們完全具備各自的參與者和功能性。 ## 1.3 常用術語 #1.3.1 抽象/實現 #抽象指對現實世界問題和實體的本質表現，行為和特征建模，建立一個相關的子集，可以用于 #描繪程序結構，從而實現這種模型。抽象不僅包括這種模型的數據屬性，還定義了這些數據的接口。 #對某種抽象的實現就是對此數據及與之相關接口的現實化(realization)。現實化這個過程對于客戶 #程序應當是透明而且無關的。 #1.3.2 封裝/接口 #封裝描述了對數據/信息進行隱藏的觀念，它對數據屬性提供接口和訪問函數。通過任何客戶端 #直接對數據的訪問，無視接口，與封裝性都是背道而馳的，除非程序員允許這些操作。作為實現的 #一部分，客戶端根本就不需要知道在封裝之后，數據屬性是如何組織的。在Python 中，所有的類屬 #性都是公開的，但名字可能被“混淆”了，以阻止未經授權的訪問，但僅此而已，再沒有其他預防 #措施了。這就需要在設計時，對數據提供相應的接口，以免客戶程序通過不規范的操作來存取封裝 #的數據屬性。 #1.3.3 合成 #合成擴充了對類的描述，使得多個不同的類合成為一個大的類，來解決現實問題。合成描述了 #一個異常復雜的系統，比如一個類由其它類組成，更小的組件也可能是其它的類，數據屬性及行為， #所有這些合在一起，彼此是“有一個”的關系。比如，RepairShop“有一個”技工(應該至少有一個 #吧)，還“有一個”顧客(至少一個)。 #這些組件要么通過聯合關系組在一塊，意思是說，對子組件的訪問是允許的(對RepairShop 來 #說，顧客可能請求一個SmogCheck，客戶程序這時就是與RepairShop 的組件進行交互),要么是聚合 #在一起，封裝的組件僅能通過定義好的接口來訪問，對于客戶程序來說是透明的。繼續我的例子， #客戶程序可能會建立一個SmogCheck 請求來代表顧客，但不能夠同RepairShop 的SmogZone 部分進 #行交互，因為SmogZone 是由RepairShop 內部控制的，只能通過smogCheckCar()方法調用。Python #支持上述兩種形式的合成。 # 1.3.4 派生/繼承/繼承結構 #派生描述了子類的創建，新類保留已存類類型中所有需要的數據和行為，但允許修改或者其它 #的自定義操作，都不會修改原類的定義。繼承描述了子類屬性從祖先類繼承這樣一種方式。從前面 #的例子中，技工可能比顧客多個汽車技能屬性，但單獨的來看，每個都“是一個”人，所以，不管 #對誰而言調用talk()都是合法得，因為它是人的所有實例共有的。繼承結構表示多“代”派生，可 #以描述成一個“族譜”，連續的子類，與祖先類都有關系。 # 1.3.5 泛化/特化 #泛化表示所有子類與其父類及祖先類有一樣的特點，所以子類可以認為同祖先類是“是一個” #的關系，因為一個派生對象（實例）是祖先類的一個“例子”。比如，技工“是一個”人，車“是一 #個”交通工具，等等。在上面我們間接提到的族譜圖中，我們可以從子類到祖先類畫一條線，表示 #“是一個”的關系。特化描述所有子類的自定義，也就是，什么屬性讓它與其祖先類不同。 #1.3.5 多態 #多態的概念指出了對象如何通過他們共同的屬性和動作來操作及訪問，而不需考慮他們具體的 #類。多態表明了動態（又名，運行時）綁定的存在，允計重載及運行時類型確定和驗證。 # 1.3.6 自省/反射 #自省表示給予你，程序員，某種能力來進行像“手工類型檢查”的工作，它也被稱為反射。這 #個性質展示了某對象是如何在運行期取得自身信息的。如果傳一個對象給你，你可以查出它有什么 #能力，這樣的功能不是很好嗎？這是一項強大的特性，在本章中，你會時常遇到。如果Python 不 #支持某種形式的自省功能，dir()和type()內建函數，將很難正常工作。請密切關注這些調用，還 #有那些特殊屬性，像__dict__,__name__及__doc__。可能你對其中一些已經很熟悉了！ #*********** Part 2: 類 *********************** #類是一種數據結構，我們可以用它來定義對象，后者把數據值和行為特性融合在一起。 #類是現實世界的抽象的實體以編程形式出現。實例是這些對象的具體化。 ## 2.1 創建類 #類的定義： #class ClassName(object): # 'class documentation string' #類文檔字符串 # class_suite #類體 # #當你創建一個類，你就實際創建了一個你自己的數據類型。盡管類是對象，但正被定義時，它們還不是對象的實現。 # #類允許派生。你可以創建一個子類，它也是類，而且繼續了父類所有的特征和屬性。從Python2.2 開始，你也可以從內建類型中派生子類，而不是僅僅從其它類。 # #注意類的參數，object 是“所有類之母”。如果你的類沒有繼承任何其他父類，object 將作為默認的父類。它位于所有類繼承結構的最上層。 #基類是一個或多個用于繼承的父類的集合；類體由所有聲明語句，類成員定義，數據屬性和函數組成。 #類通常在一個模塊的頂層進行定義，以便類實例能夠在類所定義的源代碼文件中的任何地方被創建. ## 2.2 聲明與定義 #對于Python 函數來說，聲明與定義類沒什么區別，因為他們是同時進行的，定義（類體）緊跟 #在聲明（含class 關鍵字的頭行[header line])和可選(但總是推薦使用)的文檔字符串后面。同時， #所有的方法也必須同時被定義。如果對OOP 很熟悉，請注意Python 并不支持純虛函數（像C++）或 #者抽象方法（如在JAVA 中），這些都強制程序員在子類中定義方法。作為替代方法，你可以簡單地 #在基類方法中引發NotImplementedError 異常，這樣可以獲得類似的效果。 #*********** Part 3: 類屬性 *********************** #屬性就是屬于另一個對象的數據或者函數元素,可以通過我們熟悉的句點屬性 #標識法來訪問。一些Python 類型比如復數有數據屬性（實部和虛部），而另外一些，像列表和字典，擁有方法（函數屬性）。 #有關屬性的一個有趣的地方是，當你正訪問一個屬性時，它同時也是一個對象，擁有它自己的 #屬性，可以訪問，這導致了一個屬性鏈，比如，myThing,subThing,subSubThing.等等。常見例子如下： # sys.stdout.write('foo') # print myModule.myClass.__doc__ # myList.extend(map(upper, open('x').readlines())) ## 3.1 類的數據屬性 #數據屬性僅僅是所定義的類的變量。它們可以像任何其它變量一樣在類創建后被使用，并且， #要么是由類中的方法來更新，要么是在主程序其它什么地方被更新。即靜態變量，或者是靜態數據。它們表示這些數據是與它們所 #屬的類對象綁定的，不依賴于任何類實例。 #靜態成員通常僅用來跟蹤與類相關的值。大多數情況下，你會考慮用實例屬性，而不是類屬性。 #class c1(object): # num=100 # #c2=c1() #print(c2.num) ##-->100 #c2.num+=1 #print(c2.num) #-->101 ## 3.2 方法 #方法，即類中的函數 #class c1(object): # name='dave' # def showName(self,name): # print('name is:',name) # #c2=c1() #c2.showName('DMM') #--> #name is: DMM #注意self 參數，它在所有的方法聲明中都存在。這個參數代表實例對象本身，當你 #用實例調用方法時，由解釋器悄悄地傳遞給方法的，所以，你不需要自己傳遞self 進來，因為它是 #自動傳入的。舉例說明一下，假如你有一個帶兩參數的方法，所有你的調用只需要傳遞第二個參數，Python 把self 作為第一個參數傳遞進來 ######### 綁定（綁定及非綁定方法） #為與OOP 慣例保持一致，Python 嚴格要求，沒有實例，方法是不能被調用的。這種限制即Python所描述的綁定概念(binding)， #在此，方法必須綁定（到一個實例）才能直接被調用。非綁定的方法可能可以被調用，但實例對象一定要明確給出，才能確保調用成功。 #然而，不管是否綁定，方法都是它所在的類的固有屬性，即使它們幾乎總是通過實例來調用的. ## 3.3 決定類的屬性 #要知道一個類有哪些屬性，有兩種方法。最簡單的是使用dir()內建函數。另外是通過訪問類的字典屬性__dict__，這是所有類都具備的特殊屬性之一。 #class c1(object): # name='dave' # def showName(self,name): # print('name is:',name) #print(dir(c1)) #--> #['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__ge__', #'__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', #'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', #'__str__', '__subclasshook__', '__weakref__', 'name', 'showName'] #注意dir 返回的是列表 #print(c1.__dict__) #--> #{'__module__': '__main__', 'name': 'dave', '__dict__': <attribute '__dict__' of 'c1' objects>, #'__weakref__': <attribute '__weakref__' of 'c1' objects>, '__doc__': None, #'showName': <function showName at 0x00000000025280C8>} #注意__dict__ 返回的是字典 ## 3.4 特殊的類屬性 #C.__name__ 類Ｃ的名字（字符串） #C.__doc__ 類Ｃ的文檔字符串 #C.__bases__ 類Ｃ的所有父類構成的元組 #C.__dict__ 類Ｃ的屬性 #C.__module__ 類Ｃ定義所在的模塊（1.5 版本新增） #C.__class__ 實例Ｃ對應的類（僅新式類中） #class c1(object): # def showName(self,name): # print('name is:',name) # #class c2(object): # 'This is the name' # def showName(self,name): # print('name is:',name) #__name__是給定類的字符名字。它適用于那種只需要字符串（類對象的名字），而非類對象本身 #的情況。甚至一些內建的類型也有這個屬性，我們將會用到其中之一來展示__name__字符串的益處。 #__doc__是類的文檔字符串，與函數及模塊的文檔字符串相似，必須緊隨頭行（header line） #后的字符串。文檔字符串不能被派生類繼承，也就是說派生類必須含有它們自己的文檔字符串。 #c3=c1() #c4=c2() #print(c3.__doc__) #print(c4.__doc__) #--> #None #c1 類我們沒有定義文檔字符串，所以顯示為None #This is the name #Python 支持模塊間的類繼承 #*********** Part 4: 實例 *********************** #如果說類是一種數據結構定義類型，那么實例則聲明了一個這種類型的變量。 #實例是那些主要用在運行期時的對象，類被實例化得到實例，該實例的類型就是這個被實例化的類。 ## 4.1 初始化：通過調用類對象來創建實例 #實例化的實現，可以使用函數操作符： #class c1(object): # def showName(self,name): # print('name is:',name) #c3=c1() ## 4.2 __init__() "構造器"方法 #當類被調用，實例化的第一步是創建實例對象。一旦對象創建了，Python 檢查是否實現了__init__()方法。 #默認情況下，如果沒有定義（或覆蓋）特殊方法__init__()，對實例不會施加任何特別的操作.任何所需的特定操作， #都需要程序員實現__init__()，覆蓋它的默認行為。如果__init__()沒有實現，則返回它的對象，實例化過程完畢。 # #然而，如果__init__()已經被實現，那么它將被調用，實例對象作為第一個參數(self)被傳遞 #進去，像標準方法調用一樣。調用類時，傳進的任何參數都交給了__init__()。實際中，你可以想 #像成這樣：把創建實例的調用當成是對構造器的調用。 #__init__()是很多為類定義的特殊方法之一。其中一些特殊方法是預定義的，缺省情況下，不 #進行任何操作，比如__init__()，要定制，就必須對它進行重載，還有些方法，可能要按需要去實現. ## 4.3 __new__() “構造器”方法 #與__init__()相比，__new__()方法更像一個真正的構造器。Python 用戶可以對內建類型進行派生， #因此，需要一種途徑來實例化不可變對象，比如，派生字符串，數字，等等 #在這種情況下，解釋器則調用類的__new__()方法，一個靜態方法，并且傳入的參數是在類實例 #化操作時生成的。__new__()會調用父類的__new__()來創建對象（向上代理）。 #__new__()必須返回一個合法的實例，這樣解釋器在調用__init__()時，就可以把這個實例作為self 傳給它。調用父類的__new__() #來創建對象，正像其它語言中使用new 關鍵字一樣。__new__()和__init__()在類創建時，都傳入了（相同）參數。 ## 4.4 __del__() "解構器"方法 #由于Python 具有垃圾對象回收機制（靠引用計數)，這個函數要直到該實例對象所有的引用都被清除掉后才會執行。 #Python 中的解構器是在實例釋放前提供特殊處理功能的方法，它們通常沒有被實現，因為實例很少被顯式釋放。 #核心筆記：跟蹤實例 #Python 沒有提供任何內部機制來跟蹤一個類有多少個實例被創建了，或者記錄這些實例是些什 #么東西。如果需要這些功能，你可以顯式加入一些代碼到類定義或者__init__()和__del__()中去。 #最好的方式是使用一個靜態成員來記錄實例的個數。靠保存它們的引用來跟蹤實例對象是很危險的， #因為你必須合理管理這些引用，不然，你的引用可能沒辦法釋放（因為還有其它的引用）！看下面一個例子： #class InstCt(object): # count = 0 # count is class attr count 是一個類屬性 # def __init__(self): # increment count 增加count # InstCt.count += 1 # def __del__(self): # decrement count 減少count # InstCt.count -= 1 # def howMany(self): # return count 返回count # print(InstCt.count) # #c1=InstCt() #c2=InstCt() # #c1.howMany() #c2.howMany() #c1.__del__() #c2.howMany() #--> #2 #2 #1 #*********** Part 5: 實例屬性 *********************** #實例僅擁有數據屬性（方法嚴格來說是類屬性），后者只是與某個類的實例相關聯的數據值，并 #且可以通過句點屬性標識法來訪問。這些值獨立于其它實例或類。當一個實例被釋放后，它的屬性同時也被清除了。 ## 5.1 “實例化”實例屬性（或創建一個更好的構造器） #設置實例的屬性可以在實例創建后任意時間進行，也可以在能夠訪問實例的代碼中進行。構造器__init()__是設置這些屬性的關鍵點之一。 ####在構造器中首先設置實例屬性 #構造器是最早可以設置實例屬性的地方，因為__init__()是實例創建后第一個被調用的方法。 #再沒有比這更早的可以設置實例屬性的機會了。一旦__init__()執行完畢，返回實例對象，即完成了實例化過程。 ####默認參數提供默認的實例安裝 #在實際應用中，帶默認參數的__init__()提供一個有效的方式來初始化實例。在很多情況下， #默認值表示設置實例屬性的最常見的情況，如果提供了默認值，我們就沒必要顯式給構造器傳值了。 #需要明白一點，默認參數應當是不變的對象；像列表(list)和字典(dictionary)這樣的可變對象可以扮演靜態數據， #然后在每個方法調用中來維護它們的內容。 #class c1(object): # def __init__(self,name,sex='man'): # print('name:%s,sex:%s' %(name,sex)) #c2=c1('dave') #-->name:dave,sex:man #注意：__init__()應當返回None #你也知道，采用函數操作符調用類對象會創建一個類實例，也就是說這樣一種調用過程返回的對象就是實例。 #如果定義了構造器，它不應當返回任何對象，因為實例對象是自動在實例化調用后返回的。相 #應地，__init__()就不應當返回任何對象（應當為None）；否則，就可能出現沖突，因為只能返回實例。 #class c1(object): # def __init__(self,name,sex='man'): # print('name:%s,sex:%s' %(name,sex)) # return 1 #c2=c1('dave') #-->TypeError: __init__() should return None, not 'int' ## 5.2 查看實例屬性 #可是使用dir() 或者類的__dict__屬性查看。 這個在3.3 節有示例。 ## 5.3 特殊的實例屬性 #實例僅有兩個特殊屬性。對于任意對象I: # I.__class__ 實例化I 的類 # I.__dict__ I 的屬性 #class C(object): # define class 定義類 # pass # #c = C() # create instance 創建實例 #print(dir(c)) # instance has no attributes 實例還沒有屬性 #print(c.__dict__) # yep, definitely no attributes 也沒有屬性 #print(c.__class__) # class that instantiated us 實例化c 的類 #--> #[] #{} #<class '__main__.C'> #c 現在還沒有數據屬性，添加一些再來檢查__dict__屬性，看是否添加成功了： #c.foo = 1 #c.bar = 'SPAM' #print(c.__dict__) #--> #{'foo': 1, 'bar': 'SPAM'} #dict__屬性由一個字典組成，包含一個實例的所有屬性。鍵是屬性名，值是屬性相應的數據值。字典中僅有實例屬性，沒有類屬性或特殊屬性。 ## 5.4 內建類型屬性 #內建類型也是類，對內建類型也可以使用dir()，與任何其它對象一樣，可以得到一個包含它屬性名字的列表： #x = 3+0.14j #print(x.__class__) #--><class 'complex'> #print(dir(x)) #-->['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__divmod__', '__doc__', '__eq__', # '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', # '__hash__', '__init__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', # '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', # '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', # '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'conjugate', 'imag', 'real'] #print(x.imag) #-->0.14 #在內建類型中，不存在__dict__屬性： #print(x.__dict__) #-->AttributeError: 'complex' object has no attribute '__dict__' ## 5.5 實例屬性 vs 類屬性 #類屬性僅是與類相關的數據值，和實例屬性不同，類屬性和實例無關。這些值像靜態成員那樣被引用，即使在多次實例化中調用類， #它們的值都保持不變。不管如何，靜態成員不會因為實例而改變它們的值，除非實例中顯式改變它 #們的值。（實例屬性與類屬性的比較，類似于自動變量和靜態變量，但這只是籠統的類推。 #類和實例都是名字空間。類是類屬性的名字空間，實例則是實例屬性的。 ###訪問類屬性 #類屬性可通過類或實例來訪問. ###從實例中訪問類屬性須謹慎 #與通常Python 變量一樣，任何對實例屬性的賦值都會創建一個實例屬性（如果不存在的話）并 #且對其賦值。如果類屬性中存在同名的屬性，有趣的副作用即產生。 ###類屬性持久性 #靜態成員，如其名所言，任憑整個實例（及其屬性）的如何進展，它都不理不采（因此獨立于 #實例）。同時，當一個實例在類屬性被修改后才創建，那么更新的值就將生效。類屬性的修改會影響 #到所有的實例 #*********** Part 6: 校對----綁定和方法調用 *********************** #方法僅僅是類內部定義的函數。其次，方法只有在其所屬的類擁有實例時，才能被調用。當存在一個實例時，方法才被認為是 #綁定到那個實例了。沒有實例時方法就是未綁定的。最后，任何一個方法定義中的第一個參數都是變量self，它表示調用此方法的實例對象。 #核心筆記：self 是什么？ #self 變量用于在類實例方法中引用方法所綁定的實例。因為方法的實例在任何方法調用中總是 #作為第一個參數傳遞的，self 被選中用來代表實例。你必須在方法聲明中放上self(你可能已經注 #意到了這點),但可以在方法中不使用實例(self)。如果你的方法中沒有用到self , 那么請考慮創建 #一個常規函數，除非你有特別的原因。畢竟，你的方法代碼沒有使用實例，沒有與類關聯其功能， #這使得它看起來更像一個常規函數。在其它面向對象語言中，self 可能被稱為 this。 ## 6.1 調用綁定方法 #方法，不管綁定與否，都是由相同的代碼組成的。唯一的不同在于是否存在一個實例可以調用 #此方法。在很多情況下，程序員調用的都是一個綁定的方法。假定現在有一個 MyClass 類和此類的 #一個實例 mc，而你想調用MyClass.foo()方法。因為已經有一個實例，你只需要調用mc.foo()就可 #以。記得self 在每一個方法聲明中都是作為第一個參數傳遞的。當你在實例中調用一個綁定的方法 #時，self 不需要明確地傳入了。這算是"必須聲明self 作為第一個參數"對你的報酬。當你還沒有 #一個實例并且需要調用一個非綁定方法的時候你必須傳遞self 參數。 ## 6.2 調用非綁定方法 #調用非綁定方法并不經常用到。需要調用一個還沒有任何實例的類中的方法的一個主要的場景 #是:你在派生一個子類,而且你要覆蓋父類的方法，這時你需要調用那個父類中想要覆蓋掉的構造方法。 # #在子類構造器中調用父類的構造器并且明確地傳遞（父類）構造器所需要的self 參數（因為我們沒有一個父類的實例）。 #子類中 __init__() 的第一行就是對父類__init__()的調用。我們通過父類名來調用它，并且傳遞給它 self 和其他所需要的 #參數。一旦調用返回，我們就能定義那些與父類不同的僅存在我們的（子）類中的（實例）定制。 #*********** Part 7: 靜態方法和類方法 *********************** #靜態方法是類中的函數(不需要實例). ## 7.1 staticmethod()和classmethod()內建函數 #示例： #class TestStaticMethod: # def foo(): # print('calling static method foo()') # foo = staticmethod(foo) # #class TestClassMethod: # def foo(cls): # print('calling class method foo()') # print('foo() is part of class:', cls.__name__) # foo = classmethod(foo) #對應的內建函數被轉換成它們相應的類型，并且重新賦值給了相同的變量名。如果沒有調用這 #兩個函數，二者都會在Python 編譯器中產生錯誤，顯示需要帶self 的常規方法聲明。我們可以通過類或者實例調用這些函數. #tsm = TestStaticMethod() #TestStaticMethod.foo() #tsm.foo() #--> #calling static method foo() #calling static method foo() #tcm = TestClassMethod() #TestClassMethod.foo() #tcm.foo() #--> #calling class method foo() #foo() is part of class: TestClassMethod #calling class method foo() #foo() is part of class: TestClassMethod ## 7.2 使用函數修飾符 #看到像foo=staticmethod(foo)這樣的代碼會刺激一些程序員。很多人對這樣一個沒意義 #的語法感到心煩，即使van Rossum 曾指出過，它只是臨時的，有待社區對些語義進行處理。 # #可以用它把一個函數應用到另個函數對象上, 而且新函數對象依然綁定在原來的變量。我們正是需要它來 #整理語法。通過使用decorators，我們可以避免像上面那樣的重新賦值： #class TestStaticMethod: # @staticmethod # def foo(): # print('calling static method foo()') # #class TestClassMethod: # @classmethod # def foo(cls): # print('calling class method foo()') # print('foo() is part of class:', cls.__name__) #*********** Part 8: 組合 *********************** #一個類被定義后，目標就是要把它當成一個模塊來使用，并把這些對象嵌入到你的代碼中去， #同其它數據類型及邏輯執行流混合使用。有兩種方法可以在你的代碼中利用類。第一種是組合 #(composition)。就是讓不同的類混合并加入到其它類中，來增加功能和代碼重用性。你可以在一個 #大點的類中創建你自已的類的實例，實現一些其它屬性和方法來增強對原來的類對象。另一種方法 #是通過派生. #class NewAddrBookEntry(object): # class definition 類定義 # 'new address book entry class' # def __init__(self, nm, ph): # define constructor 定義構造器 # self.name = Name(nm) # create Name instance 創建Name 實例 # self.phone = Phone(ph) # create Phone instance 創建Phone 實例 # print('Created instance for:', self.name) # #NewAddrBookEntry 類由它自身和其它類組合而成。 #*********** Part 9: 子類和派生 *********************** #當類之間有顯著的不同，并且(較小的類)是較大的類所需要的組件時，組合表現得很好，但當 #你設計“相同的類但有一些不同的功能”時，派生就是一個更加合理的選擇了。 #OOP 的更強大方面之一是能夠使用一個已經定義好的類，擴展它或者對其進行修改，而不會影響 #系統中使用現存類的其它代碼片段。OOD 允許類特征在子孫類或子類中進行繼承。這些子類從基類（或 #稱祖先類，超類）繼承它們的核心屬性。而且，這些派生可能會擴展到多代。在一個層次的派生關 #系中的相關類（或者是在類樹圖中垂直相鄰）是父類和子類關系。從同一個父類派生出來的這些類 #（或者是在類樹圖中水平相鄰）是同胞關系。父類和所有高層類都被認為是祖先。 #####創建子類 #創建子類的語法看起來與普通(新式)類沒有區別，一個類名，后跟一個或多個需要從其中派生的父類： #class SubClassName (ParentClass1[, ParentClass2, ...]): # 'optional class documentation string' # class_suite #如果你的類沒有從任何祖先類派生，可以使用object 作為父類的名字。 # #經典類的聲明唯一不同之處在于其沒有從祖先類派生－－－此時，沒有圓括號： #class ClassicClassWithoutSuperclasses: # pass #class Parent(object): # define parent class 定義父類 # def parentMethod(self): # print('calling parent method') # #class Child(Parent): # define child class 定義子類 # def childMethod(self): # print('calling child method') # #p = Parent() # instance of parent 父類的實例 #p.parentMethod() #--> #calling parent method # #c = Child() # instance of child 子類的實例 #c.childMethod() # child calls its method 子類調用它的方法 #c.parentMethod() # calls parent's method 調用父類的方法 # #--> #calling child method #calling parent method #*********** Part 10: 繼承 *********************** #繼承描述了基類的屬性如何“遺傳”給派生類。一個子類可以繼承它的基類的任何屬性，不管是數據屬性還是方法。 #class Parent(object): # define parent class 定義父類 # def parentMethod(self): # print('calling parent method') # #class Child(Parent): # define child class 定義子類 # def childMethod(self): # print('calling child method') # #c = Child() # instantiate child 實例化子類 #print(c.__class__) # child "is a" parent 子類“是一個”父類 #--><class '__main__.Child'> #print(Child.__bases__) # child's parent class(es) 子類的父類 #-->(<class '__main__.Parent'>,) ## 10.1 __bases__類屬性 #對任何(子）類,它是一個包含其父類（parent）的集合的元組。注意，我們明確指出“父類”是相對所有基類（它包括了所有祖先類） #而言的。那些沒有父類的類，它們的__bases__屬性為空。 #class A(object): pass # define class A 定義類A #class B(A): pass # subclass of A A 的子類 #class C(B): pass # subclass of B (and indirectly, A) B 的子類（A 的間接子類） #class D(B,A): pass # subclass of A and B A，B 的子類, 注意，這里B 要寫在前面 # #print(A.__bases__) #print(C.__bases__) #print(D.__bases__) #--> #(<class 'object'>,) #(<class '__main__.B'>,) #(<class '__main__.B'>, <class '__main__.A'>) ## 10.2 通過繼承覆蓋（Overriding）方法 #創建父類 #class P(object): # def foo(self): # print('Hi, I am P-foo()') #p = P() #p.foo() #-->Hi, I am P-foo() #創建子類C，從父類P 派生： #class C(P): # def foo(self): # print('Hi, I am C-foo()') #c = C() #c.foo() #-->Hi, I am C-foo() #盡管C 繼承了P 的foo()方法，但因為C 定義了它自已的foo()方法，所以 P 中的 foo() 方法 #被覆蓋。覆蓋方法的原因之一是，你的子類可能需要這個方法具有特定或不同的功能. # #如果想繼續調用那個被我覆蓋的基類方法，就需要去調用一個未綁定的基類方法，明確給出子類的實例. #P.foo(c) #-->Hi, I am P-foo() #可以在子類的重寫方法里顯式地調用基類方法： #class C(P): # def foo(self): # P.foo(self) # print('Hi, I am C-foo()') #注意，在這個（未綁定）方法調用中我們顯式地傳遞了self. 一個更好的辦法是使用super()內建方法： #class C(P): # def foo(self): # super(C, self).foo() # print('Hi, I am C-foo()') #super()不但能找到基類方法，而且還為我們傳進self，這樣我們就不需要做這些事了。現在我 #們只要調用子類的方法，它會幫你完成一切： #c = C() #c.foo() #--> #Hi, I am P-foo() #Hi, I am C-foo() #核心筆記：重寫__init__不會自動調用基類的__init__ #類似于上面的覆蓋非特殊方法，當從一個帶構造器 __init()__的類派生，如果你不去覆蓋 #__init__()，它將會被繼承并自動調用。但如果你在子類中覆蓋了__init__()，子類被實例化時， #基類的__init__()就不會被自動調用. #class P(object): # def __init__(self): # print "calling P's constructor" # #class C(P): # def __init__(self): # print "calling C's constructor" # #>>> c = C() #calling C's constructor #如果你還想調用基類的 __init__()，你需要像上邊我們剛說的那樣，明確指出，使用一個子 #類的實例去調用基類（未綁定）方法。相應地更新類C，會出現下面預期的執行結果： #class C(P): # def __init__(self): # P.__init__(self) # print "calling C's constructor" #>>> c = C() #calling P's constructor #calling C's constructor # #Python 使用基類名來調用類方法，對應在JAVA 中，是用關鍵字super 來實現的，這就是super() #內建函數引入到Python 中的原因，這樣你就可以“依葫蘆畫瓢”了: #class C(P): # def __init__(self): # super(C, self).__init__() # print "calling C's constructor" #使用super()的漂亮之處在于，你不需要明確給出任何基類名字...“跑腿事兒”，它幫你干了！ #使用super()的重點，是你不需要明確提供父類。這意味著如果你改變了類繼承關系，你只需要改一 #行代碼（class 語句本身）而不必在大量代碼中去查找所有被修改的那個類的名字。 #*********** Part 11: 類、實例和其他對象的內建函數 *********************** ## 11.1 issubclass() #issubclass() 布爾函數判斷一個類是另一個類的子類或子孫類。它有如下語法： # issubclass(sub, sup) #issubclass() 返回True 的情況：給出的子類sub 確實是父類sup 的一個子類（反之，則為False）。 #這個函數也允許“不嚴格”的子類，意味著，一個類可視為其自身的子類，所以，這個函數如果當 #sub 就是sup，或者從sup 派生而來，則返回True。（一個“嚴格的”子類是嚴格意義上的從一個類 #派生而來的子類。） #從Python 2.3 開始，issubclass()的第二個參數可以是可能的父類組成的tuple（元組），這時， #只要第一個參數是給定元組中任何一個候選類的子類時，就會返回True。 #class P(object): # def __init__(self): # print("calling P's constructor") # #class C(P): # def __init__(self): # print("calling C's constructor") # #print(issubclass(C,P)) #-->True ## 11.2 isinstance() #isinstance() 布爾函數在判定一個對象是否是另一個給定類的實例時，非常有用。它有如下語法： # isinstance(obj1, obj2) #isinstance()在obj1 是類obj2 的一個實例，或者是obj2 的子類的一個實例時，返回True（反之，則為False）. #class P(object): # def __init__(self): # print("calling P's constructor") # #p1=P() #print(isinstance(p1,P)) #-->True #也可以使用isinstance()來檢查一個對象obj1 是否是obj2 的類型: #print(isinstance(4,int)) #-->True ## 11.3 hasattr(), getattr(),setattr(), delattr() #*attr()系列函數可以在各種對象下工作，不限于類（class）和實例（instances）。 # #hasattr()函數是Boolean 型的，它的目的就是為了決定一個對象是否有一個特定的屬性，一 #般用于訪問某屬性前先作一下檢查。getattr()和setattr()函數相應地取得和賦值給對象的屬性， #getattr()會在你試圖讀取一個不存在的屬性時，引發AttributeError 異常，除非給出那個可選的 #默認參數。setattr()將要么加入一個新的屬性，要么取代一個已存在的屬性。而delattr()函數會 #從一個對象中刪除屬性。 #class myClass(object): # def __init__(self): # self.foo = 100 # #myInst = myClass() #print(hasattr(myInst, 'foo')) #print(getattr(myInst, 'foo')) #print(hasattr(myInst, 'bar')) #--> #True #100 #False ## 11.4 dir() # dir()作用在實例上（經典類或新式類）時，顯示實例變量，還有在實例所在的類及所有它 #的基類中定義的方法和類屬性。 # dir()作用在類上（經典類或新式類）時，則顯示類以及它的所有基類的__dict__中的內容。 #但它不會顯示定義在元類（metaclass）中的類屬性。 # dir()作用在模塊上時，則顯示模塊的__dict__的內容。（這沒改動）。 # dir()不帶參數時，則顯示調用者的局部變量。（也沒改動）。 # 關于更多細節:對于那些覆蓋了__dict__或__class__屬性的對象，就使用它們；出于向后兼 #容的考慮，如果已定義了__members__和__methods__，則使用它們。 ## 11.5 super() #這個函數的目的就是幫助程序員找出相應的父類，然后方便調用相關的屬性。 #一般情況下，程序員可能僅僅采用非綁定方式調用祖先類方法。使用 #super()可以簡化搜索一個合適祖先的任務，并且在調用它時，替你傳入實例或類型對象。 #對于每個定義的類，都有一個名為__mro__的屬性，它是一個元組，按照他們被搜索時的順序，列出了備搜索的類。語法如下： # super(type[, obj]) #給出type,super()“返回此type 的父類”。如果你希望父類被綁定,你可以傳入obj 參數(obj必須是type 類型的). #否則父類不會被綁定。obj 參數也可以是一個類型，但它應當是type 的一個子類。通常，當給出obj 時： # 如果 obj 是一個實例，isinstance(obj,type)就必須返回True # 如果 obj 是一個類或類型，issubclass(obj,type)就必須返回True #事實上，super()是一個工廠函數，它創造了一個super object，為一個給定的類使用__mro__去查找相應的父類。 #super() 的主要用途， 是來查找父類的屬性， 比如，super(MyClass,self).__init__()。 #如果你沒有執行這樣的查找，你可能不需要使用super()。 ## 11.6 vars() #vars()內建函數與dir()相似，只是給定的對象參數都必須有一個__dict__屬性。vars()返回一 #個字典，它包含了對象存儲于其__dict__中的屬性(鍵)及值。如果提供的對象沒有這樣一個屬性， #則會引發一個TypeError 異常。如果沒有提供對象作為vars()的一個參數，它將顯示一個包含本地 #名字空間的屬性（鍵）及其值的字典，也就是，locals(). #class C(object): # pass # #c = C() #c.foo = 100 #c.bar = 'Python' #print(c.__dict__) #print(vars(c)) #--> #{'foo': 100, 'bar': 'Python'} #{'foo': 100, 'bar': 'Python'} #*********** Part 12: 用特殊方法定制類 *********************** #特殊方法是Python 中用來擴充類的強有力的方式。它們可以實現: # 模擬標準類型 # 重載操作符 #特殊方法允許類通過重載標準操作符+,*, 甚至包括分段下標及映射操作操作[] 來模擬標準 #類型。如同其它很多保留標識符，這些方法都是以雙下劃線(__)開始及結尾的。 #下表列出了所有特殊方法及其它的描述 #特殊方法 描述 ###基本定制型 #C.__init__(self[, arg1, ...]) 構造器（帶一些可選的參數） #C.__new__(self[, arg1, ...]) 構造器（帶一些可選的參數）；通常用在設置不變數據類型的子類。 #C.__del__(self) 解構器 #C.__str__(self) 可打印的字符輸出；內建str()及print 語句 #C.__repr__(self) 運行時的字符串輸出；內建repr() 和‘‘ 操作符 #C.__unicode__(self) Unicode 字符串輸出；內建unicode() #C.__call__(self, *args) 表示可調用的實例 #C.__nonzero__(self) 為object 定義False 值；內建bool() （從2.2 版開始） #C.__len__(self) “長度”（可用于類）；內建len() ####對象（值）比較c #C.__cmp__(self, obj) 對象比較；內建cmp() #C.__lt__(self, obj) and 小于/小于或等于；對應<及<=操作符 #C.__gt__(self, obj) and 大于/大于或等于；對應>及>=操作符 #C.__eq__(self, obj) and 等于/不等于；對應==,!=及<>操作符 # #####屬性 #C.__getattr__(self, attr) 獲取屬性；內建getattr()；僅當屬性沒有找到時調用 #C.__setattr__(self, attr, val) 設置屬性 #C.__delattr__(self, attr) 刪除屬性 #C.__getattribute__(self, attr) 獲取屬性；內建getattr()；總是被調用 #C.__get__(self, attr) （描述符）獲取屬性 #C.__set__(self, attr, val) （描述符）設置屬性 #C.__delete__(self, attr) （描述符）刪除屬性 ####數值類型：二進制操作符 #C.__*add__(self, obj) 加；+操作符 #C.__*sub__(self, obj) 減；-操作符 #C.__*mul__(self, obj) 乘；*操作符 #C.__*div__(self, obj) 除；/操作符 #C.__*truediv__(self, obj) True 除；/操作符 #C.__*floordiv__(self, obj) Floor 除；//操作符 #C.__*mod__(self, obj) 取模/取余；%操作符 #C.__*divmod__(self, obj) 除和取模；內建divmod() #C.__*pow__(self, obj[, mod]) 乘冪；內建pow();**操作符 #C.__*lshift__(self, obj) 左移位；<<操作符 #C.__*rshift__(self, obj) 右移；>>操作符 #C.__*and__(self, obj) 按位與；&操作符 #C.__*or__(self, obj) 按位或；|操作符 #C.__*xor__(self, obj) 按位與或；^操作符 ####數值類型：一元操作符 #C.__neg__(self) 一元負 #C.__pos__(self) 一元正 #C.__abs__(self) 絕對值；內建abs() #C.__invert__(self) 按位求反；~操作符 # #####數值類型：數值轉換 #C.__complex__(self, com) 轉為complex(復數);內建complex() #C.__int__(self) 轉為int;內建int() #C.__long__(self) 轉為long；內建long() #C.__float__(self) 轉為float；內建float() # #####數值類型：基本表示法（String） #C.__oct__(self) 八進制表示；內建oct() #C.__hex__(self) 十六進制表示；內建hex() # #####數值類型：數值壓縮 #C.__coerce__(self, num) 壓縮成同樣的數值類型；內建coerce() #C.__index__(self) 在有必要時,壓縮可選的數值類型為整型（比如：用于切片索引等等） ####序列類型 #C.__len__(self) 序列中項的數目 #C.__getitem__(self, ind) 得到單個序列元素 #C.__setitem__(self, ind,val) 設置單個序列元素 #C.__delitem__(self, ind) 刪除單個序列元素 #C.__getslice__(self, ind1,ind2) 得到序列片斷 #C.__setslice__(self, i1, i2,val)設置序列片斷 #C.__delslice__(self, ind1,ind2) 刪除序列片斷 #C.__contains__(self, val) 測試序列成員；內建in 關鍵字 #C.__*add__(self,obj) 串連；+操作符 #C.__*mul__(self,obj) 重復；*操作符 #C.__iter__(self) 創建迭代類；內建iter() # #####映射類型 #C.__len__(self) mapping 中的項的數目 #C.__hash__(self) 散列(hash)函數值 #C.__getitem__(self,key) 得到給定鍵(key)的值 #C.__setitem__(self,key,val) 設置給定鍵(key)的值 #C.__delitem__(self,key) 刪除給定鍵(key)的值 #C.__missing__(self,key) 給定鍵如果不存在字典中，則提供一個默認值 ## 12.1 簡單定制（RoundFloat2） #類的作用：保存浮點數，四舍五入，保留兩位小數位。 通過斷言來控制輸入類型 #class RoundFloatManual(object): # def __init__(self, val): # assert isinstance(val, float), \ # "Value must be a float!" # self.value = round(val, 2) # # def __str__(self): # return str(self.value) # # __repr__ = __str__ # #C.__str__(self) 可打印的字符輸出；內建str()及print 語句 #C.__repr__(self) 運行時的字符串輸出；內建repr() 和‘‘ 操作符 #rfm=RoundFloatManual(8.888) #print(rfm) #-->8.89 ## 12.2 數值定制(Time60) #class Time60(object): # 'Time60 - track hours and minutes' # # def __init__(self, hr, min): # 'Time60 constructor - takes hours and minutes' # self.hr = hr # self.min = min # # def __str__(self): # 'Time60 - string representation' # return '%d:%d' % (self.hr, self.min) # # __repr__ = __str__ # # def __add__(self, other): # 'Time60 - overloading the addition operator' # return self.__class__(self.hr + other.hr,self.min + other.min) # # def __iadd__(self, other): # 'Time60 - overloading in-place addition' # self.hr += other.hr # self.min += other.min # return self ## 12.3 迭代器（RandSeq 和AnyIter) ## RandSeq #from random import choice # #class RandSeq(object): # def __init__(self, seq): # self.data = seq # # def __iter__(self): # return self # # def next(self): # return choice(self.data) ## 任意項的迭代器（anyIter.py） #class AnyIter(object): # def __init__(self, data, safe=False): # self.safe = safe # self.iter = iter(data) # # def __iter__(self): # return self # # def next(self, howmany=1): # retval = [] # for eachItem in range(howmany): # try: # retval.append(self.iter.next()) # except StopIteration: # if self.safe: # break # else: # raise # return retval ## 12.4 *多類型定制（NumStr） #class NumStr(object): # def __init__(self, num=0, string=''): # self.__num= num # self.__string = string # # def __str__(self): # define for str() # return '[%d :: %r]' %(self.__num, self.__string) # # __repr__ = __str__ # # def __add__(self, other): # define for s+o # if isinstance(other, NumStr): # return self.__class__(self.__num + \ # other.__num, \ # self.__string + other.__string) # else: # raise TypeError('Illegal argument type for built-in operation') # # def __mul__(self, num): # define for o*n # if isinstance(num, int): # return self.__class__(self.__num__ * num,self.__string__ * num) # else: # raise TypeError('Illegal argument type for built-in operation') # # def __nonzero__(self): # False if both are # return self.__num or len(self.__string) # #a = NumStr(3, 'foo') #b = NumStr(3, 'goo') #c = NumStr(2, 'foo') #d = NumStr() #e = NumStr(string='boo') #f = NumStr(1) #print(a) #print(b) #print(c) #print(d) #print(e) #print(f) #--> #[3 :: 'foo'] #[3 :: 'goo'] #[2 :: 'foo'] #[0 :: ''] #[0 :: 'boo'] #[1 :: ''] #*********** Part 13: 私有化 *********************** #默認情況下，屬性在Python 中都是“public”，類所在模塊和導入了類所在模塊的其他模塊的代碼都可以訪問到。 ## 13.1 雙下劃線(__) #Python 為類元素（屬性和方法）的私有性提供初步的形式。由雙下劃線開始的屬性在運行時被“混淆”，所以直接訪問是不允許的。 #實際上，會在名字前面加上下劃線和類名。比如上面示例中的：self.__num 屬性為例，被“混淆”后，用于訪問這個數據值的標識就變成了 #self._NumStr__num。把類名加上后形成的新的“混淆”結果將可以防止在祖先類或子孫類中的同名沖突。 #盡管這樣做提供了某種層次上的私有化，但算法處于公共域中并且很容易被“擊敗”。 #這更多的是一種對導入源代碼無法獲得的模塊或對同一模塊中的其他代碼的保護機制. #這種名字混淆的另一個目的,是為了保護__XXX 變量不與父類名字空間相沖突。如果在類中有一 #個__XXX 屬性，它將不會被其子類中的__XXX 屬性覆蓋。(回憶一下，如果父類僅有一個XXX 屬性， #子類也定義了這個，這時，子類的XXX 就是覆蓋了父類的XXX，這就是為什么你必須使用PARENT.XXX #來調用父類的同名方法。) 使用__XXX，子類的代碼就可以安全地使用__XXX，而不必擔心它會影響 #到父類中的__XXX。 ## 13.2 單下劃線(_) #簡單的模塊級私有化只需要在屬性名前使用一個單下劃線字符。 #這就防止模塊的屬性用“from mymodule import *”來加載。這是嚴格基于作用域的，所以這同樣適合于函數。 #*********** Part 14: 授權 *********************** ## 14.1 包裝 #“包裝”在Python 編程世界中經常會被提到的一個術語。它是一個通用的名字，意思是對一 #個已存在的對象進行包裝，不管它是數據類型，還是一段代碼，可以是對一個已存在的對象，增加 #新的，刪除不要的，或者修改其它已存在的功能。 #包裝包括定義一個類，它的實例擁有標準類型的核心行為。 ## 14.2 實現授權 #授權是包裝的一個特性，可用于簡化處理有關dictating 功能，采用已存在的功能以達到最大限度的代碼重用。 #包裝一個類型通常是對已存在的類型的一些定制。我們在前面提到過，這種做法可以新建，修 #改或刪除原有產品的功能。其它的則保持原樣，或者保留已存功能和行為。授權的過程，即是所有 #更新的功能都是由新類的某部分來處理，但已存在的功能就授權給對象的默認屬性。 # #實現授權的關鍵點就是覆蓋__getattr__()方法，在代碼中包含一個對getattr()內建函數的調 #用。特別地，調用getattr()以得到默認對象屬性（數據屬性或者方法）并返回它以便訪問或調用。 #特殊方法__getattr__()的工作方式是，當搜索一個屬性時，任何局部對象首先被找到（定制的對象）。 #如果搜索失敗了，則__getattr__()會被調用，然后調用getattr()得到一個對象的默認行為。 #換言之，當引用一個屬性時，Python 解釋器將試著在局部名稱空間中查找那個名字，比如一個 #自定義的方法或局部實例屬性。如果沒有在局部字典中找到，則搜索類名稱空間，以防一個類屬性 #被訪問。最后，如果兩類搜索都失敗了，搜索則對原對象開始授權請求，此時，__getattr__()會被調用。 #示例： class WrapMe(object): def __init__(self, obj): self.__data = obj def get(self): return self.__data def __repr__(self): return 'self.__data' def __str__(self): return str(self.__data) def __getattr__(self, attr): return getattr(self.__data, attr) #因為所有Python 數值類型，只有復數擁有屬性：數據屬性，及conjugate()內建方法（求共軛復數）。 #屬性可以是數據屬性，還可以是函數或方法. wrappedComplex = WrapMe(3.5+4.2j) #print(wrappedComplex) #-->(3.5+4.2j) #print(wrappedComplex.conjugate()) #print(wrappedComplex.get()) #--> #(3.5-4.2j) #(3.5+4.2j) #對這些屬性的訪問，是通過getattr()方法，授權給對象．最終調用get()方法沒有授權，因為它是為我們的對象定義的----它返回包裝的真實的數據對象。

-------------------------------------------------------------------------------------------------------
Blog： http://blog.csdn.net/tianlesoftware?
Weibo: http://weibo.com/tianlesoftware
Email: dvd.dba@gmail.com
DBA1 群：62697716(滿); ? DBA2 群：62697977(滿) ? DBA3 群：62697850(滿) ??
DBA 超級群：63306533(滿); ?DBA4 群： 83829929(滿) ?DBA5群： 142216823(滿) ?
DBA6 群：158654907(滿) ? DBA7 群：69087192(滿) ? DBA8 群：172855474
DBA 超級群2：151508914 ?DBA9群：102954821 ? ? ?聊天 群：40132017(滿)
--加群需要在備注說明Oracle表空間和數據文件的關系，否則拒絕申請

轉載于:https://www.cnblogs.com/spring3mvc/archive/2011/09/16/2414546.html

總結

以上是生活随笔為你收集整理的Dave Python 练习十五 -- 面向对象编程的全部內容，希望文章能夠幫你解決所遇到的問題。

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