python學習面向對象

面向對象(OOP)基本概念

面向對象編程 —— Object Oriented Programming 簡寫 OOP

 

類和對象

 

01. 類和對象的概念

類 和 對象 是 面向對象編程的 兩個 核心概念

1.1 類

• 類 是對一羣具有 相同 特徵 或者 行爲 的事物的一個統稱，是抽象的，不能直接使用

  • 特徵 被稱爲 屬性

  • 行爲 被稱爲 方法

• 類 就相當於製造飛機時的圖紙，是一個 模板，是 負責創建對象的

 

1.2 對象

• 對象 是 由類創建出來的一個具體存在，可以直接使用

• 由 哪一個類 創建出來的 對象，就擁有在 哪一個類 中定義的：

  • 屬性

  • 方法

• 對象 就相當於用 圖紙 製造 的飛機

在程序開發中，應該 先有類，再有對象

 

02. 類和對象的關係

• 類是模板，對象 是根據 類 這個模板創建出來的，應該 先有類，再有對象

• 類 只有一個，而 對象 可以有很多個

  • 不同的對象 之間 屬性 可能會各不相同

• 類 中定義了什麼 屬性和方法，對象 中就有什麼屬性和方法，不可能多，也不可能少

03. 類的設計

在使用面相對象開發前，應該首先分析需求，確定一下，程序中需要包含哪些類！

 

在程序開發中，要設計一個類，通常需要滿足一下三個要素：

1. 類名 這類事物的名字，滿足大駝峯命名法

2. 屬性 這類事物具有什麼樣的特徵

3. 方法 這類事物具有什麼樣的行爲

大駝峯命名法

CapWords

1. 每一個單詞的首字母大寫

2. 單詞與單詞之間沒有下劃線

3.1 類名的確定

名詞提煉法 分析 整個業務流程，出現的 名詞，通常就是找到的類

3.2 屬性和方法的確定

• 對 對象的特徵描述，通常可以定義成 屬性

• 對象具有的行爲（動詞），通常可以定義成 方法

面相對象基礎語法

 

01. dir 內置函數

• 在 Python 中 對象幾乎是無所不在的，我們之前學習的 變量、數據、函數 都是對象

在 Python 中可以使用以下兩個方法驗證：

1. 在 標識符 / 數據 後輸入一個 .，然後按下 TAB 鍵，iPython 會提示該對象能夠調用的 方法列表

2. 使用內置函數 dir 傳入 標識符 / 數據，可以查看對象內的 所有屬性及方法

提示 __方法名__ 格式的方法是 Python 提供的 內置方法 / 屬性，稍後會給大家介紹一些常用的 內置方法 / 屬性

序號	方法名	類型	作用
01	__new__	方法	創建對象時，會被 自動 調用
02	__init__	方法	對象被初始化時，會被 自動 調用
03	__del__	方法	對象被從內存中銷燬前，會被 自動 調用
04	__str__	方法	返回對象的描述信息，print 函數輸出使用

02. 定義簡單的類

面向對象 是 更大 的 封裝，在 一個類中 封裝 多個方法，這樣 通過這個類創建出來的對象，就可以直接調用這些方法了！

2.1 定義只包含方法的類

• 在 Python 中要定義一個只包含方法的類，語法格式如下：

class 類名:
​
    def 方法1(self, 參數列表):
        pass
    
    def 方法2(self, 參數列表):
        pass

• 方法 的定義格式和之前學習過的函數 幾乎一樣

• 區別在於第一個參數必須是 self，大家暫時先記住，稍後介紹 self

2.2 創建對象

• 當一個類定義完成之後，要使用這個類來創建對象，語法格式如下：

對象變量 = 類名()

2.3 第一個面向對象程序

1. 定義一個貓類 Cat

2. 定義兩個方法 eat 和 drink

3. 按照需求 —— 不需要定義屬性

 

class Cat:
    """這是一個貓類"""
​
    def eat(self):
        print("小貓愛吃魚")
​
    def drink(self):
        print("小貓在喝水")
​
tom = Cat()
tom.drink()
tom.eat()

• 在 Python 中使用類 創建對象之後，tom 變量中 仍然記錄的是 對象在內存中的地址

• 也就是 tom 變量 引用 了 新建的貓對象

• 使用 print 輸出 對象變量，默認情況下，是能夠輸出這個變量 引用的對象 是 由哪一個類創建的對象，以及 在內存中的地址（十六進制表示）

案例進階 —— 使用 Cat 類再創建一個對象

lazy_cat = Cat()
lazy_cat.eat()
lazy_cat.drink()

 

03. 方法中的 self 參數

3.1 案例改造 —— 給對象增加屬性

• 在 Python 中，要 給對象設置屬性，非常的容易，但是不推薦使用

  • 因爲：對象屬性的封裝應該封裝在類的內部

• 只需要在 類的外部的代碼 中直接通過 . 設置一個屬性即可

tom.name = "Tom"
...
​
lazy_cat.name = "大懶貓"

3.2 使用 self 在方法內部輸出每一隻貓的名字

 

• 在類封裝的方法內部，self 就表示 當前調用方法的對象自己

• 調用方法時，程序員不需要傳遞 self 參數

• 在方法內部

  • 可以通過 self. 訪問對象的屬性

  • 也可以通過 self. 調用其他的對象方法

• 改造代碼如下：

class Cat:
​
    def eat(self):
        print("%s 愛吃魚" % self.name)
​
tom = Cat()
tom.name = "Tom"
tom.eat()
​
lazy_cat = Cat()
lazy_cat.name = "大懶貓"
lazy_cat.eat()

 

• 在 類的外部，通過 變量名. 訪問對象的 屬性和方法

• 在 類封裝的方法中，通過 self. 訪問對象的 屬性和方法

04. 初始化方法

4.1 之前代碼存在的問題 —— 在類的外部給對象增加屬性

• 將案例代碼進行調整，先調用方法 再設置屬性，觀察一下執行效果

tom = Cat()
tom.drink()
tom.eat()
tom.name = "Tom"
print(tom)

• 程序執行報錯如下：

AttributeError: 'Cat' object has no attribute 'name'
屬性錯誤：'Cat' 對象沒有 'name' 屬性

提示

• 在日常開發中，不推薦在 類的外部 給對象增加屬性

  • 如果在運行時，沒有找到屬性，程序會報錯

• 對象應該包含有哪些屬性，應該 封裝在類的內部

4.2 初始化方法

• 當使用 類名() 創建對象時，會 自動 執行以下操作：

  1. 爲對象在內存中 分配空間 —— 創建對象

  2. 爲對象的屬性 設置初始值 —— 初始化方法(init)

• 這個 初始化方法 就是 __init__ 方法，__init__ 是對象的內置方法

__init__ 方法是 專門 用來定義一個類 具有哪些屬性的方法！

在 Cat 中增加 __init__ 方法，驗證該方法在創建對象時會被自動調用

class Cat:
    """這是一個貓類"""
​
    def __init__(self):
        print("初始化方法")

4.3 在初始化方法內部定義屬性

• 在 __init__ 方法內部使用 self.屬性名 = 屬性的初始值 就可以 定義屬性

• 定義屬性之後，再使用 Cat 類創建的對象，都會擁有該屬性

class Cat:
​
    def __init__(self):
​
        print("這是一個初始化方法")
        
        # 定義用 Cat 類創建的貓對象都有一個 name 的屬性
        self.name = "Tom"
​
    def eat(self):
        print("%s 愛吃魚" % self.name)
​
# 使用類名()創建對象的時候，會自動調用初始化方法 __init__
tom = Cat()
​
tom.eat()

4.4 改造初始化方法 —— 初始化的同時設置初始值

• 在開發中，如果希望在 創建對象的同時，就設置對象的屬性，可以對 __init__ 方法進行 改造

  1. 把希望設置的屬性值，定義成 __init__ 方法的參數

  2. 在方法內部使用 self.屬性 = 形參 接收外部傳遞的參數

  3. 在創建對象時，使用 類名(屬性1, 屬性2...) 調用

class Cat:
​
    def __init__(self, name):
        print("初始化方法 %s" % name)
        self.name = name
    ...
    
tom = Cat("Tom")
...
​
lazy_cat = Cat("大懶貓")
...

05. 內置方法和屬性

序號	方法名	類型	作用
01	__del__	方法	對象被從內存中銷燬前，會被 自動 調用
02	__str__	方法	返回對象的描述信息，print 函數輸出使用

5.1 __del__ 方法

• 在 Python 中

  • 當使用 類名() 創建對象時，爲對象 分配完空間後，自動 調用 __init__ 方法

  • 當一個 對象被從內存中銷燬 前，會 自動 調用 __del__ 方法

• 應用場景

  • __init__ 改造初始化方法，可以讓創建對象更加靈活

  • __del__ 如果希望在對象被銷燬前，再做一些事情，可以考慮一下 __del__ 方法

• 生命週期

  • 一個對象從調用 類名() 創建，生命週期開始

  • 一個對象的 __del__ 方法一旦被調用，生命週期結束

  • 在對象的生命週期內，可以訪問對象屬性，或者讓對象調用方法

class Cat:
​
    def __init__(self, new_name):
​
        self.name = new_name
​
        print("%s 來了" % self.name)
​
    def __del__(self):
​
        print("%s 去了" % self.name)
​
# tom 是一個全局變量
tom = Cat("Tom")
print(tom.name)
​
# del 關鍵字可以刪除一個對象
del tom
​
print("-" * 50)

5.2 __str__ 方法

• 在 Python 中，使用 print 輸出 對象變量，默認情況下，會輸出這個變量 引用的對象 是 由哪一個類創建的對象，以及 在內存中的地址（十六進制表示）

• 如果在開發中，希望使用 print 輸出 對象變量 時，能夠打印 自定義的內容，就可以利用 __str__ 這個內置方法了

注意：__str__ 方法必須返回一個字符串

class Cat:
​
    def __init__(self, new_name):
​
        self.name = new_name
​
        print("%s 來了" % self.name)
​
    def __del__(self):
​
        print("%s 去了" % self.name)
​
    def __str__(self):
        return "我是小貓：%s" % self.name
​
tom = Cat("Tom")
print(tom)