類與實例
類與實例相互關(guān)聯(lián)著：類是對象的定義，而實例是“真正的實物”，它存放了類中所定義的對象的具體信息。

下面的示例展示了如何創(chuàng)建一個類：

class MyNewObjectType(bases):
   ''' 創(chuàng)建 MyNewObjectType 類'''
   class_suite

關(guān)鍵字是 class，緊接著一個類名。隨后是定義類的類代碼。這里通常由各種各樣的定義和聲明組成。新式類和經(jīng)典類聲明的最大不同在于，所有新式類必須繼承至少一個父類，參數(shù) bases 可以是一個（單繼承）或多個（多重繼承）用于繼承的父類。

創(chuàng)建一個實例的過程稱作實例化，過程如下（注意：沒有使用 new 關(guān)鍵字）：

myFirstObject = MyNewObjectType()

類名使用我們所熟悉的函數(shù)操作符（()），以“函數(shù)調(diào)用”的形式出現(xiàn)。然后你通常會把這個新建的實例賦給一個變量。賦值在語法上不是必須的，但如果你沒有把這個實例保存到一個變量中，它就沒用了，會被自動垃圾收集器回收，因為任何引用指向這個實例。這樣，你剛剛所做的一切，就是為那個實例分配了一塊內(nèi)存，隨即又釋放了它。

類既可以很簡單，也可以很復(fù)雜，這全憑你的需要。最簡單的情況，類僅用作名稱空間（namespace）。這意味著你把數(shù)據(jù)保存在變量中，對他們按名稱空間進行分組，使得他們處于同樣的關(guān)系空間中——所謂的關(guān)系是使用標準 Python 句點屬性標識。例如，你有一個本身沒有任何屬性的類，使用它僅對數(shù)據(jù)提供一個名字空間，讓你的類擁有像 C 語言中的結(jié)構(gòu)體（structure）一樣的特性，或者換句話說，這樣的類僅作為容器對象來共享名字空間。

示例如下：

class MyData(object):
  pass

mathObj = MyData()
mathObj.x = 4
mathObj.y = 5
mathObj.x + mathObj.y
9
mathObj.x \\* mathObj.y
20

方法
在 Python 中，方法定義在類定義中，但只能被實例所調(diào)用。也就是說，調(diào)用一個方法的最終途徑必須是這樣的：（1）定義類（和方法）；（2）創(chuàng)建一個實例；（3）最后一步，用這個實例調(diào)用方法。例如：

class MyDataWithMethod(object): # 定義類
  def printFoo(self): # 定義方法
    print 'You invoked printFoo()!'

這里的 self 參數(shù)，它在所有的方法聲明中都存在。這個參數(shù)代表實例對象本身，當你用實例調(diào)用方法時，由解釋器傳遞給方法的，所以，你不需要自己傳遞 self 進來，因為它是自動傳入的。

舉例說明一下，假如你有一個帶兩參數(shù)的方法，所有你的調(diào)用只需要傳遞第二個參數(shù)。

下面是實例化這個類，并調(diào)用那個方法：

> > > myObj = MyDataWithMethod()
> > > myObj.printFoo()
You invoked printFoo()!

\\_init\\()，是一個特殊的方法。在 Python 中， \\init\\() 實際上不是一個構(gòu)造器。你沒有調(diào)用“new”來創(chuàng)建一個新對象。（Python 根本就沒有“new”這個關(guān)鍵字）。取而代之， Python 創(chuàng)建實例后，在實例化過程中，調(diào)用 \\init\\_()方法，當一個類被實例化時，就可以定義額外的行為，比如，設(shè)定初始值或者運行一些初步診斷代碼——主要是在實例被創(chuàng)建后，實例化調(diào)用返回這個實例之前，去執(zhí)行某些特定的任務(wù)或設(shè)置。

創(chuàng)建一個類（類定義）

class AddrBookEntry(object):
  '''address book entry class'''
  def __init__(self, nm, ph): # 定義構(gòu)造器
    self.name = nm       # 設(shè)置 name
    self.phone = ph       # 設(shè)置 phone
    print 'Created instance for:', self.name

  def updatePhone(self, newph):  # 定義方法
    self.phone = newph
    print 'Updated phone# for: ', self.name

在 AddrBookEntry 類的定義中，定義了兩個方法： \\_init\\()和updatePhone()。\\init\\()在實例化時被調(diào)用，即，在AddrBookEntry()被調(diào)用時。你可以認為實例化是對 \\init\\()的一種隱式的調(diào)用，因為傳給AddrBookEntry()的參數(shù)完全與\\init\\_()接收到的參數(shù)是一樣的（除了self,它是自動傳遞的）。

創(chuàng)建實例（實例化）

> > > john = AddrBookEntry('John Doe', '408-555-1212') # 為 John Doe 創(chuàng)建實例
> > > jane = AddrBookEntry('Jane Doe', '650-555-1212') # 為 Jane Doe 創(chuàng)建實例

這就是實例化調(diào)用，它會自動調(diào)用 \\_init\\()。 self 把實例對象自動傳入\\init\\_()。

另外，如果不存在默認的參數(shù)，那么傳給 \\_init\\_() 的兩個參數(shù)在實例化時是必須的。

訪問實例屬性

> > > john
> > > john.name
> > > jane.name
> > > jane.phone

一旦實例被創(chuàng)建后，就可以證實一下，在實例化過程中，我們的實例屬性是否確實被 \\_init\\_() 設(shè)置了。我們可以通過解釋器“轉(zhuǎn)儲”實例來查看它是什么類型的對象。

方法調(diào)用（通過實例）

> > > john.updatePhone('415-555-1212')  # 更新 John Doe 的電話
> > > john.phone

updatePhone()方法需要一個參數(shù)（不計 self 在內(nèi)）：新的電話號碼。在 updatePhone()之后，立即檢查實例屬性，可以證實已生效。

方法與屬性的小結(jié)
直接上代碼，已經(jīng)在里面有注釋了

#coding:utf8

name = 'yangyanxing'
class Test():
  class kevin():
    var1 = '我是內(nèi)部類'

  name = 'kvein'
  gae = '26'

  def fun1(self):
    print self.name
    print '我是公共方法'
    self.__fun2() #可以通過公有就去來調(diào)用私有方法，在調(diào)用的過程中可以進行更改

  def __fun2(self):
    print '我是私有方法'

  @classmethod
  def fun3(self): #可以不通過實例來訪問這個類方法
    print '#'*40
    print self.name
    print '我是類方法'

  @staticmethod #靜態(tài)方法，也是可以不通過實例對象就可以訪問的方法但是在定義的時候不用加self
  def fun4():
    print Test.name
    print name #這里的name是全局變量
    Test.fun3()
    print '我是靜態(tài)方法'

print Test.name #公有屬性可以直接方法，不用實例化對象
yang = Test() #實例化一個類
interyang = Test.kevin() #實例化一個內(nèi)部類
yang.fun1() #方法類里面的公共屬性
print interyang.var1 # 訪問內(nèi)部類里的屬性
Test.fun3()#訪問類方法
Test.fun4()
#coding:utf8

class Test():
  var1 = '類的公有屬性'
  __var2 = '類的私有屬性'

  def fun(self):
    self.var2 = '對象的公有屬性' # 這里定義了一個對象的公有屬性
    self.__var3 = '對象的私有屬性'# 這里定義了一個對象的私有屬性
    var4 = '函數(shù)的局部變量' #這里定義了一個函數(shù)的局部變量，這里面的var4只有在函數(shù)內(nèi)部使用

kevin = Test() #實例了一個對象
yang = Test() #又實例了另外一個對象
print kevin.var1
##print kevin.__var2 #這里將無法訪問
kevin.fun()
print kevin.var2 #在沒有調(diào)用fun函數(shù)之前是沒有var2的
##print kevin.__var3 對象的私有屬性是無法調(diào)用的
##print yang.var2 #這里因為沒有調(diào)用yang的fun方法，所以還是無法訪問yang里的var2

創(chuàng)建子類
靠繼承來進行子類化是創(chuàng)建和定制新類型的一種方式，新的類將保持已存在類所有的特性，而不會改動原來類的定義。對于新類類型而言，這個新的子類可以定制只屬于它的特定功能。除了與父類或基類的關(guān)系外，子類與通常的類沒有什么區(qū)別，也像一般類一樣進行實例化。注意下面，子類聲明中提到了父類：

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

現(xiàn)在我們創(chuàng)建了第一個子類， EmplAddrBookEntry。 Python 中，當一個類被派生出來，子類就繼承了基類的屬性，所以，在上面的類中，我們不僅定義了 \\_init\\_()，UpdateEmail()方法，而且 EmplAddrBookEntry 還從 AddrBookEntry 中繼承了 updatePhone()方法。

如果需要，每個子類最好定義它自己的構(gòu)造器，不然，基類的構(gòu)造器會被調(diào)用。然而，如果子類重寫基類的構(gòu)造器，基類的構(gòu)造器就不會被自動調(diào)用了——這樣，基類的構(gòu)造器就必須顯式寫出才會被執(zhí)行，就像我們上面那樣，用AddrBookEntry.\\_init\\_()設(shè)置名字和電話號碼。我們的子類在構(gòu)造器后面幾行還設(shè)置了另外兩個實例屬性：員工ID和電子郵件地址。

注意，這里我們要顯式傳遞 self 實例對象給基類構(gòu)造器，因為我們不是在該實例中而是在一個子類實例中調(diào)用那個方法。因為我們不是通過實例來調(diào)用它，這種未綁定的方法調(diào)用需要傳遞一個適當?shù)膶嵗╯elf）給方法。

使用子類

> > > john = EmplAddrBookEntry('John Doe', '408-555-1212', 42, 'john@spam.doe')
> > > john
> > > john.name
> > > john.phone
> > > john.email
> > > john.updatePhone('415-555-1212')
> > > john.phone
> > > john.updateEmail('john@doe.spam')
> > > john.email

最新評論