基礎概念

1.速查筆記：

#-- 最普通的類  
    class C1(C2, C3):  
        spam = 42                       # 數據屬性  
        def __init__(self, name):       # 函數屬性:構造函數  
            self.name = name  
        def __del__(self):              # 函數屬性:析構函數  
            print("goodbey ", self.name)      
    I1 
 
= C1(‘bob‘)  
      
#-- Python的類沒有基於參數的函數重載  
    class FirstClass:  
        def test(self, string):  
            print(string)  
        def test(self):                 # 此時類中只有一個test函數 即後者test(self) 它覆蓋掉前者帶參數的test函數  
            print("hello world")  
  
#-- 子類擴展超類: 盡量調用超類的方法  
    class
 
 Manager(Person):  
        def giveRaise(self, percent, bonus = .10):  
            self.pay = int(self.pay*(1 + percent + bonus))     # 不好的方式 復制粘貼超類代碼  
            Person.giveRaise(self, percent + bonus)            # 好的方式 盡量調用超類方法  
  
#-- 類內省工具  
    bob = Person(‘bob‘)  
    bob.__class__
 
                       # <class ‘Person‘>  
    bob.__class__.__name__              # ‘Person‘  
    bob.__dict__                        # {‘pay‘:0, ‘name‘:‘bob‘, ‘job‘:‘Manager‘}  
      
#-- 返回1中 數據屬性spam是屬於類 而不是對象  
    I1 = C1(‘bob‘); I2 = C2(‘tom‘)      # 此時I1和I2的spam都為42 但是都是返回的C1的spam屬性  
    C1.spam = 24                        # 此時I1和I2的spam都為24  
    I1.spam = 3                         # 此時I1新增自有屬性spam 值為2 I2和C1的spam還都為24  
      
#-- 類方法調用的兩種方式  
    instance.method(arg...)  
    class.method(instance, arg...)  

2.學習筆記

面向對象：狗吃（屎）

面向過程：吃狗（屎）

類：具有共同特征和行為的一組對象的抽象定義。類相當於制造飛機的圖紙，用它創建的飛機相當於對象。

類就是創建對象的模板。

3.類的創建中self的含義

# -*-  coding:utf-8 -*-
class Test():
    def __init__(self,name):
        self.name=name

try1 = Test(‘python‘) #當前調用class中方法的對象，此語句就是創建一個對象，對應類中定義的self

4. __init__方法講解

# -*-  coding:utf-8 -*-
class Test():
    def __init__(self,name,age):#__init__在創建一個對象的時候，默認被調用，不需要手動調用
        self.name = name    #__init__(self)中，定義了兩個形參，那麽創建對象時需要傳遞兩個實參
        self.age = age    #self參數，Python解釋器會自動把當前的對象引用傳遞進去，不需要開發者傳遞

try1 = Test(‘python‘,12) #當前調用class中方法的對象，此語句就是創建一個對象，對應類中定義的self

5. __str__方法

# -*-  coding:utf-8 -*-
"""
__str__定義在類內部，必須返回一個字符串類型
實例化不會觸發__str__方法，但是打印的話就會觸發
"""
class Test():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return "name %s,age%d"%(self.name,self.age)

try1 = Test(‘python‘,12)
print(try1)

類的屬性

# -*-  coding:utf-8 -*-
class test2():
    name = wm    #公共的類屬性
    __age = 18  #私有的類屬性，只能在類的內部調用
    def __init__(self,user,pw):
        self.user = user
        self.pw = pw
a = test2(‘python‘,20)
print(a.name)
print(a.__age)    #會報錯

靜態方法和類方法

1. 速查筆記

#-- #實例方法 / 靜態方法 / 類方法  
    class Methods:  
        def imeth(self, x): print(self, x)      # 實例方法：傳入的是實例和數據，操作的是實例的屬性  
        def smeth(x): print(x)                  # 靜態方法：只傳入數據 不傳入實例，操作的是類的屬性而不是實例的屬性  
        def cmeth(cls, x): print(cls, x)        # 類方法：傳入的是類對象和數據  
        smeth = staticmethod(smeth)             # 調用內置函數，也可以使用@staticmethod  
        cmeth = classmethod(cmeth)              # 調用內置函數，也可以使用@classmethod  
    obj = Methods()  
    obj.imeth(1)                                # 實例方法調用 <__main__.Methods object...> 1  
    Methods.imeth(obj, 2)                       # <__main__.Methods object...> 2  
    Methods.smeth(3)                            # 靜態方法調用 3  
    obj.smeth(4)                                # 這裏可以使用實例進行調用  
    Methods.cmeth(5)                            # 類方法調用 <class ‘__main__.Methods‘> 5  
    obj.cmeth(6)                                # <class ‘__main__.Methods‘> 6  
      
#-- 函數裝飾器:是它後邊的函數的運行時的聲明 由@符號以及後邊緊跟的"元函數"(metafunction)組成  
        @staticmethod  
        def smeth(x): print(x)  
    # 等同於:  
        def smeth(x): print(x)  
        smeth = staticmethod(smeth)  
    # 同理  
        @classmethod  
        def cmeth(cls, x): print(x)  
    # 等同於  
        def cmeth(cls, x): print(x)  
        cmeth = classmethod(cmeth)  
      
#-- 類修飾器:是它後邊的類的運行時的聲明 由@符號以及後邊緊跟的"元函數"(metafunction)組成  
        def decorator(aClass):.....  
        @decorator  
        class C:....  
    # 等同於:  
        class C:....  
        C = decorator(C)  #-- #實例方法 / 靜態方法 / 類方法  
    class Methods:  
        def imeth(self, x): print(self, x)      # 實例方法：傳入的是實例和數據，操作的是實例的屬性  
        def smeth(x): print(x)                  # 靜態方法：只傳入數據 不傳入實例，操作的是類的屬性而不是實例的屬性  
        def cmeth(cls, x): print(cls, x)        # 類方法：傳入的是類對象和數據  
        smeth = staticmethod(smeth)             # 調用內置函數，也可以使用@staticmethod  
        cmeth = classmethod(cmeth)              # 調用內置函數，也可以使用@classmethod  
    obj = Methods()  
    obj.imeth(1)                                # 實例方法調用 <__main__.Methods object...> 1  
    Methods.imeth(obj, 2)                       # <__main__.Methods object...> 2  
    Methods.smeth(3)                            # 靜態方法調用 3  
    obj.smeth(4)                                # 這裏可以使用實例進行調用  
    Methods.cmeth(5)                            # 類方法調用 <class ‘__main__.Methods‘> 5  
    obj.cmeth(6)                                # <class ‘__main__.Methods‘> 6  
      
#-- 函數裝飾器:是它後邊的函數的運行時的聲明 由@符號以及後邊緊跟的"元函數"(metafunction)組成  
        @staticmethod  
        def smeth(x): print(x)  
    # 等同於:  
        def smeth(x): print(x)  
        smeth = staticmethod(smeth)  
    # 同理  
        @classmethod  
        def cmeth(cls, x): print(x)  
    # 等同於  
        def cmeth(cls, x): print(x)  
        cmeth = classmethod(cmeth)  
      
#-- 類修飾器:是它後邊的類的運行時的聲明 由@符號以及後邊緊跟的"元函數"(metafunction)組成  
        def decorator(aClass):.....  
        @decorator  
        class C:....  
    # 等同於:  
        class C:....  
        C = decorator(C)  

2. 類方法

• 定義：類方法是給類用的，類在使用時會將類本身當做參數傳給類方法的第一個參數，python為我們內置了函數classmethod來把類中的函數定義成類方法,一般以cls作為第一個參數
• 實例代碼：
  

  # -*-  coding:utf-8 -*-
  class People(object):
      country = ‘china‘
  
      @classmethod
      def getCountry(cls):
          return cls.country
  p = People
  print(p.getCountry())

3. 靜態方法

實例釋義：

# -*-  coding:utf-8 -*-
class A(object):
    name = ‘python‘
    def test1(self):
        print(‘--test1--‘)
    @classmethod
    def test2(cls):#cls代表當前類A
        cls.name = ‘java‘
        print(‘--test2--‘)
    @staticmethod
    def test3():#靜態方法屬於類，沒有類方法中那樣的默認參數cls，但是可以通過類對象來調用，也可以用類名來調用
        A.name = ‘C#‘
        print(‘--test3--‘)
a = A()
a.test1()
a.test2()
a.test3()
print(A.name)

property的使用

1. 速查筆記

#-- 類屬性高級話題: @property  
    # 假設定義了一個類:C，該類必須繼承自object類，有一私有變量_x  
    class C(object):  
        def __init__(self):  
            self.__x = None  
    # 第一種使用屬性的方法  
        def getx(self):  
            return self.__x  
        def setx(self, value):  
            self.__x = value  
        def delx(self):  
            del self.__x  
        x = property(getx, setx, delx, ‘‘)  
    # property函數原型為property(fget=None,fset=None,fdel=None,doc=None)  
    # 使用  
    c = C()  
    c.x = 100                         # 自動調用setx方法  
    y = c.x                           # 自動調用getx方法  
    del c.x                           # 自動調用delx方法  
    # 第二種方法使用屬性的方法  
        @property  
        def x(self):  
            return self.__x  
        @x.setter  
        def x(self, value):  
           self.__x = value  
        @x.deleter  
        def x(self):  
           del self.__x  
    # 使用  
    c = C()  
    c.x = 100                         # 自動調用setter方法  
    y = c.x                           # 自動調用x方法  
    del c.x                           # 自動調用deleter方法  
      

python3 速查參考- python基礎 8 -> 面向對象基礎：類的創建與基礎使用，類屬性，property、類方法、靜態方法、常用知識點概念（封裝、繼承等等見下一章）