全棧測試一 | py3基礎六：類的基礎

阿新 • • 發佈：2020-07-20

基礎概念

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方法