python中的class(類)

 

編碼註釋:
在源文件的第一行或第二行寫入以下內容：
  # -*- coding:gbk -*-
  # 設置源文件編碼格式爲:gbk
或
  # -*- coding:utf-8 -*-
  # 設置源文件編碼格式爲:UTF-8

 

面向對象編程:
  什麼是對象:
     一切皆對象(實例)

類型   對象(實例)
車   --> 車牌號(京P88888) 實例
畫   --> 蒙娜麗莎(實例), ....

面向對象是指用類來描述一個對象(實例)，用類來創建實例與實例的關聯關係
對象 : object
實例 : instance

類 : class

做用：
  用來描述對象
  用來建立對象

類的建立語法:
  class 類名(繼承列表):
     "類文檔字符串"
     實例方法(類內的函數methed)定義
     類變量定義
     類方法(@classmethod)定義
     靜態方法(@staticmethod)定義

最簡單類的定義的示例：
  # 定義一個類
  class Dog:
      pass
  # 建立一個Dog實例
  dog1 = Dog()
  dog2 = Dog()
  # 同list
  L = list()  # L是list類的一個對象(實例)
  L2 = list()
  L3 = list(range(10))

類的建立語法說明：
  類名必須是標識符
  類名實質上是變量，它綁定一個類
  類的定義的先後要加兩個空行以告訴解釋執行器，類的定義已經開始和結束

實例建立表達式:
  類名([建立傳參列表])
做用：
  建立一個類的實例對象並返回此實例的引用關係

實例說明：
  實例有本身的做用域和名字空間,能夠爲該實例添加變量(實例變量/屬性)
  實例能夠調用類中的方法
  實例能夠訪問類中的類變量

實例變量:
  在python程序中，每一個實例能夠有本身的變量，每一個實例變量有本身獨立的做用域

實例變量的調用語法:
  實例.變量名

實例變量的賦值規則:
  首次爲實例變量賦值則建立此實例變量
  再次爲實例變量賦值則改變變量的綁定關係

示例見:

 1 # dog.py
 2 
 3 
 4 class Dog:
 5     """這是一個小狗的類
 6 
 7     此類用來建立小狗的實例
 8     """
 9     pass
10 
11 
12 dog1 = Dog()
13 dog1.kinds = "京巴"  # 爲實例添加 kinds 屬性
14 dog1.color = "白色"
15 
16 dog2 = Dog()
17 dog2.kinds = "藏獒"
18 dog2.color = "棕色"
19 
20 print("dog1的屬性:", dog1.kinds, dog1.color)
21 print("dog2的屬性:", dog2.kinds, dog2.color)

 

實例方法:
語法:
  class 類名(繼承列表):
      def 實例方法名(self, 參數1, 參數2, ...):
          "實例方法的文檔字符串"
          語句塊

實例方法說明：
　　實例方法的實質就是函數，是定義在類內的函數
  實例方法屬於類的屬性
  實例方法的第一個參數表明調用這個方法的實例，通常命名爲: "self"
  實例方法若是沒有return 語句則返回None

調用語法:
  實例.實例方法名(調用參數)
  或
  類名.實例方法名(實例，　調用參數)

示例見:

  

# instance_method.py
class Dog:
    def say(self):
        """這是小狗的溝通方法"""
        print("旺!")
        print("self.kinds=", self.kinds)


dog1 = Dog()

dog1.kinds = "京巴"
# 調用方法1
dog1.say()

dog2 = Dog()
# 下一行出錯，由於 第8行 self綁定的
# 對象沒有kinds實例變量
dog2.say()

 

  和
  

# instance_method.py
class Dog:
    def say(self):
        """這是小狗的溝通方法"""
        print("旺!")

    def eat(self, that):
        "爲狗進食，同時在狗的food屬性裏記住吃的是什麼"
        print("小狗正在吃", that, "旺!...")
        self.food = that

    def food_info(self):
        "顯示狗的進食信息"
        print("小狗剛吃過的是:", self.food)

dog1 = Dog()
# 調用方法1
dog1.say()
# 調用方法2
Dog.say(dog1)


dog2 = Dog()

dog1.eat("骨頭")
dog2.eat("窩頭")

# print("小狗1吃的是", dog1.food)
# print("小狗2吃的是", dog2.food)

dog1.food_info()
r = dog1.food_info()
print(r)

class MyList:
    def append(obj):
        # 把obj放在某個容器的尾部
        return None

 

 

構造方法(也叫初始化方法)
做用：
  建立對象，初始化實例變量

構造方法的語法格式:
  class 類名(繼承列表):
      def __init__(self [, 參數列表]):
          語句塊
  [] 表明可省略
說明：
  1. 構造 方法名必須是: __init__ 不可改變
  2. 在一個類內只能有一個__init__構造方法起做用
  3. 構造方法會在實例生成時自動調用,且將實例自身經過第一個參數self傳入__init__方法
  4. 構造方法內若是須要return語句返回，則只能返回None

 1 class Car:
 2     def __init__(self, c, b, m):
 3         "這是構造方法"
 4         print("__init__被調用!")
 5         self.color, self.brand, self.model = c, b, m
 6 
 7     def run(self, speed):
 8         print(self.color, "的", self.brand,
 9               self.model, "正在以", speed,
10               "千米/小時的速度駛")
11 
12     def change_color(self, c):
13         "此方法用來改變顏色"
14         self.color = c  # 換色
15 
16 
17 a4 = Car("紅色", "奧迪", "A4")
18 
19 a4.run(199)
20 a4.change_color("黑色")  # 推薦
21 # a4.color = "銀色"  # 不推薦
22 a4.run(233)
23 
24 ts = Car("藍色", "Tesla", "S")
25 ts.run(300)

 

 

析構方法：
語法格式 ：
  class 類名(繼承列表):
      def __del__(self):
          語句塊
說明：
  析構方法在對象被銷燬時被自動調用
注：
  python語言建議不要在對象銷燬時作任何事情，由於銷燬的時間難以肯定

預置實例屬性:
  __dict__屬性:
    一般每一個對象(實例)都有一個__dict__屬性
    __dict__屬性綁定一個存儲此實例自身變量的字典

例：
  class Dog:
       pass
  dog1 = Dog()
  print(dog1.__dict__)

__doc__屬性:
  記錄文件字符串, 用於help幫助
  此文件字符串與類的文檔字符串相同

__class__屬性
  用於綁定建立此實例的類對象(類實例)

做用：
  能夠藉助此屬性來建立同類對象
  能夠藉助此屬性來訪問類對象(類實例)
示例：
  class Dog:
     pass
  dog1 = Dog()
  dog2 = dog1.__class__()  # 建立dog2

類變量
  1. 是指在類class 內定義的變量,此變量屬於類，不屬於此類的實例
  2. 類變量能夠經過該類直接訪問
  3. 類變量能夠經過類的實例直接訪問
  4. 類變量能夠經過此類的對象的__class__屬性間接訪問

語法:
  class 類名(繼承列表):
      變量名 = 表達式
      ....

示例：
  class Human:  # 人類
      home = "地球"  # 類變量

  print(Human.home)  #  home 屬於  Human類變量

 

類的 __slots__ 列表屬性
做用：
  限定一個類建立的實例只能有固定的實例屬性
  不容許對象添加列表之外的實例屬性(變量)
  防止用戶因錯寫屬性的名稱而發生程序錯誤!

說明：
   __slots__屬性是一個列表，列表的值是字符串
   含有__slots__ 屬性的類所建立的實例對象沒有
     __dict__屬性,即此實例不用字典來存儲屬性

示例：
  class Student:
     # __slots__ = ["name", "age", "score"]
     def __init__(self, n, a, s):
         self.name = n
         self.age = a
         self.score = s
         self.scros = s  # 錯，由於scros不在列表裏

  s1 = Student("李四", 21, 100)
  s1.name = "張三"
  s1.abcd = 10000  # 出錯

對象的屬性管理函數
  1. getattr(obj, name[, default])  從一個對象獲得對象的屬性; getattr(x, 'y') 等同於x.y,當屬性不存在時，若是給出default參數，則返回default,若是沒有給出default則生一個AttributeError錯誤
  2. hasattr(obj, name) 用給定的name返回對象obj是否有此屬性，此種作法能夠避免在getattr(obj, name)時引起錯誤
  3. setattr(obj, name, value) 給對象obj的名爲name的屬性設置相應的值value; set(x, 'y', v)  等同於 x.y = v
  4. delattr(obj, name) 刪除 對象的obj中的name屬性, delattr(x, 'y') 等同於 del x.y

用於類的函數:
  isinstance(obj, 類或元組) 返回這個對象obj是不是某個(或某些)類的對象，若是是則返回True, 不然返回False
  type(obj)  返回對象的類型

類方法 @classmethod
    類方法是隻能訪問類變量的方法
    類方法須要使用@classmethod裝飾器定義
    類方法的第一個參數是類實例, 約定寫爲 cls
說明：
  類實例的對象實例均可以調用類方法
  類方法不能訪問實例變量

示例:
  class Human:
      home = "地球"

      @classmethod
      def set_home(cls, h):
          cls.home = h
          print("歡迎來到", cls.home)

靜態方法 @staticmethod
  靜態方法是普通的函數
  靜態方法定義在類的內部，只能憑藉該類的實例訪問
  靜態方法須要使用@staticmethod裝飾器定義
  靜態方法與普通函數定義相同，不須要傳入self和cls參數

說明：
  類實例和對象實例均可以調用靜態方法
  靜態方法不能訪問類變量和實例變量

示例:
  

# 靜態方法示例
class A:
    @staticmethod
    def myadd(a, b):
        return a + b

print(A.myadd(100, 200))
a = A()
print(a.myadd(3, 4))

 

實例方法、類方法、靜態方法、函數 總結  不想訪問類變量和實例變量，能夠用靜態方法  只想訪問類內變量，不想訪問實例變量用類方法  即想訪問類變量，也想訪問實例變量用實例方法  函數與靜態方法相同，只是靜態方法的做用域定義在類內