Python基礎-13面向對象

来源:https://www.cnblogs.com/surpassme/archive/2020/05/28/12983492.html
-Advertisement-
Play Games

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


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.通過調用方法進行修改

1.通過實例進行修改

    示例代碼如下所示：

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

2.通過調用方法進行修改

    通過實例修改直接修改屬性值非常方便，如下所示：

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，或掃描下麵的二維碼添加關註：
MyQRCode.jpg


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 第三篇-用Flutter手擼一個抖音國內版，看看有多炫
    前言 前一篇已經開發了大部分框架，包含視頻上下滑動播放，這次將上次未完成的數據顯示友好顯示，以及底部音樂走馬燈特效，另外優化了載入數據的bug，在dart語言里 & 會自動變成&amp; 也不知道這個bug啥時候修複哈. 本系列會持續更新，將各個模塊及功能持續完善. 修複Dart語言 URL顯示錯誤 ...
  • Java學習方法途徑，Java學習誤區及乾貨推薦
    編程學習本身就是一個枯燥的過程，面對一個新鮮的東西一定是一開始比較好奇，起初比較有興趣，但是越學越覺得枯燥。學習任何東西都是一樣的，但是一定要堅持下去(如果決定要做這一行)。 電腦語言的學習其實就是學習別人的思想，因為這些東西是別人發明出來的，這些東西不是憑空就來了，而是基於很多理論和為解決具體的 ...
  • 遇到網站的反爬蟲機制，那麼我們應該來如何應對呢？
    前言 本文的文字及圖片來源於網路,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理。 加企鵝群695185429即可免費獲取，資料全在群文件里。資料可以領取包括不限於Python實戰演練、PDF電子文檔、面試集錦、學習資料等 1、使用代理 適用情況：限制IP地 ...
  • 爬蟲滑塊計算圖片之間的距離更加精確
    1.思路 原先圖片匹配一般都是缺口匹配全圖 優化點: 1.缺口圖片匹配缺口所在圖片那一行圖片可以提高他識別率 2.移動後再進行2次匹配計算距離 2.代碼 def get_image_deviation(): ##讀取滑塊圖 block = cv.imread("img.png", -1) #完整圖片 ...
  • python一個列表根據某個元素前後分割
    from itertools import groupbyresult = [list(g) for k, g in groupby(data, lambda x:x=='') if not k]print(result) ...
  • laravel安裝jwt-auth及驗證（實例）
    laravel 安裝jwt-auth及驗證 1、使用composer安裝jwt，cmd到項目文件夾中； composer require tymon/jwt-auth 1.0.*（這裡版本號根據自己的需要寫） 安裝jwt ，參考官方文檔https://jwt-auth.readthedocs.io/ ...
  • java方法句柄-----1.方法句柄類型、調用
    方法句柄 方法句柄(method handle)是JSR 292中引入的一個重要概念，它是對Java中方法、構造方法和域的一個強類型的可執行的引用。這也是句柄這個詞的含義所在。通過方法句柄可以直接調用該句柄所引用的底層方法。從作用上來說，方法句柄的作用類似於2.2節中提到的反射API中的Method ...
  • Docker scratch 無法正常運行golang二進位程式的問題
    使用Docker構建容器能夠極大的降低運維成本，提高部署效率，同時非常方便對服務的平行擴展。然而在構建容器鏡像過程中的，存在著一個難以避免的問題，就是如果使用常見的發行版本作為程式運行的基礎環境，那麼即使一個服務本身的運行文件非常小，最終構建的鏡像也可能會有會在運行環境的鏡像的基礎上變得更大，動不動 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類