類與實例
類與實例相互關聯著：類是對象的定義，而實例是“真正的實物”，它存放了類中所定義的對象的具體信息。
下面的示例展示了如何創建一個類：
|
1
2
3
|
class MyNewObjectType(bases): ''' 創建 MyNewObjectType 類''' class_suite |
關鍵字是 class，緊接著一個類名。隨后是定義類的類代碼。這里通常由各種各樣的定義和聲明組成。新式類和經典類聲明的最大不同在于，所有新式類必須繼承至少一個父類，參數 bases 可以是一個（單繼承）或多個（多重繼承）用于繼承的父類。
創建一個實例的過程稱作實例化，過程如下（注意：沒有使用 new 關鍵字）：
|
1
|
myFirstObject = MyNewObjectType() |
類名使用我們所熟悉的函數操作符（()），以“函數調用”的形式出現。然后你通常會把這個新建的實例賦給一個變量。賦值在語法上不是必須的，但如果你沒有把這個實例保存到一個變量中，它就沒用了，會被自動垃圾收集器回收，因為任何引用指向這個實例。這樣，你剛剛所做的一切，就是為那個實例分配了一塊內存，隨即又釋放了它。
類既可以很簡單，也可以很復雜，這全憑你的需要。最簡單的情況，類僅用作名稱空間（namespace）。這意味著你把數據保存在變量中，對他們按名稱空間進行分組，使得他們處于同樣的關系空間中——所謂的關系是使用標準 Python 句點屬性標識。例如，你有一個本身沒有任何屬性的類，使用它僅對數據提供一個名字空間，讓你的類擁有像 C 語言中的結構體（structure）一樣的特性，或者換句話說，這樣的類僅作為容器對象來共享名字空間。
示例如下：
|
1
2
3
4
5
6
7
8
9
10
|
class MyData(object): passmathObj = MyData()mathObj.x = 4mathObj.y = 5mathObj.x + mathObj.y9mathObj.x \\* mathObj.y20 |
方法
在 Python 中，方法定義在類定義中，但只能被實例所調用。也就是說，調用一個方法的最終途徑必須是這樣的：（1）定義類（和方法）；（2）創建一個實例；（3）最后一步，用這個實例調用方法。例如：
|
1
2
3
|
class MyDataWithMethod(object): # 定義類 def printFoo(self): # 定義方法 print 'You invoked printFoo()!' |
這里的 self 參數，它在所有的方法聲明中都存在。這個參數代表實例對象本身，當你用實例調用方法時，由解釋器傳遞給方法的，所以，你不需要自己傳遞 self 進來，因為它是自動傳入的。
舉例說明一下，假如你有一個帶兩參數的方法，所有你的調用只需要傳遞第二個參數。
下面是實例化這個類，并調用那個方法：
|
1
2
3
|
> > > myObj = MyDataWithMethod()> > > myObj.printFoo()You invoked printFoo()! |
\\_init\\()，是一個特殊的方法。在 Python 中， \\init\\() 實際上不是一個構造器。你沒有調用“new”來創建一個新對象。（Python 根本就沒有“new”這個關鍵字）。取而代之， Python 創建實例后，在實例化過程中，調用 \\init\\_()方法，當一個類被實例化時，就可以定義額外的行為，比如，設定初始值或者運行一些初步診斷代碼——主要是在實例被創建后，實例化調用返回這個實例之前，去執行某些特定的任務或設置。
創建一個類（類定義）
|
1
2
3
4
5
6
7
8
9
10
|
class AddrBookEntry(object): '''address book entry class''' def __init__(self, nm, ph): # 定義構造器 self.name = nm # 設置 name self.phone = ph # 設置 phone print 'Created instance for:', self.name def updatePhone(self, newph): # 定義方法 self.phone = newph print 'Updated phone# for: ', self.name |
在 AddrBookEntry 類的定義中，定義了兩個方法： \\_init\\()和updatePhone()。\\init\\()在實例化時被調用，即，在AddrBookEntry()被調用時。你可以認為實例化是對 \\init\\()的一種隱式的調用，因為傳給AddrBookEntry()的參數完全與\\init\\_()接收到的參數是一樣的（除了self,它是自動傳遞的）。
創建實例（實例化）
|
1
2
|
> > > john = AddrBookEntry('John Doe', '408-555-1212') # 為 John Doe 創建實例> > > jane = AddrBookEntry('Jane Doe', '650-555-1212') # 為 Jane Doe 創建實例 |
這就是實例化調用，它會自動調用 \\_init\\()。 self 把實例對象自動傳入\\init\\_()。
另外，如果不存在默認的參數，那么傳給 \\_init\\_() 的兩個參數在實例化時是必須的。
訪問實例屬性
|
1
2
3
4
|
> > > john> > > john.name> > > jane.name> > > jane.phone |
一旦實例被創建后，就可以證實一下，在實例化過程中，我們的實例屬性是否確實被 \\_init\\_() 設置了。我們可以通過解釋器“轉儲”實例來查看它是什么類型的對象。
方法調用（通過實例）
|
1
2
|
> > > john.updatePhone('415-555-1212') # 更新 John Doe 的電話> > > john.phone |
updatePhone()方法需要一個參數（不計 self 在內）：新的電話號碼。在 updatePhone()之后，立即檢查實例屬性，可以證實已生效。
方法與屬性的小結
直接上代碼，已經在里面有注釋了
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
#coding:utf8name = 'yangyanxing'class Test(): class kevin(): var1 = '我是內部類' name = 'kvein' gae = '26' def fun1(self): print self.name print '我是公共方法' self.__fun2() #可以通過公有就去來調用私有方法，在調用的過程中可以進行更改 def __fun2(self): print '我是私有方法' @classmethod def fun3(self): #可以不通過實例來訪問這個類方法 print '#'*40 print self.name print '我是類方法' @staticmethod #靜態方法，也是可以不通過實例對象就可以訪問的方法但是在定義的時候不用加self def fun4(): print Test.name print name #這里的name是全局變量 Test.fun3() print '我是靜態方法'print Test.name #公有屬性可以直接方法，不用實例化對象yang = Test() #實例化一個類interyang = Test.kevin() #實例化一個內部類yang.fun1() #方法類里面的公共屬性print interyang.var1 # 訪問內部類里的屬性Test.fun3()#訪問類方法Test.fun4()#coding:utf8class Test(): var1 = '類的公有屬性' __var2 = '類的私有屬性' def fun(self): self.var2 = '對象的公有屬性' # 這里定義了一個對象的公有屬性 self.__var3 = '對象的私有屬性'# 這里定義了一個對象的私有屬性 var4 = '函數的局部變量' #這里定義了一個函數的局部變量，這里面的var4只有在函數內部使用kevin = Test() #實例了一個對象yang = Test() #又實例了另外一個對象print kevin.var1##print kevin.__var2 #這里將無法訪問kevin.fun()print kevin.var2 #在沒有調用fun函數之前是沒有var2的##print kevin.__var3 對象的私有屬性是無法調用的##print yang.var2 #這里因為沒有調用yang的fun方法，所以還是無法訪問yang里的var2 |
創建子類
靠繼承來進行子類化是創建和定制新類型的一種方式，新的類將保持已存在類所有的特性，而不會改動原來類的定義。對于新類類型而言，這個新的子類可以定制只屬于它的特定功能。除了與父類或基類的關系外，子類與通常的類沒有什么區別，也像一般類一樣進行實例化。注意下面，子類聲明中提到了父類：
|
1
2
3
4
5
6
7
8
9
10
|
class EmplAddrBookEntry(AddrBookEntry): '''Employee Address Book Entry class''' # 員工地址簿類 def __init__(self, nm, ph, id, em): AddrBookEntry.__init__(self, nm, ph) self.empid = id self.email = em def updateEmail(self, newem): self.email = newem print 'Updated e-mail address for:', self.name |
現在我們創建了第一個子類， EmplAddrBookEntry。 Python 中，當一個類被派生出來，子類就繼承了基類的屬性，所以，在上面的類中，我們不僅定義了 \\_init\\_()，UpdateEmail()方法，而且 EmplAddrBookEntry 還從 AddrBookEntry 中繼承了 updatePhone()方法。
如果需要，每個子類最好定義它自己的構造器，不然，基類的構造器會被調用。然而，如果子類重寫基類的構造器，基類的構造器就不會被自動調用了——這樣，基類的構造器就必須顯式寫出才會被執行，就像我們上面那樣，用AddrBookEntry.\\_init\\_()設置名字和電話號碼。我們的子類在構造器后面幾行還設置了另外兩個實例屬性：員工ID和電子郵件地址。
注意，這里我們要顯式傳遞 self 實例對象給基類構造器，因為我們不是在該實例中而是在一個子類實例中調用那個方法。因為我們不是通過實例來調用它，這種未綁定的方法調用需要傳遞一個適當的實例（self）給方法。
使用子類
|
1
2
3
4
5
6
7
8
9
|
> > > john> > > john.name> > > john.phone> > > john.email> > > john.updatePhone('415-555-1212')> > > john.phone> > > john.email |
