Python面向對象——類屬性、類方法、靜態方法

Python面向對象——類屬性、類方法、靜態方法

01 類的結構

（1）術語——實例

1.使用面向對象開發，第1步 是設計 類
2.使用 類名() 創建對象，創建對象 的動作有兩步：
　　在內存中爲對象 分配空間
　　調用初始化方法__init__爲 對象初始化
3.對象創建後，內存 中就有了一個對象的 實實在在 的存在——實例

因此，通常也會把：
1.創建出來的 對象 叫做 類 的 實例
2.創建對象的 動作 叫做 實例化
3.對象的屬性 叫做 實例屬性
4.對象調用的方法 叫做 實例方法

在程序執行時：
1.對象各自擁有自己的 實例屬性
2.調用對象方法，可以通過 self.
　　訪問自己的屬性
　　調用自己的方法

結論
每一個對象 都有自己 獨立的內存空間，保存各自不同的屬性
多個對象的方法，在內存中只有一份，在調用此方法時，需要把對象的引用 傳遞到方法內部

（2）類是一個特殊的對象

Python 中 一切皆對象：
　　class AAA：定義的類屬於 類對象
　　obj1 = AAA() 屬於 實例對象

在程序運行時，類 同樣 會被加載到內存
在 Python 中，類 是一個特殊的對象——類對象
在程序運行時，類對象在內存中 只有一份，使用 一個類 可以創建出 很多個對象實例
除了封裝 實例 的 屬性 和 方法外，類對象 還可以擁有自己的 屬性 和 方法
　　1.類屬性
　　2.類方法
通過 類名. 的方式可以 訪問類的屬性 或者 調用類的方法

02 類屬性和實例屬性

（1）概念和使用

類屬性 就是給 類對象 中定義的 屬性
通常用來記錄 與這個類相關 的特性
類屬性 不會用於記錄 具體對象的特徵

示例需求
定義一個 工具類
每件工具都有自己的 name
需求——知道使用這個類，創建了多少個工具對象？

（2）屬性的獲取機制（科普）

在 Python 中 屬性的獲取 存在一個 向上查找機制

因此，要訪問類屬性有兩種方式：
1.類名.類屬性
2.對象.類屬性（不推薦）
注意
如果使用 對象.類屬性 = 值 賦值語句，只會 給對象添加一個屬性，而不會影響到 類屬性的值

03 類方法和靜態方法

（1）類方法

類屬性 就是針對 類對象 定義的屬性
　　使用 賦值語句 在 class 關鍵字下方可以定義 類屬性
　　類屬性 用於記錄 與這個類相關 的特徵
類方法 就是針對 類對象 定義的方法
　　在 類方法 內部可以直接訪問 類屬性 或者調用其他的 類方法

語法如下

類方法需要用 修飾器@classmethod 來標識，告訴解釋器這是一個類方法
類方法的 第一個參數 應該是 cls
　　由 哪一個類 調用的方法，方法內的 cls 就是 哪一個類的引用
　　這個參數和 實例方法 的第一個參數是 self 類似
　　提示 使用其他名稱也可以，不過習慣使用 cls
通過 類名. 調用 類方法，調用方法時，不需要傳遞 cls 參數
在方法內部
　　可以通過 cls. 訪問類的屬性
　　也可以通過cls. 調用其他的類方法

示例需求
定義一個 工具類
每件工具都有自己的 name
需求 —— 在 類 封裝一個 show_tool_count 的類方法，輸出使用當前這個類，創建的對象個數

在類方法內部，可以直接使用 cls 訪問 類屬性 或者 調用類方法

class Tool(object):

    # 使用賦值語句定義類屬性，記錄所有工具對象的數量
    count = 0

    @classmethod
    def show_tool_count(cls):
        print("工具對象的數量 %d" % cls.count)

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

        # 讓類屬性的值+1
        Tool.count+=1

# 創建工具對象
tool1 = Tool("斧頭")
tool2 = Tool("榔頭")

# 調用類方法
Tool.show_tool_count()

（2）靜態方法

在開發時，如果需要在 類 中封裝一個方法，這個方法：
　　既 不需要 訪問 實例屬性 或者調用 實例方法
　　也 不需要 訪問 類屬性 或者調用 類方法

這個時候，可以把這個方法封裝成一個 靜態方法

語法如下

靜態方法 需要用 修飾器@staticmethod 來標識，告訴解釋器這是一個靜態方法
通過 類名. 調用 靜態方法

class Dog(object):

    @staticmethod
    def run():

        # 不訪問實例屬性/類屬性
        print("小狗要跑...")

# 通過 類名. 調用靜態方法 - 不需要創建對象
Dog.run()

（3）方法綜合案例

需求
1.設計一個 Game 類
2.屬性：
　　定義一個 類屬性 top_score 記錄遊戲的 歷史最高分
　　定義一個 實例屬性 player_name 記錄 當前遊戲的玩家姓名
3.方法：
　　靜態方法 show_help 顯示遊戲幫助信息
　　類方法 show_top_score 顯示歷史最高分
　　實例方法 start_game 開始當前玩家的遊戲
4.主程序步驟
　　1）查看幫助信息
　　2）查看歷史最高分
　　3）創建遊戲對象，開始遊戲

class Game(object):

    #歷史最高分
    top_score = 0

    def __init__(self,player_name):
        self.player_name = player_name

    @staticmethod
    def show_help():
        print("幫助信息")

    @classmethod
    def show_top_score(cls):
        print("歷史記錄 %d" %(cls.top_score))

    def start_game(self):
        print("%s 開始遊戲啦..." % self.player_name)

# 1.查看遊戲的幫助信息
Game.show_help()

# 2.查看歷史最高分
Game.show_top_score()

# 2.創建遊戲對象
game = Game("小明")
game.start_game()

案例小結
1.實例方法 —— 方法內部需要訪問 實例屬性
　　實例方法 內部可以使用 類名. 訪問類屬性

2.類方法 —— 方法內部 只 需要訪問 類屬性

3.靜態方法 —— 方法內部，不需要訪問 實例屬性 和 類屬性

提問
如果方法內部 即需要訪問 實例屬性，又需要訪問 類屬性，應該定義成什麼方法
答案
應該定義 實例方法
因爲，類只有一個，在實例方法 內部可以使用 類名. 訪問類屬性