Class 類

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

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

一、名詞定義

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

二、先睹為快

通俗舉例：

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

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

  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()           # ☆實(shí)例化(cal1也有了相同的屬性和方法)
  ————————————————————————————————————————————————————————————————————————————————————————————
  >>> cal1.name                 ----->'Good calculator'
  >>> cal1.add(1,2)             ----->3
  >>> cal1.price                ----->18
  >>> cal1.price=25
  >>> cal1.price                ----->25 # 實(shí)例的屬性可以修改
  

三、詳細(xì)解釋

（1）self

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

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

  請(qǐng)看 VCR ：

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

• self 不是 python 關(guān)鍵字，可以把它換成別的單詞，但仍強(qiáng)烈建議使用 self。

（2）方法

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

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

__init__

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

前后各兩個(gè)下劃線

在實(shí)例化時(shí)，會(huì)自動(dòng)調(diào)用，用來初始化自定義屬性

• 有 __init__ 代碼舉例（沒給出默認(rèn)自定義屬性，實(shí)例化時(shí)需要手動(dòng)給出）：

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

  class Calculator:             # Calculator：類名
      class_variable = "I am a class variable" # 這是一個(gè)類變量（固有屬性）  
      name = 'Good calculator'  # name：類變量（固有屬性）
      price= 18                 # price：類變量（固有屬性）
                                                  #*****************************
      def __init__ (self, hig, wid, wei):         #              *
          self.hight = hig      # hight：實(shí)例變量（自定義屬性）      *
          self.width = wid      # width：實(shí)例變量（自定義屬性）      *
          self.weight = wei     # weight：實(shí)例變量（自定義屬性）     *
                                                  #*****************************
      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)
  ————————————————————————————————————————————————————————————————————————————————————————————
  #先運(yùn)行程序
  >>> cal2 = Calculator(1,5,12) #實(shí)例化時(shí)，一定要給出自定義屬性的內(nèi)容
  >>> cal2.name                 ----->'Good calculator'
  >>> cal2.hight                ----->1
  >>> cal2.add(1,2)             ----->3
  >>> cal2.price                ----->18
  >>> cal2.price=25
  >>> cal2.price                ----->25 # 實(shí)例的固有、自定義屬性都可修改
  

• 有 __init__ 代碼舉例（給出默認(rèn)自定義屬性）：

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

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

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

  • 用法：

    假設(shè)我們有一個(gè)基類（父類）和一個(gè)派生類（子類），子類在初始化時(shí)，可能需要父類的一些已經(jīng)設(shè)置好的屬性或方法，我們希望在子類初始化時(shí)也初始化基類。這時(shí)就可以使用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)
    ---------------------------------------------------------------------------------------------------------------
    # 運(yùn)行結(jié)果
    Parent with name: Alice  
    Child with name: Alice and age: 10
    

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

__call__

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

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

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

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

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

（3）繼承

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

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

• 單繼承：

  • 當(dāng)基類和派生類 處于同一個(gè)模塊中 時(shí)：

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

  • 當(dāng)基類和派生類不在同一個(gè)模塊中時(shí)，需要從基類所在模塊導(dǎo)入基類：

    • 寫法一（僅導(dǎo)入基類）：

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

    • 寫法二（直接導(dǎo)入基類所在模塊）：

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

  示例：

  #類定義
  class people:
      #定義基本屬性
      name = ''
      age = 0
      #定義私有屬性,私有屬性在類外部無法直接進(jìn)行訪問
      __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 年級(jí)"%(self.name,self.age,self.grade))
   
  s = student('ken',10,60,3)
  s.speak()
  ————————————————————————————————————————————————————————————————————————————————————————————
  #輸出結(jié)果為：
  ken 說: 我 10 歲了，我在讀 3 年級(jí)
  

• 多繼承：

  #參考菜鳥教程，基本不用：
  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()          # 子類實(shí)例
c.myMethod()         # 子類調(diào)用重寫方法
super(Child,c).myMethod() #用子類對(duì)象調(diào)用父類已被覆蓋的方法
————————————————————————————————————————————————————————————————————————————————————————————
#輸出結(jié)果為：
調(diào)用子類方法
調(diào)用父類方法

四、實(shí)例變量、局部變量、類變量的 GPT 解釋

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

• 實(shí)例變量（Instance Variables）

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

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

• 局部變量（Local Variables）

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

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

• 類變量（Class Variables）

  類變量是在類級(jí)別定義的變量，它們不屬于類的任何特定實(shí)例。相反，它們被類的所有實(shí)例共享。類變量可以通過類本身來訪問，也可以通過類的任何實(shí)例來訪問。當(dāng)通過實(shí)例修改類變量時(shí)，這個(gè)改變會(huì)影響到所有實(shí)例，因?yàn)樗械膶?shí)例共享同一個(gè)類變量。

  class MyClass:  
      class_variable = "I am a class variable"  # 這是一個(gè)類變量  
    
      def __init__(self, value):  
          self.instance_variable = value  
    
      def print_variables(self):  
          print(self.class_variable)  # 通過實(shí)例訪問類變量  
          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()  # 輸出同上，因?yàn)轭愖兞勘凰袑?shí)例共享
  

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

總結(jié) 

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

最新評(píng)論