python物件導向，類

標籤：python物件導向

1：類和對象

    是物件導向中的倆個重要概念，類是對事物的抽象，比如人類，球類。對象是事物的執行個體，比如足球，籃球。球類可以對球的特徵和行為進行抽象，然後可以執行個體化一個真實的球體出來。

2：類的定義

    類把需要的變數和函數組合成一起，這種包含稱為“封裝”。。classA（object）：

3：類的結構

    class類名：

        成員變數-屬性              ## 類的屬性是對資料的封裝

        成員函數-方法              ## 類的方法是對類的行為進行封裝

    類的建立：

        class MyClass1(object):        ## 類名

            color = ‘Black‘          ## 類的屬性-變數

           def fun(self):           ## 類的方法中必須有參數self，這是成員函數類的方法

                print "I am function"

#!/usr/bin/python
class People():
    color = ‘yellow‘             ## 成員變數
    def think(self):             ## 成員函數
        self.color = ‘Black‘     ## self表示類本身
        print ‘I am a %s‘ % self.color
        print ‘I am a thinker‘
ren = People()                   ## 把類賦予一個變數，即執行個體化
print ren.color
ren.think()

4：類的屬性

    公有屬性：在類中類外都可以使用。

    私人屬性：只能在類中使用，定義方式為__name（雙底線）

    內建屬性：由系統定義類的時候預設添加的，由前後雙底線構成。__dict__,__module__。

#!/usr/bin/python
class People():
    color = ‘yellow‘
    __age = 20
    def think(self):
        self.color = ‘Black‘
        print ‘I am a %s‘ % self.color
        print ‘I am a thinker‘
        print self.__age   ## 私人函數，只能在類中使用
ren = People()
print ren.color
ren.think()
print ren._People__age     ## 僅測試使用，類外使用私人函數

5：類的方法相當於函數，類的屬性相當於變數。

    方法的定義跟函數一樣，但是需要self作為第一個參數。

        公有方法：跟公有屬性一樣，類內類外都可以使用

        私人方法：跟私人屬性一樣，只能類內使用。__self

        self：用來區分類跟方法，self本身表示類

        類方法：被classmethod編譯過的函數，能被類所調用，也能被對象調用（繼承的關係）

        靜態方法：被staticmethod編譯過的函數，可以被類直接調用，靜態方法不需要設定self參數。

        裝飾器：

            @classmethod：類方法

            @staticmethod：靜態方法

6：對象的建立

    建立對象的過程稱之為執行個體化：當一個對象被建立後，包含三個方面的特性：物件控點，屬性，方法。控制代碼用來區分對象。

    對象的屬性和方法與類中的成員變數和成員函數相對應

    object=MyClass() ## 建立類的一個執行個體（對象），通過對象來調用方法和屬性

#!/usr/bin/python
# coding:utf-8
class MyClass1(object):                   ## 類
    color = ‘Yellow‘                      ## 類的屬性--變數
    __age = 20                            ## 類的私人屬性，只能在類中使用
    @classmethod
    def __hide(self):                     ## 類的隱藏方法，只能在類中使用
        print "I am hidemethods!"
    @classmethod                          ## 裝飾，對象和類都可以調用
    def fun(self):                        ## 類的方法--函數
        print self.__age                  ## self等同類，表示調用類的私人屬性
        print ‘This is function!‘
    @staticmethod                         ## 裝飾，對象和類都能調用，不需要self
    def fun1():                           ## 不需要self
        print MyClass1.color              ## 直接使用類調用類的屬性或方法
        MyClass1.__hide()                 ## 調用類的隱藏方法
    class InsideClass(object):            ## 類中類，內部類
        Inside = ‘Red‘                    ## 內部類的屬性
        @classmethod
        def InsideFun(self):              ## 內部類的方法
            print self.Inside
object = MyClass1()                       ## 對象，執行個體化類
object.fun()                              ## 對象調用類的方法
MyClass1.fun()                            ## 類調用類的方法
MyClass1.fun1()
object_inside = object.InsideClass()      ## 先調用外部類，再調用內部類
MyClass1.InsideClass.InsideFun()          ## 調用內部類的方法
print object_inside.Inside                ## 調用內部類的屬性

7：內部方法（魔術方法）

    def __str__(self):               ## 如果直接執行個體化類，會返回__str__的值，而不是提示這樣<對象>

       return "This is class object!"

   建構函式

    def __init__(self,c=‘Black‘):       ## 初始化對象的屬性，但不會改變類的屬性

       self.color = c        

    解構函式

    def __del__(self):                         ## 主要用於釋放資源，一般執行與指令碼的最後

#!/usr/bin/python
class PeoPle(object):
    color = ‘Black‘
    def __init__(self,c):                         ## 初始化屬性，c需要在執行個體化類的時候，跟在後面
        self.color = c
        print "Init runinng ......"               ## 只要把類執行個體化成對象，就會列印這行，
    def fun1(self):
        print "Color is: %s" % self.color
pe = PeoPle(‘Red‘)
print "Object print is: %s" %pe.color             ## __init__會影響對象的屬性
print "Class print is: %s" %PeoPle.color          ## 類不會受__init__的影響

類的繼承：

單類繼承

#!/usr/bin/python
class PeoPle(object):
    color = ‘Black‘
    def __init__(self,c):                   ## 初始化參數
        self.color = c
        print "Init runinng ......"
    @classmethod                            ## 裝飾方法，使其對象和類都可以調用
    def fun1(self):
        print "Color is: %s" % self.color
class MyClass(PeoPle):                      ## 繼承父類PeoPle  
    color = ‘MyClass‘
    def __init__(self):
        PeoPle.__init__(self.‘Red‘)         ## 表示繼承父類的__init__建構函式。                      
    @classmethod
    def fun1(self):
       print "This is MyClass the function"
    pass
my=MyClass()                      ## 由於MyClass類中繼承過PeoPle裡的__init__參數。
print MyClass.color               ## 優先返回MyClass裡的屬性
my.fun1()                         ## 優先返回MyClass裡的方法
PeoPle.fun1()                     ## 返回PeoPle裡的fun1方法
MyClass.fun1()                    ## 返回MyClass裡的fun1方法
pe = PeoPle(‘Green‘)              ## 由於PeoPle初始化__init__那裡需要倆個參數，所以這裡要加一個參數
print "Object print is: %s" % pe.color  ## 列印初始化後對象的屬性即Green
print "Class print is: %s" % PeoPle.color  ## 列印類屬性即Black 

多類繼承：

#!/usr/bin/python
class PeoPle(object):
    def __init__(self):
        self.dwell = ‘Earth‘
        self.color = ‘Yellow‘
    def think(self):
        print "I dwell am %s!" % self.dwell
class Chinese(object):
    color = ‘Black‘
    def __init__(self):
        self.dwell = ‘China‘
    def think(self):
        print "I am chinese %s " % self.color
class MyClass(Chinese,PeoPle):       ## 預設首先繼續第一個類的屬性跟方法                    
    def __init__(self): 
        PeoPle.__init__(self)        ## 表示使用指定類的屬性
    pass
my = MyClass()
my.think()                           ## 返回I am Chinese Yellow

類的屬性---總結

• 類屬性（公有屬性）： 可以在類中使用，相當於變數。    

• 類私人屬性（私人屬性）： 只能函數中使用，無法被對象調用

• 對象的公有屬性： 對象可以調用

• 對象的私人屬性： 只能類中調用

• 內建屬性：

• 函數的局部變數： 只能在本函數中使用

• 函數的全域變數： 可以在類中所有的函數裡使用

#!/usr/bin/python
# coding:utf8
val6 = "全域變數"
print ‘*‘ * 50
class My(object):
    val1 = "類的公有屬性 val1"
    __val2 = "類的私人屬性 __val2"
    def fun(self):
        self.val3 = "對象的公有屬性 val3"
        self.__val4 = "對象的私人屬性 __val4"
        val5 = "函數的局部變數,只能在本函數使用"
        global val6
        val6 = "函數的全域變數,可以在類中所有的函數中使用"
    def fun1(self):
        print val6
my = My()
print my.val1
print my._My__val2
my.fun()
print ‘*‘ * 50
my.fun1()

類的方法總結：

• 公有方法：

• 私人方法：

• 類方法：

• 靜態方法：

• 內建方法：

#!/usr/bin/python
#-*- coding:utf8 -*_
class MyClass(object):
    name = ‘Warning‘
    def __init__(self):
        self.fun1()
        self.__fun2()
        self.fun3()
        self.fun4()
    def fun1(self):
        print "%s %s" % (self.name,‘我是公有方法‘)
    def __fun2(self):
        print "%s %s" % (self.name,‘我是私人方法‘)
    @classmethod
    def fun3(self):
        print "%s %s" % (self.name,‘我是類方法‘)
    @staticmethod
    def fun4():
        print "%s %s" % (MyClass.name,‘我是靜態方法‘)
my = MyClass()
my.fun1()                           ## 調用公有方法
MyClass.fun3()                      ## 調用類方法
MyClass.fun4()                      ## 調用靜態方法，注意靜態方法不需要self,與類方法的區別

本文出自 “擱淺丶” 部落格，請務必保留此出處http://yasar.blog.51cto.com/9120455/1875574

python物件導向，類