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

時間  2019-12-04
標籤 python3 python 速查 參考 基礎 面向對象 建立 使用 類屬 property 方法 靜態 經常 知識 概念 封裝 繼承 等等 一章 欄目 Python 简体版
原文   原文鏈接

基礎概念

 

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.學習筆記

面向對象：狗吃（屎）java

面向過程：吃狗（屎）python

類：具備共同特徵和行爲的一組對象的抽象定義。類至關於製造飛機的圖紙，用它建立的飛機至關於對象。函數

類就是建立對象的模板。工具

 

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方法
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程