我與python約個會：27. 企業級開發基礎8：面向對象擴展

前面的章節中，我們已經學習過面向對象的基本操作、面向對象的三大特徵的詳細操作，對於面向對象有了一個初步的瞭解和認知。
本節內容會針對面向對象的程序設計進行一部分的擴展和補充，方便我們在項目開發過程中的操作能更加的全面和完善。

0. 本節內容

0.1 類型屬性和對象成員屬性

0.2 對象屬性的外部聲明和限制

0.3 多繼承機制下的注意的問題

0.4 類的定製屬性~魔法方法

0.5 特殊的類型：枚舉

1. 類型屬性和對象的成員屬性

在之前的章節中，我們就類和對象已經學習過了如下內容

• 類型的定義
• 類型中屬性的定義
• 類型中方法的定義
• 屬性和方法的私有化操作

當類型在處理的過程中，我們知道在init()函數中可以初始化類的成員屬性/變量，在創建對象的過程中，每個對象的成員屬性都是互相獨立且互不影響的；對象A是不能直接使用對象B的成員屬性的值的，而是要通過對象B調用獲取對象B的屬性；
python的類型中，還提供了一種方式，可以直接定義類的屬性，這樣定義的屬性是當前類型創建的所有對象所共享的，也可以直接通過類名稱調用，這樣的屬性稱爲：類屬性

類屬性：是定義在類型中的公開的屬性，可以讓通過當前類型直接操作，可以是當前類型創建的所有對象共享的數據

# 創建一個Person類型
class Person(object):
    # 定義一個類屬性:在線人數
    onlineCount = 100
    # 類型初始化的方法
    def __init__(self, name):
        self.__name = name
    # 屬性訪問方法
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
# 創建Person類型的對象
p1 = Person("tom")
p2 = Person("jerry")

# 訪問類屬性
print(Person.onlineCount)    # 執行結果 100
print(p1.onlineCount)          # 執行結果 100
print(p2.onlineCount)          # 執行結果 100

# 通過類名稱修改類屬性
Person.onlineCount = 15
# 再次訪問類屬性
print(Person.onlineCount)    # 執行結果 15
print(p1.onlineCount)          # 執行結果 15
print(p2.onlineCount)          # 執行結果 15

# 切記不能通過對象修改類屬性：下面的做法只是給p1對象添加了一個額外的成員屬性onlineCount
p1.onlineCount = 200
# 再次訪問類屬性
print(Person.onlineCount)    # 執行結果 15
print(p1.onlineCount)          # 執行結果 200
print(p2.onlineCount)          # 執行結果 15

類和對象，注意：
類中可能會出現三種屬性/變量

• 類屬性：直接定義在類的內部，初始化函數的外部的屬性，可以直接通過類名稱訪問或者修改，通過當前類創建的對象都可以共享/訪問類的類屬性
• 成員屬性：定義在初始化函數__init__(self)中，每個通過當前類創建的對象都有自己獨立的成員屬性的數據，並且對象和對象之間的數據不會有任何影響
• 局部變量：在類的方法中的參數、方法中定義的變量都是局部變量，局部變量一旦方法執行完畢就會被回收

2. 對象屬性的外部聲明和限制

上面的代碼中，我們使用p1.onlineCount=15發現沒有修改類屬性，而是給p1增加了一個成員屬性，這是怎麼回事呢？

觀察下面的代碼：

# 創建了一個空類型
class Person:
    pass

# 創建Person的對象
p = Person()
# 給對象p追加成員屬性
p.name = "tom"
p.age = 19
p.gender = "男"
# 打印屬性數據
print(p.name, p.age, p.gender)
# 執行結果：tom 19 男

在上述代碼中，我們定義了一個空類型Person，在創建了Person的對象之後，可以在對象的引用變量上，給對象添加額外的成員屬性【切記，這裏添加的額外的成員屬性僅限於當前的這個對象，其他對象上不會出現】

這樣的操作方式，可以在一定程度上讓代碼的操作更加靈活，但是同時也降低了代碼的可讀性，試想一下~我們辛辛苦苦抽象定義好了類型Person，Person中已經出現了我們所有人知道的屬性，結果在操作的過程中，朝陽羣衆A創建的Person對象多出來了2個其他人不知道的屬性，朝陽羣衆B創建的Person對象又多出來了其他人不知道的3個屬性，這是一件非常恐怖的事情，會讓整個類型和對象的操作變得非常的混亂。

# 原始的Person類型，只有一個name屬性
class Person:
    def __init__(self, name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name

# 朝陽羣衆A創建的對象
p = Person("老A")
p.age = 20
p.sex = "男"
# 朝陽羣衆B創建的對象
p = Person ("老B")
p.gender = "女"
p.address = "朝陽"
p.phone = "13838383838"

觀察上述代碼，兩個人創建的對象，一團混亂，光是一個性別兩個開發人員定義的擴展出來的成員變量都不一致，後續其他人在操作的時候都不知道應該調用什麼屬性來處理了。

python爲了處理這樣的問題，提供了一個特殊的類屬性__slots__ ，該屬性的值是一個元組，元組中定義了類中可以出現的所有成員屬性的名稱

# 創建一個Person類型
class Person:
    # 通過__slots__屬性定義可以擴展的成員屬性名稱
    __slots__ = ("__name", "address", "age", "gender", "email")
    # 初始化方法
    def __init__(self, name):
        self.__name = name
    # 屬性的set/get方法
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
# 創建對象
p = Person("tom")
# 擴展屬性
p.address = "朝陽"
p.age = 20
p.sex = "男"
# 執行結果
~ AttributeError: 'Person' object has no attribute 'sex'

通過上述代碼就可以看到，python提供了一個__slots__類屬性，屬性的值是一個元組，元組中規範了可能出現在類的成員屬性列表。

類在創建好對象之後，可以在對象上直接掛在屬性，這在一定程度上對於程序處理的靈活度有所提升，但是同樣的，過於靈活的代碼都會極大的降低代碼的可讀性，所以python提供了__slots__這樣的類屬性進行規範，規範類屬性中只能出現的成員屬性的列表，防止惡意的擴展。

3. 多繼承機制下的注意的問題

多繼承機制，在操作的過程中，同樣也是提高了代碼的處理靈活性，很大程度的擴展了代碼的功能

在使用多繼承機制進行程序設計開發的過程中一定要注意一個問題：當前類繼承了一個或者多個父類，當前類就同時繼承了父類中的公開的屬性和函數，如果不同的父類中出現相同的屬性/函數，就需要明確執行的過程

# 定義一個類型Son
class Son(object):
    def fealty(self):
        print("孝順父母")
# 常見一個類型Student
class Student(object):
    def fealty(self):
        print("尊師重道")

# 創建一個Person類型，繼承自Son和Student
class Person(Son, Student):
    pass

# 創建對象，執行方法
p = Person()
p.fealty()
# 問題：這裏的fealty()函數，會不會報錯？如果不報錯，怎麼執行？
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 我們可以看到，在繼承的兩個父類中都出現了fealty()函數
# 這裏執行時，按照類型定義時繼承的順序進行查找
#  查找到對應的函數立刻執行並且不再向後查詢
# 上述案例中，繼承順序是（Son, Student）
# 首先在Son類型中查詢是否有fealty()方法，查詢到立刻執行。
# 執行結果：孝順父母
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

上述案例中，我們看到一旦出現多重繼承，就會出現這樣繼承的多個父類中出現了多個相同名稱的變量或者方法的情況，使用的這些變量和方法的時候一定要注意一個原則，先繼承誰就使用誰的變量或者方法！

4. 類的定製屬性~魔法方法

上面的代碼中，我們已經看到了，類似__slots__這樣的變量在前後加了雙下劃線的，在python中會有特殊的含義，這裏會繼續介紹一些常見的在面向對象開發過程中出現的一些這樣的魔法方法

4.1. 對象格式化打印輸出【__str__()】

常規情況下，對象直接輸出，會輸出對象的描述信息，晦澀難懂

# 定義類型
class Person(object):
    def __init__(self, name):
        self.__name = name
# 創建對象
p = Person("jerry")
# 輸出對象
print(p) 
# 執行結果：<__main__.Person object at 0x0000028727259550>

對當前類型進行如下改造

# 定義類型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __str__(self):
        return "i am a person, my name is " + self.__name
# 創建對象
p = Person("jerry")
# 輸出對象
print(p) 
# 執行結果：i am a person, my name is jerry
p
# 執行結果：<__main__.Person object at 0x0000028727259550>

我們突然發現，直接打印對象，輸出的結果竟然是我們在__str__()方法中定義的字符串。其實我們在使用使用對象的時候，就會默認調用對象的__str__()方法獲取對象的字符串描述信息，這個__str__()方法是從object對象繼承而來的，我們這裏只是對它進行了方法重寫。

另外，在命令行操作過程中，如果不用print()方法打印而是直接輸入對象，會發現執行的結果又是讓人晦澀難懂的東西了，在命令行直接使用對象調用的不是對象的__str__()方法，而是__repr__()方法，只需要簡單的修改即可

# 定義類型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __str__(self):
        return "i am a person, my name is " + self.__name
    # 將方法__str__賦值給__repr__
    __repr__ = __str__
# 創建對象
p = Person("jerry")
# 輸出對象
print(p) 
# 執行結果：i am a person, my name is jerry
p
# 執行結果：i am a person, my name is jerry

4.2. 玩轉自己~對象的應用直接調用【__call__()】

當我們創建好對象之後，可以將對象的引用變量當成方法執行會出現什麼樣的情況呢

# 定義類型
class Person(object):
    def __init__(self, name):
        self.__name = name
# 創建對象
p = Person("jerry")
# 直接執行
p()
# 執行結果：TypeError: 'Person' object is not callable

肯定是不能這麼幹的~，所以出現錯誤：Person對象不是一個可執行的東東

但是可以進行如下的改造

# 定義類型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __call__(self):
        print("一種快捷執行對象中某些初始化操作的特殊方法__call__")
# 創建對象
p = Person("jerry")
# 直接執行
p()
# 執行結果：一種快捷執行對象中某些初始化操作的特殊方法__call__

此時又發現，這樣直接將引用變量當成方法執行又變的可行了。
__call__()方法，主要用於對象快捷執行而存在的一個魔術方法，方便進行對象中某些重要數據的初始化整理工作等。

在python中，還有一系列的魔法方法，可以讓一個類具有各種特殊的處理功能，如__iter__()方法，讓一個類創建的對象可以像列表那樣進行數據的迭代；__getitem__()函數可以在迭代的基礎上進行索引取值等操作，

5. 特殊的類型：枚舉

某些情況下，在我們項目開發過程中，會針對一些不會改變的數據進行標記，~常見的做法就是通過定義常量的情況進行處理，如：在一個員工管理系統中，針對一年十二個月發放工資，這裏的十二個月需要進行標記~每個月的天數、績效這些都不一定一致，可以按照下面的方式進行處理：

# 通過列表中定義一堆的變量來表示12個月份
month = ["JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]
# 但是列表表示的方式，列表中的數據並不是非常的安全，有可能在操作的過程中被修改

# 通過元組中定義一堆的變量來表示12個月份
month = ("JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC")
# 這樣就比第一種方案簡單多了，也方便後續的各種操作

# 通過類型中定義一堆的變量來表示12個月份
class Month(object): 
    "JAN" = 1
     "FAB" = 2
    "MAR" = 3
    "APR" = 4 
    "MAY" = 5 
    "JUN" = 6 
    "JUL" = 7 
    "AUG" = 8 
    "SEP" = 9 
    "OCT" = 10 
    "NOV" = 11
    "DEC" = 12
# 這樣更加正式一些，不過寫起來確實挺麻煩，後續的操作也不怎麼友好

5.1. 使用枚舉

上述代碼中，我們通過三種方式進行了枚舉的定義和處理，但是每一種方式都多多少少存在一些遺憾，python中提供了一種特殊的類型：枚舉，來處理這樣定義常量的問題：

枚舉的語法結構：是不是和上面我們使用元組的方式特別相像呢？！

from enum import Enum
# Month = Enum("枚舉名稱", (元組中的枚舉值))
M = Enum("Month",  ("JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"))
# 使用枚舉
print(M.JAN)   #執行結果：Month.JAN
print(M.JAN.value) # 執行結果：1

通過將我們原始的條件判斷，加上枚舉操作，可以簡化代碼的同時提高代碼的可讀性
參考如下代碼，明顯第二種代碼的可讀性更高，更加方便我們的項目維護操作

if month == 1:
    print("1月份發放工資")
-------------------------------------------
if month = Month.JAN:
     print("1月份發放工資")

5.2. 自定義枚舉

Python提供的枚舉已經完全足夠適用於我們項目中使用的各種場景了
如果枚舉的細節處理程度還是不滿足您的項目，可以通過python提供的方式進行自定義枚舉的定義

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#  自定義枚舉語法結構
# from enum import Enum, unique
#
# @unique
# class EnumName(Enum):
#     枚舉元素
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 創建一個自定義枚舉，用於定義一週中星期的每一天，方便做日誌記錄
from enum import Enum, unique

@unique
class Weekday(Enum):
    MON = 1
    TUE = 2
    WED = 3
    THU = 4
    FRI = 5
    SAT = 6
    SUN = 7
# 使用枚舉，和常規的使用方式一致
if today == Weekday.SAT:
    print("提醒：今天是發送週報的日子，不要忘記哦")

枚舉，是爲了方便在項目中定義有字面意義的常量，提高代碼的可讀性而出現的一種特殊的類型，底層封裝的其實就是給枚舉的名稱賦值了整數數據，所以我們可以在程序中使用整數常量作爲條件處理判斷的地方，使用枚舉能提高代碼的可讀性和維護性。