Class 類

用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

一個人（身高：一米八）要吃飯、喝水、睡覺；
一只老虎（體重：300斤）要奔跑、洗澡、捕獵。

一、名詞定義

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
• 方法： 類中定義的 函數(shù) 。
• 類變量： 類變量在整個實例化的對象中是公用的。
  • 一般位置 ：類變量定義在類中且在函數(shù)體之外。
  • 固有屬性由類變量表示。
  • 類變量通常不作為實例變量使用。
  • 對類變量的修改會影響到類的所有實例。
• 數(shù)據(jù)成員： 類變量或者實例變量用于處理類及其實例對象的相關的數(shù)據(jù)。
• 方法重寫： 如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
• 實例變量：
  • 一般位置 ：在類的 __init__ 聲明中。
  • 屬性 是用變量來表示的，這種變量就稱為實例變量，且一般是自定義屬性。
• 局部變量：
  • 一般位置 ：定義在方法中的變量。
  • 只作用于當前實例（對象）的類。
  • 一旦函數(shù)或方法執(zhí)行完畢，局部變量就會被銷毀。
  • 局部變量與類本身無關，無論是在類的內(nèi)部還是外部定義的方法中，都可以有局部變量。
• 繼承： 即一個派生類（derived class）繼承基類（base class）的屬性和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。
• 實例化： 創(chuàng)建一個類的實例，即創(chuàng)建一個類的具體對象。
  • 實例是可以更改、刪除原屬性的。
• 對象： 通過類定義的數(shù)據(jù)結(jié)構(gòu)實例，實例即對象。對象包括兩個數(shù)據(jù)成員（類變量和實例變量）和方法。

二、先睹為快

通俗舉例：

#通俗舉例：
定義一個人（男性）要吃飯、喝水、睡覺；
現(xiàn)在有個具體的人，他被賦予上述定義，所以他便是男人，會吃飯，會喝水，會睡覺。
#類名：一個人
#屬性：男性
#方法：吃飯、喝水、睡覺
#對象：這個具體的人（賦予這個人相同的屬性、方法的過程叫“實例化”）

• 無 __init__ 代碼舉例（有 __init__ 的后面會寫）：

  class Calculator:             # Calculator：類名
      name = 'Good calculator'  # name：類變量（固有屬性）
      price= 18                 # price：類變量（固有屬性）
      def add(self,x, y):       # add()：方法
          result=x+y            # result：局部變量
          print(result)
      def minus(self, x, y):    # minus()：方法
          result=x-y            # result：局部變量
          print(result)
      def times(self, x, y):    # times()：方法
          print(x*y)
      def divide(self, x, y):   # divide()：方法
          print(x/y)
  cal1 = Calculator()           # ☆實例化(cal1也有了相同的屬性和方法)
  ————————————————————————————————————————————————————————————————————————————————————————————
  >>> cal1.name                 ----->'Good calculator'
  >>> cal1.add(1,2)             ----->3
  >>> cal1.price                ----->18
  >>> cal1.price=25
  >>> cal1.price                ----->25 # 實例的屬性可以修改
  

三、詳細解釋

（1）self

• 在用 def 定義方法時，第一個參數(shù)一定得是 self 。

• self 代表的是類的實例（對象），本質(zhì)是代表當前對象的地址，不是類；而 self.class 則指向類。

  請看 VCR ：

  class Test:
      def prt(self):
          print(self)
          print(self.__class__)
   
  t = Test()
  t.prt()
  ————————————————————————————————————————————————————————————————————————————————————————————
  #輸出結(jié)果為（兩個 print 的結(jié)果）：
  <__main__.Test instance at 0x100771878>
  __main__.Test
  

• self 不是 python 關鍵字，可以把它換成別的單詞，但仍強烈建議使用 self。

（2）方法

• 在類的內(nèi)部，使用 def 關鍵字來定義一個方法。
• 與一般函數(shù)不同，類的方法在定義時必須包含參數(shù) self，且為第一個參數(shù)，self 代表的是類的實例。
• self 不是 python 的關鍵字，所以可以用別的單詞來代替 self 。
  但按照慣例，最好就用 self 。

def add(self,x,y) # add即為方法名，x和y為調(diào)用該函數(shù)需要輸入的參數(shù)
    result=x+y

__init__

一種內(nèi)置的方法，可稱之為“構(gòu)造方法”，初始化（Initialize的縮寫）

前后各兩個下劃線

在實例化時，會自動調(diào)用，用來初始化自定義屬性

• 有 __init__ 代碼舉例（沒給出默認自定義屬性，實例化時需要手動給出）：

  下方代碼要注意一點，自定義屬性是 hight 這些，不是 hig 這些，hig 只是輸入?yún)?shù)。

  class Calculator:             # Calculator：類名
      class_variable = "I am a class variable" # 這是一個類變量（固有屬性）  
      name = 'Good calculator'  # name：類變量（固有屬性）
      price= 18                 # price：類變量（固有屬性）
                                                  #*****************************
      def __init__ (self, hig, wid, wei):         #              *
          self.hight = hig      # hight：實例變量（自定義屬性）      *
          self.width = wid      # width：實例變量（自定義屬性）      *
          self.weight = wei     # weight：實例變量（自定義屬性）     *
                                                  #*****************************
      def add(self,x, y):       # add()：方法
          result=x+y            # result：局部變量
          print(result)
      def minus(self, x, y):    # minus()：方法
          result=x-y            # result：局部變量
          print(result)
      def times(self, x, y):    # times()：方法
          print(x*y)
      def divide(self, x, y):   # divide()：方法
          print(x/y)
  ————————————————————————————————————————————————————————————————————————————————————————————
  #先運行程序
  >>> cal2 = Calculator(1,5,12) #實例化時，一定要給出自定義屬性的內(nèi)容
  >>> cal2.name                 ----->'Good calculator'
  >>> cal2.hight                ----->1
  >>> cal2.add(1,2)             ----->3
  >>> cal2.price                ----->18
  >>> cal2.price=25
  >>> cal2.price                ----->25 # 實例的固有、自定義屬性都可修改
  

• 有 __init__ 代碼舉例（給出默認自定義屬性）：

  ...#同上
                                                  #*******************
      def __init__ (self, hight=1, width=5, weight=12):      *
          self.hight = hight    # hight：自定義屬性            *
          self.width = width    # width：自定義屬性            *
          self.weight = weight  # weight：自定義屬性           *
                                                  #*******************
      ...#同上
  ————————————————————————————————————————————————————————————————————————————————————————————
  #先運行程序
  >>> cal2 = Calculator() #實例化時，不用再給出自定義屬性，除非要修改
  

• super().__init__() 的功能與用法

  在Python中，super() 函數(shù)是用于調(diào)用父類（超類）的一個方法。在類的構(gòu)造函數(shù)（__init__）中使用super().__init__()是一種常見的做法（特別是在多重繼承的情況下，它確保了父類被正確地初始化，但是這里不過多介紹多重繼承）。
  ————
  python3 的 super() 函數(shù)就是此格式，比 python2 的 super() 函數(shù)要精簡。

  • 用法：

    假設我們有一個基類（父類）和一個派生類（子類），子類在初始化時，可能需要父類的一些已經(jīng)設置好的屬性或方法，我們希望在子類初始化時也初始化基類。這時就可以使用super().__init__()。

  • 示例：

    class Parent:  
        def __init__(self, name):  
            self.name = name  
            print(f"Parent with name: {self.name}")  
      
    class Child(Parent):  
        def __init__(self, name, age):  
            super().__init__(name)  # 調(diào)用父類的__init__方法  
            self.age = age  
            print(f"Child with name: {self.name} and age: {self.age}")  
      
    # 使用子類  
    child_instance = Child("Alice", 10)
    ---------------------------------------------------------------------------------------------------------------
    # 運行結(jié)果
    Parent with name: Alice  
    Child with name: Alice and age: 10
    

    這里用到了 f-string 字符，感興趣的可以上網(wǎng)搜搜，或者直接問 GPT 。

__call__

一種內(nèi)置的方法，前后各兩個下劃線。
這個內(nèi)置方法，有點多此一舉的感覺，不過有些妙用，需要慢慢體會…

該內(nèi)置函數(shù)的作用是：
“實例可以直接當函數(shù)用，且其效果就是 __call__ 函數(shù)的效果”，此時， __call__ 函數(shù)的輸入?yún)?shù)，就是實例的輸入?yún)?shù)。
具體使用代碼見下方運行程序結(jié)果：

class Calculator:             # Calculator：類名
    class_variable = "I am a class variable" # 這是一個類變量（固有屬性）  
    name = 'Good calculator'  # name：類變量（固有屬性）
    price= 18                 # price：類變量（固有屬性）
                                                #*****************************
    def __init__ (self, hig, wid, wei):         #              *
        self.hight = hig      # hight：實例變量（自定義屬性）      *
        self.width = wid      # width：實例變量（自定義屬性）      *
        self.weight = wei     # weight：實例變量（自定義屬性）     *
                                                #*****************************
    def __call__ (self, test_value):
    	print("Output is:" + str(test_value))

    def add(self,x, y):       # add()：方法
        result=x+y            # result：局部變量
        print(result)
————————————————————————————————————————————————————————————————————————————————————————————
#先運行程序
>>> cal2 = Calculator(1,5,12) #實例化時，一定要給出自定義屬性的內(nèi)容
>>> cal2.name                 ----->'Good calculator'
>>> cal2(111)                 -----> Output is:111

多加一嘴：其余自命名方法（函數(shù)）的調(diào)用方式為 實例名.方法名() 。

（3）繼承

就是先定義了一個 基準類，后面想再定義一個 派生類，該派生類想沿用基準類的屬性和方法，這種沿用過程就叫“繼承”。

子類（派生類 DerivedClassName）會繼承父類（基類 BaseClassName）的屬性和方法。

• 單繼承：

  • 當基類和派生類 處于同一個模塊中 時：

    class 派生類名(基類名):
        ...
        代碼塊
        ...
    

  • 當基類和派生類不在同一個模塊中時，需要從基類所在模塊導入基類：

    • 寫法一（僅導入基類）：

      #假設基類 BaseClassName 在模塊 modname 中
      from modname import BaseClassName  
        
      class DerivedClassName(BaseClassName):  
          ...
          代碼塊
          ...
      

    • 寫法二（直接導入基類所在模塊）：

      #假設基類 BaseClassName 在模塊 modname 中
      import modname  
        
      class DerivedClassName(modname.BaseClassName):  
          ...
          代碼塊
          ...
      

  示例：

  #類定義
  class people:
      #定義基本屬性
      name = ''
      age = 0
      #定義私有屬性,私有屬性在類外部無法直接進行訪問
      __weight = 0
      #定義構(gòu)造方法
      def __init__(self,n,a,w):
          self.name = n
          self.age = a
          self.__weight = w
      def speak(self):
          print("%s 說: 我 %d 歲。" %(self.name,self.age))
   
  #單繼承示例
  class student(people):
      grade = ''
      def __init__(self,n,a,w,g):
          #調(diào)用父類的構(gòu)函
          people.__init__(self,n,a,w)
          self.grade = g
      #覆寫父類的方法
      def speak(self):
          print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
   
  s = student('ken',10,60,3)
  s.speak()
  ————————————————————————————————————————————————————————————————————————————————————————————
  #輸出結(jié)果為：
  ken 說: 我 10 歲了，我在讀 3 年級
  

• 多繼承：

  #參考菜鳥教程，基本不用：
  https://www.runoob.com/python3/python3-class.html
  

（4）方法重寫

如果父類定義的方法的功能不能滿足需求，則可以在子類重寫父類的方法。

示例：

class Parent:        # 定義父類
   def myMethod(self):
      print ('調(diào)用父類方法')
 
class Child(Parent): # 定義子類
   def myMethod(self):
      print ('調(diào)用子類方法')
 
c = Child()          # 子類實例
c.myMethod()         # 子類調(diào)用重寫方法
super(Child,c).myMethod() #用子類對象調(diào)用父類已被覆蓋的方法
————————————————————————————————————————————————————————————————————————————————————————————
#輸出結(jié)果為：
調(diào)用子類方法
調(diào)用父類方法

四、實例變量、局部變量、類變量的 GPT 解釋

在Python的繼承機制中，理解實例變量、局部變量、和類變量是非常重要的。這些變量在類及其對象中的作用域和生命周期各不相同。下面是對這些變量的詳細解釋：

• 實例變量（Instance Variables）

  實例變量也稱為對象變量，它們是在類的實例（即對象）中定義的變量。每個實例都有自己獨立的實例變量副本，即使兩個實例屬于同一個類，它們的實例變量值也可以是不同的。實例變量通常通過類的構(gòu)造方法（__init__）來初始化。

  class MyClass:  
      def __init__(self, value):  
          self.instance_variable = value  # 這是一個實例變量  
    
  obj1 = MyClass(10)  
  obj2 = MyClass(20)  
    
  print(obj1.instance_variable)  # 輸出: 10  
  print(obj2.instance_variable)  # 輸出: 20
  

• 局部變量（Local Variables）

  局部變量是在函數(shù)或方法內(nèi)部定義的變量。它們的作用域僅限于定義它們的函數(shù)或方法。一旦函數(shù)或方法執(zhí)行完畢，局部變量就會被銷毀。局部變量與類本身無關，無論是在類的內(nèi)部還是外部定義的方法中，都可以有局部變量。

  class MyClass:  
      def my_method(self):  
          local_variable = "I am a local variable"  # 這是一個局部變量  
          print(local_variable)  
    
  obj = MyClass()  
  obj.my_method()  # 輸出: I am a local variable  
  # 在這里，local_variable 已經(jīng)不存在了
  

• 類變量（Class Variables）

  類變量是在類級別定義的變量，它們不屬于類的任何特定實例。相反，它們被類的所有實例共享。類變量可以通過類本身來訪問，也可以通過類的任何實例來訪問。當通過實例修改類變量時，這個改變會影響到所有實例，因為所有的實例共享同一個類變量。

  class MyClass:  
      class_variable = "I am a class variable"  # 這是一個類變量  
    
      def __init__(self, value):  
          self.instance_variable = value  
    
      def print_variables(self):  
          print(self.class_variable)  # 通過實例訪問類變量  
          print(MyClass.class_variable)  # 直接通過類名訪問類變量  
    
  # 修改類變量  
  MyClass.class_variable = "I have been modified"  
    
  obj1 = MyClass(10)  
  obj2 = MyClass(20)  
    
  obj1.print_variables()  # 輸出: I have been modified 和 I have been modified  
  obj2.print_variables()  # 輸出同上，因為類變量被所有實例共享
  

  注意：盡管可以通過實例訪問類變量，但最好通過類名來訪問和修改類變量，以避免潛在的混淆。特別是在通過實例修改類變量時，要清楚這樣做會影響所有實例共享的類變量值。

總結(jié) 

到此這篇關于python中Class(類)的文章就介紹到這了,更多相關python Class類說明內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論