Python 的物件導向特性允許我們使用類別來組織程式碼，建立可重複使用的程式碼區塊。然而，隨著專案規模的增長，記憶體管理就顯得尤為重要。不當的記憶體使用可能導致程式效能下降，甚至當機。本文將探討 Python 類別設計中兩個重要的議題：繼承和 __slots__，並分享一些記憶體最佳化的技巧。繼承是物件導向程式設計的核心概念，它允許我們建立新的類別（子類別），並從現有的類別（父類別）繼承屬性和方法。子類別可以繼承父類別的所有特性，並根據需要新增或修改自己的特性。這種機制可以減少程式碼冗餘，提高程式碼的可維護性。在 Python 中，繼承的語法非常簡單，只需在子類別的定義中指定父類別即可。Python 也支援多重繼承，允許一個子類別繼承多個父類別的特性。然而，多重繼承也可能帶來一些複雜性，例如方法解析順序（MRO）的問題。Python 使用 C3 線性化演算法來解決 MRO 問題，確保方法呼叫的順序符合預期。
除了繼承，__slots__ 也是 Python 類別設計中一個值得關注的特性。它可以有效地減少物件的記憶體佔用，尤其是在處理大量物件時。在 Python 中，每個物件都有一個 __dict__ 屬性，用於儲存物件的屬性。__dict__ 是一個字典，雖然使用方便，但會佔用額外的記憶體空間。而 __slots__ 允許我們預先定義物件的屬性，避免使用 __dict__，從而節省記憶體。使用 __slots__ 也有一些限制，例如需要預先指定所有屬性，以及在繼承時需要額外處理。然而，在需要大量建立物件的場景下，__slots__ 帶來的記憶體最佳化效果非常顯著，值得我們去深入瞭解和應用。
掌握 Python 類別：從入門到實戰
在 Python 的世界裡，類別（Class）是物件導向程式設計的根本。它們就像藍圖，讓我們能創造出具有特定屬性（Attributes）和方法（Methods）的物件。今天，玄貓將帶領大家一步步瞭解 Python 類別的奧秘，從基本概念到實際應用，讓你也能輕鬆駕馭這個強大的工具。
類別初探：開發你的第一個 Python 類別
首先，讓玄貓從一個簡單的例子開始，看看如何定義一個類別：
class Person:
pass
這段程式碼建立了一個名為 Person 的類別，但它目前還沒有任何屬性或方法。pass 關鍵字在這裡表示「不做任何事」，只是為了符合 Python 的語法要求。
屬性：為物件賦予特徵
屬性就像是物件的特徵或資料。例如，一個 Person 物件可能會有姓名和年齡等屬性。我們通常會在類別的 __init__ 方法中初始化這些屬性。__init__ 是一個特殊的方法，它會在建立物件時自動執行。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
在這個例子中，Person 類別有 name 和 age 兩個屬性。當我們建立 Person 物件時，需要傳入姓名和年齡的值，這些值會被儲存在物件的屬性中。
方法：讓物件動起來
方法是與類別相關聯的函式，它們可以對物件的屬性執行操作。例如，我們可以為 Person 類別定義一個 greet 方法，讓物件能夠打招呼。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print(f"哈囉，我是 {self.name}，今年 {self.age} 歲。")
這個 greet 方法會印出一句包含物件姓名和年齡的問候語。注意，self 引數代表物件本身，透過它可以存取物件的屬性。
例項化：創造獨一無二的物件
要使用類別，我們需要先建立它的例項（Instance）。這就像是根據藍圖建造房屋。
person1 = Person("愛麗絲", 25)
這行程式碼會建立一個 Person 類別的例項，並將其指定給 person1 變數。person1 物件的 name 屬性會被設為 “愛麗絲”，age 屬性會被設為 25。
現在，我們可以透過點運算元（.）來存取物件的屬性和方法：
person1.greet() # 輸出：哈囉，我是 愛麗絲，今年 25 歲。
完整範例：開發更生動的互動
讓我們把上面的概念整合起來，建立一個更完整的範例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print(f"哈囉，我是 {self.name}，今年 {self.age} 歲。")
person1 = Person("愛麗絲", 25)
person1.greet()
person2 = Person("鮑伯", 30)
person2.greet()
這個程式會建立兩個 Person 物件，並讓它們分別打招呼。
例項方法：物件的專屬動作
例項方法（Instance Method）是定義在類別中，與可以被該類別的例項呼叫的方法。它們可以操作物件的屬性，執行特定的動作。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self, greeting):
print(f"{greeting}, 我是 {self.name}，今年 {self.age} 歲。")
person1 = Person("愛麗絲", 25)
person1.greet("嗨") # 輸出：嗨, 我是 愛麗絲，今年 25 歲。
在這個例子中，greet 方法接受一個 greeting 引數，讓我們可以自訂問候語。
例項變數：每個物件的獨有資料
例項變數（Instance Variable）是定義在類別中，與每個例項都擁有獨立副本的變數。它們用於儲存物件的特定資料。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("愛麗絲", 25)
print(person1.name) # 輸出：愛麗絲
print(person1.age) # 輸出：25
在這個例子中，name 和 age 都是例項變數。每個 Person 物件都會有自己的 name 和 age 值。
玄貓結語
類別是 Python 物件導向程式設計的核心。透過定義類別，我們可以建立具有特定屬性和方法的物件，讓程式碼更具結構性和可重用性。希望這篇文章能幫助你掌握 Python 類別的基本概念，並在實際開發中靈活運用。
修改例項變數：Pythonic 的物件屬性調整術
在 Python 中，要修改物件的例項變數，就像是調整房屋的擺設一樣簡單。你可以使用點運算元（.）來存取變數，然後賦予它一個新的值，就像這樣：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("Alice", 25)
person1.age = 26 # 修改年齡
print(person1.age) # 輸出：26
這段程式碼先建立了一個 Person 類別的例項 person1，設定了 name 屬性為 “Alice”，age 屬性為 25。接著，我們使用點運算元將 age 修改為 26，並印出新的值。
預設值加持：讓例項變數更彈性
就像函式的引數可以有預設值一樣，例項變數也能擁有預設值，讓你的程式碼更具彈性。看看這個例子：
class Person:
def __init__(self, name, age=18): # age 預設值為 18
self.name = name
self.age = age
person2 = Person("Bob")
print(person2.age) # 輸出：18
在這個例子中，Person 類別的 age 例項變數預設值被設為 18。如果在建立類別例項時沒有提供 age 的值，它就會自動使用預設值 18。
掌握類別與例項資料：Python 物件導向的根本
在 Python 的物件導向世界中，類別可以同時擁有類別資料和例項資料。類別資料是所有例項分享的，而例項資料則是每個例項獨有的。理解這兩者之間的差異，是撰寫高效物件導向程式碼的關鍵。
類別資料：分享的知識
類別資料就像是家族的共同財產，所有成員都可以存取。它定義在類別內部，但在任何方法之外。
class Person:
count = 0 # 類別變數，記錄人數
def __init__(self, name):
self.name = name
Person.count += 1 # 每次建立例項，人數加一
在這個例子中，Person 類別有一個類別變數 count，用於追蹤 Person 類別的例項數量。每次建立新的 Person 例項時，__init__ 方法會將 count 遞增 1。
例項資料：個人專屬的記憶
例項資料就像是個人擁有的物品，每個例項都有自己的一份。它定義在 __init__ 方法中，並使用 self 引數。
class Person:
def __init__(self, name, age):
self.name = name # 例項變數，姓名
self.age = age # 例項變數，年齡
在這個例子中，Person 類別有 name 和 age 兩個例項變數。每個 Person 例項都會有自己獨特的姓名和年齡。
存取類別資料與例項資料：開啟資料之門
要存取類別資料，可以使用點運算元搭配類別名稱。要存取例項資料，則使用點運算元搭配例項名稱。
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)
print(Person.count) # 輸出：2 (類別資料)
print(person1.name) # 輸出："Alice" (例項資料)
print(person1.age) # 輸出：25 (例項資料)
print(person2.name) # 輸出："Bob" (例項資料)
print(person2.age) # 輸出：30 (例項資料)
這段程式碼建立兩個 Person 類別的例項，然後使用點運算元印出 count（類別資料）、name 和 age（例項資料）的值。
修改類別資料與例項資料：改變世界的權力
要修改類別資料，可以使用點運算元搭配類別名稱，並賦予新的值。要修改例項資料，則使用點運算元搭配例項名稱，並賦予新的值。
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)
Person.count = 3 # 修改類別資料
person1.age = 26 # 修改例項資料
print(Person.count) # 輸出：3
print(person1.age) # 輸出：26
print(person2.age) # 輸出：30
這段程式碼修改了 Person 類別的 count 值，以及 person1 的 age 值。
Slots 記憶體最佳化：節省資源的妙招
在 Python 中，每個物件都會建立一個字典來儲存所有的屬性。雖然這很方便，但如果你要建立大量的物件，可能會消耗大量的記憶體。在記憶體有限的情況下，你可以使用 __slots__ 來最佳化物件的記憶體使用量。
什麼是 Slots？
__slots__ 是一種告訴 Python 類別將擁有一組固定的屬性的方法，這樣它就不需要為每個例項建立字典。取而代之的是，它會為這些屬性分配固定量的記憶體。這可以顯著減少物件的記憶體使用量，特別是當你要建立大量的例項時。
使用 Slots：
要使用 __slots__，你需要定義一個名為 __slots__ 的類別屬性，它是一個字串序列，表示屬性的名稱。
class Person:
__slots__ = ['name', 'age'] # 定義 slots
def __init__(self, name, age):
self.name = name
self.age = age
在這個例子中，我們定義了一個 Person 類別，並為 name 和 age 屬性定義了 slots。這告訴 Python，Person 類別的每個例項只會有這兩個屬性，它可以據此分配記憶體。
使用 Slots 的好處：
使用 slots 有幾個好處：
- 記憶體最佳化：Slots 可以顯著減少物件的記憶體使用量，特別是當你要建立大量的例項時。
玄貓認為，__slots__ 的使用時機取決於應用場景。如果你的應用程式需要建立大量的物件，並且記憶體是一個重要的考量因素，那麼使用 slots 是一個不錯的選擇。
為何 Python 開發者應關注記憶體最佳化？玄貓的經驗分享
身為一個 Python 開發者，我們常常專注於功能的實作，而忽略了程式碼的效率。但當專案規模擴大，或者處理大量資料時，記憶體管理就變得至關重要。記憶體使用不當可能導致程式執行緩慢，甚至當機。玄貓在過去參與多個大型專案的經驗中，深刻體會到記憶體最佳化的重要性。
Python __slots__：節省記憶體的秘密武器
Python 是一門動態語言，允許我們在執行時動態地新增屬性。然而，這種靈活性也帶來了額外的記憶體開銷。預設情況下，Python 使用字典（__dict__）來儲存物件的屬性。字典雖然方便，但佔用空間較大。
這時候，__slots__ 就派上用場了。__slots__ 允許我們預先宣告物件的屬性，告訴 Python 這個類別的例項只會擁有這些屬性。這樣 Python 就可以使用更緊湊的記憶體結構來儲存物件，從而節省記憶體。
__slots__ 的優點：
- 節省記憶體： 這是最主要的好處。透過預先宣告屬性，避免使用
__dict__，可以顯著減少記憶體用量。 - 更快的屬性存取： 因為
__slots__為每個屬性分配了固定的記憶體空間，所以屬性存取速度比字典更快。 - 防止動態新增屬性： 使用
__slots__後，無法在執行時動態新增屬性，這有助於防止因拼寫錯誤或其他錯誤導致的 Bug。
__slots__ 的限制：
- 必須預先指定所有屬性： 這使得程式碼的靈活性降低，如果之後需要新增屬性，就必須修改類別定義。
- 繼承問題： 如果子類別繼承了使用
__slots__的父類別，子類別也必須定義__slots__，與必須包含父類別的所有屬性。
__slots__ 使用範例：
class Point:
__slots__ = ['x', 'y']
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(10, 20)
print(p.x, p.y) # 輸出: 10 20
# 嘗試動態新增屬性會丟擲 AttributeError
# p.z = 30 # 這行會報錯
內容解密：
class Point:：定義一個名為Point的類別，代表二維空間中的一個點。__slots__ = ['x', 'y']：宣告這個類別的例項只會擁有x和y這兩個屬性。def __init__(self, x, y):：建構子，用於初始化x和y屬性。p = Point(10, 20)：建立一個Point例項，x為 10，y為 20。print(p.x, p.y)：印出p的x和y屬性。# p.z = 30 # 這行會報錯：嘗試動態新增z屬性，會因為__slots__的限制而丟擲AttributeError。
深入理解 Python 類別繼承：開發可複用的程式碼
類別繼承是物件導向程式設計中的一個重要概念。它允許我們建立新的類別，並從現有的類別繼承屬性和方法。這有助於程式碼的複用和組織。
什麼是類別繼承？
類別繼承是指一個類別（子類別）繼承另一個類別（父類別或超類別）的屬性和方法。子類別可以新增自己的屬性和方法，也可以覆寫父類別的方法。
類別繼承的語法：
class Parent:
def __init__(self):
self.x = 1
def parent_method(self):
print("Parent method called.")
class Child(Parent):
pass
child = Child()
child.parent_method() # 輸出: Parent method called.
print(child.x) # 輸出: 1
內容解密：
class Parent:：定義一個名為Parent的父類別。def __init__(self):：父類別的建構子，初始化x屬性為 1。def parent_method(self):：父類別的一個方法，印出 “Parent method called."。class Child(Parent):：定義一個名為Child的子類別，繼承自Parent。pass：子類別沒有新增任何屬性或方法，使用pass佔位。child = Child()：建立一個Child例項。child.parent_method()：呼叫子類別繼承自父類別的parent_method()方法。print(child.x)：印出子類別繼承自父類別的x屬性。
覆寫父類別的方法：
子類別可以覆寫父類別的方法，以提供不同的實作。
class Parent:
def parent_method(self):
print("Parent method called.")
class Child(Parent):
def parent_method(self):
print("Child method called.")
child = Child()
child.parent_method() # 輸出: Child method called.
內容解密：
class Child(Parent):：定義一個名為Child的子類別，繼承自Parent。def parent_method(self):：子類別定義了一個與父類別同名的方法parent_method()，覆寫了父類別的方法。child = Child()：建立一個Child例項。child.parent_method()：呼叫子類別的parent_method()方法，因為子類別覆寫了父類別的方法，所以會執行子類別的parent_method()。
多重繼承：
Python 支援多重繼承，也就是一個類別可以繼承多個父類別。
class Parent1:
def __init__(self):
self.x = 1
def parent1_method(self):
print("Parent1 method called.")
class Parent2:
def __init__(self):
self.y = 2
def parent2_method(self):
print("Parent2 method called.")
class Child(Parent1, Parent2):
pass
child = Child()
child.parent1_method() # 輸出: Parent1 method called.
child.parent2_method() # 輸出: Parent2 method called.
print(child.x) # 輸出: 1
print(child.y) # 輸出: 2
內容解密：
class Child(Parent1, Parent2):：定義一個名為Child的子類別，同時繼承自Parent1和Parent2。child = Child()：建立一個Child例項。child.parent1_method()：呼叫子類別繼承自Parent1的parent1_method()方法。child.parent2_method()：呼叫子類別繼承自Parent2的parent2_method()方法。print(child.x)：印出子類別繼承自Parent1的x屬性。print(child.y)：印出子類別繼承自Parent2的y屬性。
探索 Python 多重繼承：優雅還是複雜？玄貓的觀點
多重繼承是一個強大的特性，但也可能導致程式碼難以理解和維護。在使用多重繼承時，需要仔細考慮類別之間的關係，避免出現命名衝突和菱形繼承等問題。
什麼是多重繼承？
多重繼承是指一個類別可以繼承多個父類別的屬性和方法。
多重繼承的語法：
class Parent1:
def method1(self):
print("Parent1 method called.")
class Parent2:
def method2(self):
print("Parent2 method called.")
class Child(Parent1, Parent2):
pass
child = Child()
child.method1() # 輸出: Parent1 method called.
child.method2() # 輸出: Parent2 method called.
內容解密：
class Child(Parent1, Parent2):：定義一個名為Child的子類別，同時繼承自Parent1和Parent2。child = Child()：建立一個Child例項。child.method1()：呼叫子類別繼承自Parent1的method1()方法。child.method2()：呼叫子類別繼承自Parent2的method2()方法。
方法解析順序（MRO）：
當一個類別繼承多個父類別時，Python 需要決定在哪些父類別中尋找方法。這個順序稱為方法解析順序（MRO）。
在 Python 3 中，MRO 使用 C3 線性化演算法來確定，保證方法解析順序的一致性，並尊重區域性優先順序和單調性。
可以使用 mro() 方法來存取類別的 MRO。
class Parent1:
def method(self):
print("Parent1 method called.")
class Parent2:
def method(self):
print("Parent2 method called.")
class Child(Parent1, Parent2):
pass
print(Child.mro())
# 輸出: [<class '__main__.Child'>, <class '__main__.Parent1'>, <class '__main__.Parent2'>, <class 'object'>]
內容解密：
class Child(Parent1, Parent2):：定義一個名為Child的子類別，同時繼承自Parent1和Parent2。print(Child.mro())：印出Child類別的方法解析順序。[<class '__main__.Child'>, <class '__main__.Parent1'>, <class '__main__.Parent2'>, <class 'object'>]：表示Child類別會先在自身尋找方法，然後在Parent1中尋找，接著在Parent2中尋找，最後在object類別中尋找。
玄貓的 Python 記憶體最佳化與繼承心法
__slots__ 和類別繼承是 Python 中兩個重要的概念。__slots__ 能夠幫助我們節省記憶體，而類別繼承則能夠提高程式碼的複用性和可維護性。玄貓建議，在開發過程中，應根據實際情況靈活運用這些技巧，寫出更高效、更優雅的 Python 程式碼。
