[Python] Class 教學

程式語言：Python
官方文件

簡介：class 宣告與使用
  1. class ClassName:
  2.     # name mangling "_ClassName__dis"
  3.     __dis = 0
  4.     _r = 10
  5.     
  6.     # 初始化
  7.     def __init__(self, x, y):
  8.         self.x = x
  9.         self.y = y
  10.     
  11.  
  12. c = ClassName(1, 2)
  13.  
  14. # 類別或實例本身會擁有一個__dict__特性參考至一個字典物件，其中記錄著類別或實例所擁有的特性
  15. # 如果實例的__dict__中沒有，則到產生實例的類別__dict__中尋找
  16. # 所以 c.__dict__ 看不到 _r
  17. print(c.__dict__)
  18. print(ClassName.__dict__)

宣告 attribute

如果 data attributes 和 method attributes 有相同名稱的話，會導致最先宣告的被覆蓋
要避免這個命名的衝突 (這常常是許多 bug 的由來)
建議的命名規則，如下
  • method 都是大寫的
  • data attribute 的前面加上一些小字串 (或者是底線)
  • method 都用動詞，data attribute 都用名詞

變數
宣告變數，在任意地方賦值即成立
  1. class ClassName:
  2.     # private
  3.     # 例：__spam 會被重命名為 _ClassName__spam
  4.     # 最前面至少要有兩個底線，最後面最多只能有一個底線
  5.     __private = 'private'
  6.     __private_ = '123'
  7.     __private_t = [1, 2, 3]
  8.     # public
  9.     __public__ = 10
  10.     
  11.     # 利用 __init__ 宣告變數
  12.     def __init__(self, x):
  13.         self.x = x
  14.         # 呼叫其他變數
  15.         self.__private = 'privateChange'
  16.  
  17. ClassName.y = 'y' # 在 class 等級加入變數
  18. ClassName.__y = 'y' # 無效，仍是 public
  19. c = ClassName('x')
  20. c.z = 'z'  # 在 instance 等級加入變數，不影響 class 後續的宣告
  21. c.__z = 'y' # 無效，仍是 public
  22.  
  23. # 類別或實例本身會擁有一個__dict__特性參考至一個字典物件，其中記錄著類別或實例所擁有的特性
  24. # 如果實例的__dict__中沒有，則到產生實例的類別__dict__中尋找
  25. # 所以 c.__dict__ 看不到 _r
  26. print(c.__dict__)
  27. print(ClassName.__dict__)
  28.  
  29. # 可強制呼叫 private variable 甚至賦值，但這並不安全
  30. print(c._ClassName__private)

函式(function) & 方法(method)
宣告函式，在任意地方賦於即成立
  1. def beforeF(self):
  2.     print('beforeF')
  3.  
  4. def afterF(self):
  5.     print('afterF')
  6.  
  7. class ClassName:
  8.     # 利用 __init__ 宣告變數
  9.     def __init__(self, x):
  10.         self.x = x
  11.     
  12.     # private
  13.     # 例：__spam 會被重命名為 _ClassName__spam
  14.     # 最前面至少要有兩個底線，最後面最多只能有一個底線
  15.     __private = beforeF
  16.     def __private_(self):
  17.         print('__private_')
  18.     
  19.     # 習慣上，我們把一個method的第一個參數叫做 self 。這只是一個習慣
  20.     # self 這個名字對 Python 來說完全沒有什麼特殊的意義
  21.     # 但建議 follow，這可增加可讀性
  22.     # self 改為 ttself 仍可正常執行
  23.     def __public__(ttself):
  24.         print('__public__')
  25.         # 呼叫其他 function
  26.         ttself.__private_()
  27.     
  28.  
  29. ClassName.F = afterF
  30. c = ClassName('x')
  31. c.f = afterF  # 在 instance 等級加入變數，不影響 class 後續的宣告
  32.  
  33. # 類別或實例本身會擁有一個__dict__特性參考至一個字典物件，其中記錄著類別或實例所擁有的特性
  34. # 如果實例的__dict__中沒有，則到產生實例的類別__dict__中尋找
  35. # 所以 c.__dict__ 看不到 _r
  36. print(c.__dict__)
  37. print(ClassName.__dict__)
  38.  
  39. c.__public__()
  40. # __public__
  41. # __private_
  42.  
  43. c.F()
  44. # afterF
  45.  
  46. # 可強制呼叫 private method 甚至重新賦於 function，但這並不安全
  47. c._ClassName__private()
  48. # beforeF
  49.  
  50. # TypeError: afterF() missing 1 required positional argument: 'self'
  51. # 主要是因為 instance method 是 class function 與 instance 的結合
  52. # 調用一個方法的時候，隱含 method 所處的 instance 會被當作 function 傳入的第一個參數
  53. c.f()

Function & Method 詳解

  • Function 即是在 class 中的函式
  • Method 即是在 instance 中的方法，是 function 與 instance 的結合
    調用時，instance 會被當作第一個參數傳遞過去

instancemethod 
  1. class C:
  2.     def f(self):
  3.         print('f')
  4.  
  5.  
  6. print(C.f)
  7. # <function C.f at 0x0000000002FC7840>
  8. # 因未被綁定，所以需要提供 instance，才正常執行
  9. C.f(C())
  10.  
  11. c = C()
  12. print(c)
  13. print(c.f)
  14. # <__main__.C object at 0x0000000002FCDB38>
  15. # <bound method C.f of <__main__.C object at 0x0000000002FCDB38>>
  16. # 已被綁定，所以會自行將 method 的 instance 當作第一個參數傳入
  17. c.f()

classmethod 
  1. class C:
  2.     @classmethod
  3.     def f(cls):
  4.         print('f')
  5.  
  6.  
  7. print(C.f)
  8. # <bound method C.f of <class '__main__.C'>>
  9. # 被綁定在 class C 上，所以會自行將 class C 當作第一個參數傳入
  10. # 無需傳入參數
  11. C.f()
  12.  
  13. c = C()
  14. print(c)
  15. print(c.f)
  16. # <__main__.C object at 0x00000000029ADB70>
  17. # <bound method C.f of <class '__main__.C'>>
  18. # 被綁定在 class C 上，所以會自行將 class C 當作第一個參數傳入
  19. # 與原本的 instance 已無關
  20. c.f()

staticmethod 
  1. class C:
  2.     @staticmethod
  3.     def f():
  4.         print('f')
  5.  
  6.  
  7. print(C.f)
  8. # <function C.f at 0x0000000002FE7840>
  9. # 普通的 function
  10. # 無需傳入參數
  11. C.f()
  12.  
  13. c = C()
  14. print(c)
  15. print(c.f)
  16. # <__main__.C object at 0x0000000002FEDB70>
  17. # <function C.f at 0x0000000002FE7840>
  18. # 普通的 function
  19. # 與原本的 instance & class 已無關
  20. c.f()

繼承

支援多重繼承形式
  1. class ParentA:
  2.     __private = 'private'
  3.     def pF(self):
  4.         print('parentA')
  5.     
  6.     def pFA(self):
  7.         print('parentA part 2')
  8.  
  9. class ParentB:
  10.     public = 'public'
  11.     def pF(self):
  12.         print('parentB')
  13.         
  14.     def pFB(self):
  15.         print('parentB part 2')
  16.         
  17.  
  18. class Child(ParentB, ParentA):
  19.     def cF(self):
  20.         print('child')
  21.     
  22.     # override
  23.     def pFA(self):
  24.         # 呼叫 ParentA 的 PFA
  25.         super().pFA()
  26.         
  27.         # 呼叫 ParentB 的 PFB
  28.         # 不建議使用此方法
  29.         ParentB.pFB(self)
  30.         
  31.         print('child part 2')
  32.         
  33. child = Child()
  34.  
  35. # 顯示可用變數 & method 含 private 變數
  36. print(dir(child))
  37.  
  38. child.cF()
  39. # child
  40.  
  41. # 同樣的名字時，規則是先深，而後由左至右(depth-first, left-to-right)
  42. child.pF()
  43. # parentB
  44.  
  45. child.pFA()
  46. # parentA part 2
  47. # parentB part 2
  48. # child part 2
  49.  
  50. print(child.public)
  51. # public
  52.  
  53. # AttributeError: 'Child' object has no attribute '__private'
  54. # 但有 _ParentA__private，可強制得到並賦值
  55. print(child._ParentA__private)
  56. print(child.__private)
  57.  

小技巧

@property
自定屬性 
  1. class Ball:
  2.     def __init__(self, radius):
  3.         if radius <= 0:
  4.             raise ValueError('必須是正數')
  5.         self.__radius = radius
  6.     
  7.     @property
  8.     def radius(self):
  9.         return self.__radius
  10.         
  11.     @radius.setter
  12.     def radius(self, radius):
  13.         if radius <= 0:
  14.             print('必須是正數')
  15.         else:
  16.             self.__radius = radius
  17.     
  18.     @radius.deleter
  19.     def radius(self):
  20.         del self.__radius
  21.         
  22.  
  23. ball = Ball(10)
  24.  
  25. print(ball.radius)
  26. # 10
  27.  
  28. ball.radius = -15
  29. # 必須是正數
  30. print(ball.radius)
  31. # 10
  32.  
  33. ball.radius = 15
  34. print(ball.radius)
  35. # 15
  36.  
  37. del ball.radius
  38. print(ball.radius)
  39. # AttributeError: 'Ball' object has no attribute '_Ball__radius'

__call__
設定直接呼叫的方法
  1. class Ball:
  2.     def __init__(self, radius):
  3.         if radius <= 0:
  4.             raise ValueError('必須是正數')
  5.         self.radius = radius
  6.         
  7.     def __call__(self, radius):
  8.         if radius <= 0:
  9.             print('必須是正數')
  10.         else:
  11.             self.radius = radius
  12.         
  13.  
  14. ball = Ball(10)
  15.  
  16. print(ball.radius)
  17. # 10
  18.  
  19. ball(15)
  20. print(ball.radius)
  21. # 15

__getitem__
__setitem__
__delitem__
__len__
自定 list, dic 等類似 object，numpy 便是以此建立 array 的
而 x[i] 等同於呼叫 type(x).__getitem__(x, i)

dict 範例
  1. class DictDemo:  
  2.     def __init__(self, key, value):  
  3.         self.dict = {}
  4.         self.dict[key] = value  
  5.     def __getitem__(self, key):  
  6.         return self.dict.get(key)  
  7.     def __setitem__(self, key, value):  
  8.         self.dict[key] = value
  9.     def __delitem__(self, key):
  10.         del self.dict[key]
  11.     def __len__(self):  
  12.         return len(self.dict) 
  13. dictDemo = DictDemo('k0','v0')  
  14. print(dictDemo['k0']) # v0
  15. dictDemo['k1'] = 'v1'  
  16. print(dictDemo['k1']) # v1  
  17. print(len(dictDemo)) # 2  
  18. del dictDemo['k1']
  19. print(dictDemo['k1']) # None
  20. print(len(dictDemo)) # 1

二維 list 範例
  1. class ListDemo:  
  2.     def __init__(self, data):  
  3.         self.list = data
  4.     def __getitem__(self, index):
  5.         # index 會是 tuple
  6.         return self.list[index[0]][index[1]]
  7.     def __setitem__(self, index, value):  
  8.         self.list[index[0]][index[1]]  = value
  9.     def __delitem__(self, index):
  10.         del self.list[index[0]][index[1]]
  11.     def __len__(self):  
  12.         return len(self.list) 
  13. listDemo = ListDemo([[1,2],
  14.                      [3,4]])  
  15. print(listDemo[1,0]) # 3
  16. listDemo[1,1] = 'abc'  
  17. print(listDemo[1,1]) # abc
  18. print(len(listDemo)) # 2  
  19. del listDemo[1,1]
  20. print(listDemo[1,1]) # IndexError: list index out of range

參考

Python 教學文件
property() 函式 Special method names

留言

張貼留言