Python基礎-13面向對象

13 面向對象

13.1 基礎概念

• 類：

 類是具有一系列共同特征和行為的事件抽象概念集合。類所描述的概念和現實生活中的類概念非常相似。例如生物有很多種類，食物也有不同的種類，商品也有很多不同的種類。而一個類通過細分又可以劃分各種小的分類，如動物就可以分為陸生動物、水生動物和兩栖動物等等，被劃分到同一個類，其都有着相似的特征和行為方式。

• 執行個體化對象

  執行個體對象通常被定義某一個類事物的具體個體，是該類事物的一個具體表現。如人是一個類，”張三“就是人這個類的執行個體對象，因為他代表了一個具體類個體。

• 類變量

  類變量一般是定義類中，但不在類方法中的變量，可以在整個執行個體化對象中公用。

• 類屬性

  類變量或執行個體變量，常用于描述執行個體對象的特征，如張三的姓名、身高等

• 方法：

  以不嚴謹的方式來講，就是定義在類中的函數稱之為方法，常用于描述執行個體對象的行為，一般分為構造函數和正常函數。

• 繼承

  就是子類可以從父類擷取父類定義的屬性和方法等。

• 方法重寫

  如果父類的方法不能滿足子類的要求，可以定義一個方法名與父類相同名字的方法，這個過程稱之方法覆寫（如Java中@Override）或方法重寫

• 執行個體變量

  類是一個非常抽象的概念，而執行個體則代表一個具體的對象，而與對象綁定的變量可稱之為執行個體變量。

13.2 類定義

    在Python中一個簡單的類定義格式如下所示：

class Person(object):
    """
    定義一個人類
    """

    # 類變量
    classVariable="sample"
    # 構造函數，也稱執行個體化對象方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    # 類中定義的方法
    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"
           

  詳細解釋如下所示：

• 定義一個類的關鍵字為class
• Person:定義的類名稱，首字母必須大寫
• (object)：表示定義的類所繼承的父類，這裡為object
• 三引号中的字元為文檔字元串，用于描述類的功能和作用
• classVariable：類變量，所有執行個體對象可共享該變量
• _init_：構造函數，用于執行個體化一個對象前，做一些的特征描述
• name,age:執行個體化對象本身所具有的特征
• getPersonInfo：類中定義的方法，用于描述類的行為，一般常以動詞做為開頭
• self:代表執行個體化對象本身，相當于Java/C#中的this

13.3 面向對象三大特性

    面向常見的三大特性：封裝、繼承、多态。分别如下所示：

13.3.1 封裝

    封裝主要将類的屬性和方法打包為一個整體，對外部而言，仿佛是不可見的。其主要特點如下所示：

• 1.對象的行為對于外部來說是不可見的，即對象的狀态資訊是私密的。
• 2.用戶端不能通過直接操作來改變對象内部狀态。相反，用戶端需要通過發送消息來請求對象改變其内部狀态。對象根據請求的類型，通過特定的方法改變内部狀态，以做出響應
• 3.在Python中，封裝（屬性和方法的隐藏）的概念不是隐式的，因為它沒有提供諸如C系列語言的關鍵字public/private/protected。

    單下劃線和雙下劃線在Python變量和方法名中都有其特殊的含義，一部分僅僅作為一種約定，一部分則含有特殊意義，詳細如下所示：

• 前置下劃線：

    前置下劃線通常代表一種約定，表示僅在内部使用，通過針對編寫程式員，可以簡單了解為其他語言的private關鍵字。

• 後置下劃線

    通常用于解決命名沖突，在Python中，str是一個将其他類型轉換為字元串的函數，那如果寫str_，則可以代表重新定義一個變量或方法，在PyQT中，這種用法比較多。

• 前置雙下劃線

    在類環境中使用時會觸發名稱改寫，對Python解釋器有特殊含義

• 前後雙置下劃線

    前後雙置下劃線的方法被稱之為魔法方法，表示則Python語言本身定義的特殊方法，在自定義的屬性中要避免使用這種命名方式。

• 單下線

    通常用作臨時或無意義變量名稱，另外也可以表示Python REPL會話中上一個表達式的結果。

13.3.2 繼承

    繼承通常是指子類從父類中擷取父類的資料和方法等等。其主要特點如下所示：

• 1.繼承表示一個類可以繼承父類的大部分功能
• 2.繼承可以複用父類已經定義的功能并可以對父類原有功能進行擴充
• 3.繼承可以利用不同類的對象之間建立層次結構，在Python支援多重繼承。

13.3.3 多态

    多态是指不同的對象可以執行相同的動作，但卻要通過自己的實作代碼來執行。國粹平劇之前都是子承父業，代代相傳的藝術。假設有一對父子，父親是非常有名的平劇藝術家，兒子長大成人，模仿父親的戲也惟妙惟肖。有一天父親生病，導緻無法上台，而父親的戲票已經賣出，如果退票則損失太大。因為平劇都是需要化妝後才上台，那是不是兒子可以代替父親上台？在這裡需要注意以下幾點：

• 子類以父類身份出現

    兒子代替父親出演，化妝上台後就是父親身份了。

• 子類工作時必須以自己的方式實作

    兒子模仿再像也是模仿，隻能以自己的了解來出演父親的作品

• 子類以父類的身份出現時，子類特有的屬性和方法不可以使用

    兒子經過多年學習，其實已經有了自己獨特的表演模式和行為習慣，但代替父親出演時，是不能以自己的表演方式出演的。必須按父親的風格去表演。

13.4 建立類

    我們先來建立一個類，示例如下所示：

class Person:
    
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"
    
    def run(self):
        return f"{self.name} is running"
           

13.5 建立類的執行個體對象

    建立類的執行個體對象就是根據類建立具體的個體，如下所示：

person=Person("Surpass",28)
           

    以上就完成了根據Person類執行個體化一個具體的人，其名字為Surpass，年齡為28，在建立執行個體後，我們就可以通路類的屬性和方法，通過方式為：

執行個體對象.[屬性或方法]
           

13.6 使用類和執行個體

13.6.1 通路屬性

person=Person("Surpass",28)
print(f"name is {person.name},age is {person.age}")
           

13.6.2 通路方法

person=Person("Surpass",28)
print(f"person info is {person.getPersonInfo()}")
           

13.6.3 建立多個執行個體

    既然類是一種事件的抽象集合，那當然也可以根據建立n個執行個體對象了，如下所示：

personA=Person("Surpass",28)
personB=Person("Kevin",38)
personB=Person("Lisa",20)
           

13.6.4 為屬性指定預設值

    類中的每個屬性必須有初始值，對于一些經常無需要每次指派的屬性可以指定預設值，如下所示：

class Person:

    def __init__(self,name,age=28):
        self.name=name
        self.age=age

    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"

    def run(self):
        return f"{self.name} is running"
        
# 執行個體化對象
personA=Person("Surpass")
           

    看看上面的用法是不是跟函數使用很像。

13.6.5 修改屬性值

    如果需要修改屬性的值，可以使用以下方法進行修改

• 1.通過執行個體進行修改
• 2.通過調用方法進行修改

    示例代碼如下所示：

class Person:

    def __init__(self,name,age=28):
        self.name=name
        self.age=age

    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"

    def run(self):
        return f"{self.name} is running"

person=Person("Surpass",28)
print(f"Before modify property {person.name} {person.age}")
person.name="Lisa"
person.age=20
print(f"After modify property {person.name} {person.age}")
           

輸出結果如下所示：

Before modify property Surpass 28
After modify property Lisa 20
           

    通過執行個體修改直接修改屬性值非常友善，如下所示：

class Person:

    def __init__(self,name,age=28):
        self.name=name
        self.age=age

    def getName(self):
        return self.name

    def setName(self,name):
        self.name=name

    def getAge(self):
        return self.age

    def setAge(self,age):
        self.age=age

    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"

    def run(self):
        return f"{self.name} is running"

person=Person("Surpass",28)
print(f"Before modify property {person.name} {person.age}")
person.setName("Lisa")
person.setAge(20)
print(f"After modify property {person.name} {person.age}")
           

Before modify property Surpass 28
After modify property Lisa 20
           

    熟悉Java的小夥伴同學，一眼就看出來這種跟Java很像，而更道地的Python寫法如下所示：

class Person:

    def __init__(self,name,age=28):
        self._name=name
        self._age=age

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,value):
        if not isinstance(value,(str,)):
            raise TypeError("Expect str")
        else:
            self._name=value

    @name.deleter
    def name(self):
        raise AttributeError("Can not delete attribute")

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        if not isinstance(value,(int,)):
            raise TypeError("Expect a numer")
        elif value<0:
            self._age=0
        else:
            self._age=value

    @age.deleter
    def age(self):
        raise AttributeError("Can not delete attribute")

    def getPersonInfo(self):
        return f"name is {self.name},age is {self.age}"

    def run(self):
        return f"{self.name} is running"

person=Person("Surpass",28)
print(f"Before modify property {person.getPersonInfo()} ")
person.name="Lisa"
person.age=-123
print(f"After modify property {person.getPersonInfo()}")
print(f"測試異常情況")
person.name=98
person.age="098"
           

Before modify property name is Surpass,age is 28 
After modify property name is Lisa,age is 0
測試異常情況
Traceback (most recent call last):
  File "C:/Users/Surpass/Documents/PycharmProjects/SADCI/TempCode/basicCode.py", line 52, in <module>
    person.name=98
  File "C:/Users/Surpass/Documents/PycharmProjects/SADCI/TempCode/basicCode.py", line 15, in name
    raise TypeError("Expect str")
TypeError: Expect str
           

    以上這種方法，必須getter、setter、deleter三個方法的名稱必須一樣，且必須先建立getter，後面的setter、deleter才能通路和使用，那如果已經事先定義好了getter、setter、deleter的方法，還有沒有辦法實作以上這種做法？答案當然是肯定的，如下所示：

class Person:

    def __init__(self,name,age=28):
        self._name=name
        self._age=age

    def getName(self):
        return self._name

    def setName(self,value):
        if not isinstance(value,(str,)):
            raise TypeError("Expect str")
        else:
            self._name=value

    def delName(self):
        raise AttributeError("Can not delete attribute")

    def getAge(self):
        return self._age

    def setAge(self,value):
        if not isinstance(value,(int,)):
            raise TypeError("Expect a numer")
        elif value<0:
            self._age=0
        else:
            self._age=value

    def delAge(self):
        raise AttributeError("Can not delete attribute")

    ageProperty=property(getAge,setAge,delAge)
    nameProperty=property(getName,setName,delName)

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

person=Person("Surpass",28)
print(f"Before modify property {person.getPersonInfo()} ")
person.setName("Lisa")
person.setAge(-123)
print(f"After modify property {person.getPersonInfo()}")
print(f"測試異常情況")
person.setName(98)
           

Before modify property name is Surpass,age is 28 
After modify property name is Lisa,age is 0
測試異常情況
Traceback (most recent call last):
  File "C:/Users/Surpass/Documents/PycharmProjects/SADCI/TempCode/basicCode.py", line 49, in <module>
    person.setName(98)
  File "C:/Users/Surpass/Documents/PycharmProjects/SADCI/TempCode/basicCode.py", line 13, in setName
    raise TypeError("Expect str")
TypeError: Expect str
           

    以上通過方法來修改屬性的思想就是面向對象中的封裝思想。但在Python，如果一個類并不存在某個屬性，通過對象.屬性名可以添加一個新的屬性，但這種做法破壞了面向對象中的封裝特性，是以不建議使用。如下所示：

class Person:

    def __init__(self,name,age=28):
        self._name=name
        self._age=age

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,value):
        if not isinstance(value,(str,)):
            raise TypeError("Expect str")
        else:
            self._name=value

    @name.deleter
    def name(self):
        raise AttributeError("Can not delete attribute")

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        if not isinstance(value,(int,)):
            raise TypeError("Expect a numer")
        elif value<0:
            self._age=0
        else:
            self._age=value

    @age.deleter
    def age(self):
        raise AttributeError("Can not delete attribute")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

person=Person("Surpass",28)
# 通過執行個體直接增加一個新的屬性，不推薦
person.country="China"
print(f"add new person property : {person.country}")
           

add new person property : China
           

13.7 屬性

    屬性常用于描述類的特征，可以通過類中定義的方法通路，也可以通過類或執行個體進行通路。因是以屬性又可分為類屬性和執行個體屬性。

13.7.1 執行個體屬性

    執行個體屬性，通俗來講是通過self.變量名稱定義的屬性，有時也稱執行個體變量，屬于特定的執行個體對象。示例如下代碼如下所示：

class Person:

    def __init__(self,name,age):
        # 執行個體屬性指派
        self._name=name
        self._age=age

    # 擷取執行個體屬性值
    def getName(self):
        return self._name


# 執行個體屬性需要與執行個體對象進行綁定後才能通路
person=Person("Surpass",28)
print(f"{person.getName()}")
           

13.7.2 類屬性

    Python允許聲明屬于類本身的變量稱之為類屬性或類變量，類屬性無需執行個體化對象即可，如下所示：

class Person:
    # 類屬性
    classVar="類屬性"
    def __init__(self,name,age):
        # 執行個體屬性指派
        self._name=name
        self._age=age

    # 擷取執行個體屬性值
    def getName(self):
        return self._name


# 執行個體屬性需要與執行個體對象進行綁定後才能通路
person=Person("Surpass",28)
# 通路執行個體屬性-通過執行個體
print(f"通路執行個體屬性-通過執行個體:{person.getName()}")
# 通路類屬性-通執行個體
print(f"通路類屬性-通執行個體:{person.classVar}")
# 通路類屬性
print(f"通路類屬性:{Person.classVar}")
           

通路執行個體屬性-通過執行個體:Surpass
通路類屬性-通執行個體:類屬性
通路類屬性:類屬性
           

13.7.3 私有屬性

    Python沒有Java/C#語言的權限控制字段，如public/protected/private等等，通常的約定是以單下劃線開頭定義的屬性為私有屬性，如下所示：

class Person:
    # 類私有屬性
    _classVar="類屬性"
    def __init__(self,name,age):
        # 執行個體屬性指派
        self._name=name
        self._age=age

           

13.7.4 特殊屬性

    Python對象中包含很多開始和結尾以雙下劃線的開始和結束的方法，稱為特殊屬性，常見的特殊屬性如下所示：

特殊方法	含義	示例
obj. __dict__	對象的屬性字典	int.__dict__
instance.__class__	對象所屬的類	int.__class__
class.__bases__	類的基類元組	int.__bases__
class.__base__	類的基類	int.__base__

13.7.5 小結

• 1.執行個體屬性隻能通過執行個體對象進行通路
• 2.類屬性屬于類和執行個體對象共享的變量，無需要執行個體化即可通路，在執行個體化對象也可以通過執行個體對象進行通路
• 3.如果要定義一個私有，隻需要在變量加一個下劃線即可
• 4.面向對象程式設計的封裝特性原則上要求不直接通路類中的屬性，Python中可以通過定義私有屬性，然後定義相應的方法來通路和修改私有屬性，也可以使用裝飾器@property來裝飾這些函數，達到程式将函數當做屬性通路。

13.8 繼承

    在建立一個類，并不需要每次都建立。如果已經現成的類，其已有功能能滿足你的要求，那麼則可以使用繼承來達到目的。一個類繼承另一個類時，将自動擷取另一個類的屬性和方法。原有的類稱為父類，新的類稱為子類。子類除了繼承父類的屬性和方法，還可以定義自己的屬性和方法，也可以重寫父類的方法。

13.8.1 構造方法_init_()

    建立子類的執行個體時，Python首先需要完成的任務是給父類的所有屬性指派。是以子類的方法_init_()需要父類施以援手。如下所示：

1.顯式調用父類構造方法

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):

    def __init__(self,name,age,):
        super().__init__(name,age)

student=Student("Surpass",25)
print(student.getPersonInfo())
           

name is Surpass,age is 25
           

    以上代碼詳解如下所示：

• super()._init_(name,age)：顯式聲明調用父類構造方法，如果子類沒有特殊屬性，也可以省略
• student.getPersonInfo()：子類調用父類繼承過來方法

2.顯式調用父類構造方法并添加自己的屬性

    示例如下所示：

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):

    def __init__(self,name,age,classNumber):
        super().__init__(name,age)
        self._classNumber=classNumber

    def getStudentInfo(self):
        return f"name is {self._name},age is {self._age},classNumer is {self._classNumber}"

student=Student("Surpass",25,"Class-NO.1")
print(student.getStudentInfo())
           

name is Surpass,age is 25,classNumer is Class-NO.1
           

3.隐式調用父類構造方法

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):
    pass

student=Student("Surpass",25)
print(student.getPersonInfo())
           

name is Surpass,age is 25
           

    通過以上幾種，那可以猜測一下，是不是不管子類有沒有聲明構造方法，都是先調用父類構造方法呢？來看看以下示例：

1.父類和子類都有定義自己構造函數

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age
        print("1.調用父類構造方法")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):
    def __init__(self,name,age,classNumber):
        self._name=name
        self._age=age
        self._classNumber=classNumber
        print("2.調用子類構造方法")

    def getStudentInfo(self):
        return f"name is {self._name},age is {self._age},classNumer is {self._classNumber}"

student=Student("Surpass",25,"Class-No.1")
           

2.調用子類構造方法
           

2.父類有定義自己構造函數，子類未定義自己的構造函數

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age
        print("1.調用父類構造方法")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):
    pass
           

1.調用父類構造方法
           

3.父類和子類都有定義自己構造函數，但子類顯式調用父類構造方法

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age
        print("1.調用父類構造方法")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):

    def __init__(self,name,age,classNumber):
        super().__init__(name,age)
        self._classNumber=classNumber
        print("2.調用子類構造方法")

    def getStudentInfo(self):
        return f"name is {self._name},age is {self._age},classNumer is {self._classNumber}"

student=Student("Surpass",25,"Class-NO.1")
           

1.調用父類構造方法
2.調用子類構造方法
           

    通過以上代碼，可以總結出以下結論：

• 1.在子類未定義構造函數，則隐式調用父類構造函數
• 2.在子類如果顯式聲明調用父類構造函數，則先調用父類構造函數，再調用子類的構造函數
• 3.如果子類自己定義了構造函數，則隻調用子類本身的構造函數
• 4.如果需要顯式調用父類構造函數，可以使用super（英文：superclass）關鍵字
• 5.擅用super方法，可以簡化代碼，當要調用父類構造方法或普通方法時，均可以使用該關鍵字

13.8.2 子類定義屬性和方法

    當一個類繼承自父類後，父類的功能無法自身需求後，子類可以定義自己的屬性和方法，示例如下所示：

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age
        print("1.調用父類構造方法")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):

    def __init__(self,name,age,classNumber):
        super().__init__(name,age)
        # 子類自身定義的屬性
        self._classNumber=classNumber
        print("2.調用子類構造方法")

    # 子類自身定義的方法,顯式調用父類方法
    def getStudentInfo(self):
       return super().getPersonInfo()

    # 子類自身定義的方法
    def getStudentCount(self):
        studentList=[]
        studentList.append(self._name)
        return len(studentList)
           

1.調用父類構造方法
2.調用子類構造方法
調用父類方法的結果：name is Surpass,age is 25
調用子類自身的方法：student count is 1
           

13.8.3 覆寫父類方法

    在Python中覆寫父類方法非常簡單，隻需要讓子類中方法名稱與父類名稱一緻即可，如下所示：

class Person:

    def __init__(self,name,age):
        self._name=name
        self._age=age
        print("1.調用父類構造方法")

    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age}"

    def run(self):
        return f"{self._name} is running"

class Student(Person):

    def __init__(self,name,age,classNumber):
        super().__init__(name,age)
        # 子類自身定義的屬性
        self._classNumber=classNumber
        print("2.調用子類構造方法")

    # 子類自身定義的方法
    def getStudentCount(self):
        studentList=[]
        studentList.append(self._name)
        return len(studentList)

    # 覆寫父類已經定義的方法
    def getPersonInfo(self):
        return f"name is {self._name},age is {self._age},class number is {self._classNumber}"

student=Student("Surpass",25,"Class-NO.1")
print(f"調用子類自身的方法：student count is {student.getStudentCount()}")
print(f"調用子類覆寫父類的方法：{student.getPersonInfo()}")
           

1.調用父類構造方法
2.調用子類構造方法
調用子類自身的方法：student count is 1
調用子類覆寫父類的方法：name is Surpass,age is 25,class number is Class-NO.1
           

13.8.4 多重繼承

    像Java/C#等語言是單繼承（即一個類同時隻能繼承一個父類，）和多接口繼承（即一個類可繼承多個接口），多層繼承（因為繼承的父類又繼承自其他父類，看起來有多個層次），在Python中支援多重繼承（即一個類可以同時繼承多個類），示例如下所示：

class A:
    def __init__(self):
        print("1.父類構造方法-1")

    def getMethonA(self):
        print(f"1.父類方法{self.getMethonA.__name__}")


class B:
    def __init__(self):
        print("2.父類構造方法-2")

    def getMethonB(self):
        print(f"2.父類方法{self.getMethonB.__name__}")

class C:
    def __init__(self):
        print("3.父類構造方法-3")

    def getMethonC(self):
        print(f"3.父類方法{self.getMethonC.__name__}")


class D(A,B,C):

    def getMethonD(self):
        print(f"4.子類方法{self.getMethonD.__name__}")

d=D()
d.getMethonA()
d.getMethonB()
d.getMethonC()
d.getMethonD()
           

1.父類構造方法-1
1.父類方法getMethonA
2.父類方法getMethonB
3.父類方法getMethonC
4.子類方法getMethonD
           

    使用多重繼承有好也有壞

1.優點是可以調用多個父類的方法

2.缺點是如果繼承的多個父類又屬于同一個父類，則會出現二義性，另外也會造成邏輯上的複雜性增加，是以不推薦使用多重繼承

13.9 方法

    方法是與類相關的函數，Python用于定義一個方法格式如下所示：

def 方法名稱(self,參數1,參數2...):
    """函數描述"""
    函數體
    return 傳回值
           

    方法的定義也前面的函數是一緻，唯一的差別，是參數第一個位置必須是self，在Python方法常被分為構造方法、普通方法、類方法和靜态方法。

13.9.1 構造方法

    構造方法通常用于在執行個體化一個對象前，給對象傳遞一些必須的屬性值，通常以__init__()做為辨別符，一般格式如下所示：

class Person:
    # 構造方法
    def __init__(self,name,age):
        self._name=name
        self._age=age
           

13.9.2 普通方法

    除了構造方法、類方法和靜态方法之外的方法稱之為普通方法，這種方法一般由使用者自行定義的，示例如下所示：

class Person:
    # 構造方法
    def __init__(self,name,age):
        self._name=name
        self._age=age

    # 普通方法
    def getName(self):
        return self._name

person=Person("Surpass",28)
print(f"通路普通方法：{person.getName()}")
           

通路普通方法：Surpass
           

13.9.3 類方法

    類方法與類屬性非常相似，是一種屬于類的方法，不需要執行個體化就可以通路的一種方法，但需要使用裝飾器@classmethon，其文法格式如下所示，注意與普通方法的差別在于第一個參數：

＠classmethod
def 方法名稱(cls,參數1,參數2...):
   函數體
   return 傳回值
           

class Person:
    className="這是類屬性"
    # 構造方法
    def __init__(self,name,age):
        self._name=name
        self._age=age

    # 普通方法
    def getName(self):
        return self._name

    # 類方法，可以通路類屬性，但不能通路對象屬性
    @classmethod
    def getPersonInfo(cls,hello="Hello,"):
        return f"{hello} {cls.className} "


person=Person("Surpass",28)
print(f"通路普通方法：{person.getName()}")
print(f"通路類方法：{Person.getPersonInfo('Welcome, ')}")
           

通路普通方法：Surpass
通路類方法：Welcome,  這是類屬性
           

13.9.4 靜态方法

    靜态方法即不需要傳入self參數、也不需要傳入cls參數，從面使得調用靜态方法并不能擷取得類中定義的屬性和其他方法，但并不會影響類對象和執行個體對象的狀态。靜态方法有點像附屬于類的對象的工具，與普通方法不同，調用靜态方法時，隻能通過類對象或執行個體對象，而不能脫離類對象使用，即靜态方法被束縛在類對象中。其文法格式如下所示：

＠staticmethod
def 方法名稱(參數1,參數2...):
   函數體
   return 傳回值
           

class Person:
    className="這是類屬性"
    # 構造方法
    def __init__(self,name,age,height,weight):
        self._name=name
        self._age=age
        self._height=height
        self._weight=weight

    # 普通方法
    def getName(self):
        return self._name

    # 類方法，可以通路類屬性，但不能通路對象屬性
    @classmethod
    def getPersonInfo(cls,hello="Hello,"):
        return f"{hello} {cls.className} "

    # 靜态方法，不可以通路類屬性
    @staticmethod
    def getBMI(h,w):
        return w/((h/100)**2)

    # 普通方法
    def showBMI(self):
        bmi=self.getBMI(self._height,self._weight)
        return bmi

person=Person("Surpass",28,170,59)
print(f"通路普通方法：{person.getName()}")
print(f"通路類方法：{Person.getPersonInfo('Welcome, ')}")
print(f"通路靜态方法：{Person.getBMI(170,59)}")
print(f"通過執行個體對象通路：{person.showBMI()}")
           

通路普通方法：Surpass
通路類方法：Welcome,  這是類屬性
通路靜态方法：20.41522491349481
通過執行個體對象通路：20.41522491349481
           

13.9.5 小結

• 1.類方法和靜态方法都是通過裝飾器實作，而構造方法和普通方法不昌
• 2.普通方法需要顯式定義self參數，類方法需要定義cls參數，靜态方法不需要self和cls參數
• 3.普通方法隻能通過執行個體對象調用，類方法和靜态方法可以通過類對象或執行個體對象調用，如果是使用執行個體對象調用的類方法和靜态方法，最終都會轉而通過類對象調用
• 4.普通方法使用最多，可以直接處理執行個體對象的各種邏輯；類方法不需要建立執行個體對象，直接處理類對象邏輯；靜态方法将與類對象相關的部分邏輯抽離出來，可以用于測試，也友善後期維護代碼
• 5.普通方法和類方法，可以改變執行個體對象或類對象的狀态，而靜态方法不能。

本文位址：https://www.cnblogs.com/surpassme/p/12983492.html

本文同步在微信訂閱号上釋出，如各位小夥伴們喜歡我的文章，也可以關注我的微信訂閱号：woaitest，或掃描下面的二維碼添加關注：

作者：

Surpassme

來源：

http://www.jianshu.com/u/28161b7c9995/

http://www.cnblogs.com/surpassme/

聲明：本文版權歸作者所有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出

原文連結

，否則保留追究法律責任的權利。如有問題，可發送郵件 聯系。讓我們尊重原創者版權，共同營造良好的IT朋友圈。