申明：資料來源于網路及書本，通過理解、實踐、整理成學習筆記，

類（Class）

類的定義與使用

類必須在被定義后才能使用，定義一個類也就是定義這一類物件的模板，定義它的屬性和方法，python中提供了class關鍵字來宣告一個類，class中有成員屬性和成員方法，

類的格式：
class [類名]:
	[陳述句塊]

類的定義：
class NewClass:
	pass
類的使用：
# 實體化類
new = NewClass()

類的構造方法

在創建實體時，很多類都需要特定的初始狀態，所以一個類可以定義一個特殊的方法，叫做構造方法，在python中，建構式就是類的__int__方法，當一個類定義了__int__方法，在類實體化是會自動呼叫__int__方法，
注意：構造方法的回傳值必須是"None"

class Human:
    def __init__(self):
        print('我是人類')
        
human = Human()
執行結果：
我是人類

類的屬性與方法

• 屬性：又稱為成員變數或類變數，必須要使用"self"加上點的方式賦值，不能直接定義變數，直接定義的變數的生命周期只會在函式內，函式執行完變數就會被銷毀，

  class Human:
      def __init__(self, name):
          self.name = name	#正確的定義變數方式
          age = 	3			#錯誤的定義變數方式
  
  human = Human('周星馳')
  print(human.name)
  
  執行結果：
  周星馳
  

• 方法：在類中定義的函式稱之為方法，類的方法和函式定義的方法基本相同，但方法一定要在類里并且第一個引數必須是"self"

  class Human:
      def __init__(self, name):
          self.name = name
  	# 方法
      def run(self):
          print('生命不息，運動不止')
  
  human = Human('周星馳')
  human.run()
  
  執行結果：
  生命不息，運動不止
  

私有屬性與私有方法

• 私有屬性：在上面的例子中可以看到實體可以獲取和修改屬性的值，但如果我們需要限制實體修改屬性的話就要用到私有屬性，定義私有屬性只需要在定義屬性名字的時候使用兩條下劃線作為開頭，python解釋器就認為這個屬性時私有的，外部不能隨便訪問這個屬性，

  class Human:
      def __init__(self, name):
          self.__name = name
  
  human = Human('周星馳')
  human.__name()
  
  執行結果：
  AttributeError: 'Human' object has no attribute '__name'
  

  雖然我們在構造方法給"__name"賦值了，但是在實體中不能直接訪問到這個私有變數，我們可以使用這個特效保護一些不想讓用戶隨便修改的屬性，

  class Human:
      def __init__(self):
          self.__name = None
  
      def set_name(self, name):
          if not isinstance(name, str):
              print('名字必須是字串')
              return False
          if len(name) > 4:
              print('名字的字符數不嫩大于4！')
              return False
          elif len(name) <= 0:
              print('名字的字符數必須大于0！')
              return False
          self.__name = name
  
      def play(self):
          print('我的名字是：', self.__name)
  
  human = Human()
  human.set_name(1)
  human.set_name('')
  human.set_name('阿姆斯特朗')
  human.set_name('周星馳')
  human.play()
  
  執行結果：
  名字必須是字串
  名字的字符數必須大于0！
  名字的字符數不嫩大于4！
  我的名字是： 周星馳
  

• 私有方法：私有方法與私有變數相似，也是只能在類內部被呼叫，實體不能直接呼叫，

  class Human:
      def __init__(self, name):
          self.name = name
  
      # 方法
      def __run(self):
          print('生命不息，運動不止')
  
  human = Human('周星馳')
  human.__run()	#錯誤
  
  執行結果：
  AttributeError: 'Human' object has no attribute '__run'
  

靜態方法與類方法

• 靜態方法：與類變數有點相似，在定義類時就已經被分配好了，并不系結類也不系結實體，相當于給方法添加了一個前綴，定義靜態方法需要加入裝飾器語法"@staticmethod"，靜態方法不再需要"self"，在呼叫時也不需要實體化，

  class Human:
  	name = '周星馳'
  	
      @staticmethod
      def run():
          print('生命不息，運動不止')
  
  Human.run()
  
  執行結果：
  生命不息，運動不止
  

• 類方法：該方法系結在定義的類上，而不是系結在實體上，定義靜態方法需要加入裝飾器語法"@classmethod"，類方法都有一個初始的引數"cls"，這個引數指向的是定義的類本身，所有類方法可以讀取和修改類變數，

  class Human:
      name = '周星馳'
  
      @classmethod
      def run(cls):
          print(cls.name, '生命不息，運動不止')
  
  Human.run()
  
  執行結果：
  周星馳 生命不息，運動不止
  

繼承與多型

面向物件編程具有三大特效：封裝性、繼承性、多型性，

繼承

在一個類的基礎上制定一個新類，這個類不僅可以繼承原來類的屬性和方法，還可以添加新的屬性和方法，原來的類叫父類，新的類叫子類，python還支持多重繼承，也就是說一個子類能繼承多個父類，但子類不能呼叫父類的私有變數和私有方法，

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

    def eat(self):
        print('人是鐵，飯是鋼')


class YellowHuman(Human):
    pass

yellow_human = YellowHuman('周星馳')
yellow_human.eat()

執行結果：
人是鐵，飯是鋼

如上所示，"YellowHuman"這個類沒有寫"eat"方法，但是繼承了"Human"類，所有就相當于擁有了"Human"類中的所有方法，執行"yellow_human.eat()“陳述句的結果為"人是鐵，飯是鋼”

多型

當子類和父類存在相同的方法時，子類的方法會覆寫父類的方法，這樣的代碼在運行時總是會呼叫子類的方法，這就是多型

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

    def run(self):
        print('生命不息，運動不止')


class YellowHuman(Human):
    def run(self):
        print('生命在于運動')

class BlackHuman(Human):
    def run(self):
        print('你想擁有強壯的肌肉嗎')

yellow_human = YellowHuman('周星馳')
yellow_human.run()
balck_human = BlackHuman('巨石強森')
balck_human.run()

執行結果：
生命在于運動
你想擁有強壯的肌肉嗎

鴨子型別

鴨子型別（Duck Typing）是動態型別的一種風格，在這種風格中，一個物件有效的語意，不是有繼承自特定的類或實作特定的介面決定的，而是由當前方法和屬性的集合決定的，
鴨子型別通常得意于不測驗方法和函式得到型別，而是依賴檔案、清晰的代碼和測驗來確保正常使用，從靜態型別語言轉向動態型別語言的用戶通常試圖添加一些靜態的型別檢查，從而影響了鴨子型別的益處和可升縮性，并約束了語言的動態特性，

class YellowHuman:
    def run(self):
        print('生命在于運動')

class BlackHuman:
    def run(self):
        print('你想擁有強壯的肌肉嗎')

def human_run(human):
    human.run()

yellow_human = YellowHuman()
balck_human = BlackHuman()

human_run(yellow_human)
human_run(balck_human)

執行結果：
生命在于運動
你想擁有強壯的肌肉嗎

這個例子中雖然沒有使用繼承，但是我們任然可以實作"多型"，這也是"多型"的一種實作方式，

類變數與實體變數的區別

類變數：不需要實體化就能直接使用，相當于系結在類上，而不是系結在實體上，但是類變數在實體中也是可以被呼叫的，可在類的所有實體之間共享的值

class Human:
    name = '名字'	#類變數

print(Human.name)
human = Human()
print(human.name)

執行結果：
名字
名字

實體變數：實體化之后，每個實體單獨擁有的變數，

class Human:
    def __init__(self, name):
        self.name = name	#實體變數

human = Human('名字')
print(human.name)

執行結果：
名字

類變數和實體變數的區別在于：類變數是所有物件共有，其中一個物件將它值改變，其他物件得到的就是改變后的結果；而實體變數則屬物件私有，某一個物件將其值改變，不影響其他物件，

一個堅持學習，堅持成長，堅持分享的人，即使再不聰明，也一定會成為優秀的人！

如果看完覺得有所識訓的話，記得一鍵三連哦，謝謝大家！