之前的文章我們簡單介紹了一下 Python 的函數，本篇文章我們來看一下 Python 中的面向對象。
Python從設計之初就已經是一門面向對象的語言，正因為如此，在Python中創建一個類和對象是很容易的。
面向對象技術簡介
- 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
- 方法：類中定義的函數。
- 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。
- 數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
- 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
- 局部變量：定義在方法中的變量，只作用於當前實例的類。
- 實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。
- 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。
- 實例化：創建一個類的實例，類的具體對象。
- 對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。
和其它編程語言相比，Python 在盡可能不增加新的語法和語義的情況下加入了類機制。
Python中的類提供了面向對象編程的所有基本功能：類的繼承機制允許多個基類，派生類可以覆蓋基類中的任何方法，方法中可以調用基類中的同名方法。
對象可以包含任意數量和類型的數據。
Python 中定義類的方法是以 class k開頭，我們先定義一個類：
1 class Cat: 2 def eat(self): 3 print("貓吃魚") 4 5 cat = Cat() 6 cat.eat() # 貓吃魚
如上 ，我們定義了一個 Cat 類，里面定義了一個方法，我們可以通過 變量=類名() 的方式來實例化一個類，這樣我們就可以調用類里面的屬性和方法，所以當我們調用 cat.eat() 時輸出打印 Cat 類里面的 eat() 方法。
在上面的 eat() 方法中，我們默認穿了一個 self 的參數，它代表該類的實例，不一定非叫 self ，可以叫 xxx，只是我們約定俗成叫 self，跟 *args 和 **kwargs 一個道理，那該如何理解這個 self 呢，如下：
1 class Cat: 2 def eat(self): 3 print(self.name+"吃魚") 4 5 6 tom = Cat() 7 tom.name = "Tom" 8 tom.eat() # Tom吃魚 9 10 jerry = Cat() 11 jerry.name = "Jerry" 12 jerry.eat() # Jerry吃魚
在上面的代碼中，我們定義了兩個 Cat 的實例，並且在每個實例中都添加了一個 name 屬性，如果我們想要在 eat() 方法中輸出各自定義的 name 值，我們可以通過 self 屬性來定義，因為 self 就表示該類的實例，所以就會去拿各自實例里面的 name 值。
上面的代碼中我們可以實現輸出不同的 name 值，但是需要我們在實例化后自己定義 name，我們也可以在定義類的時候就將 name 值傳入來做：
1 class Cat: 2 def __init__(self,name): 3 self.name = name 4 def eat(self): 5 print(self.name+"吃魚") 6 7 tom = Cat("Tom") 8 tom.eat() # Tom吃魚 9 10 jerry = Cat("Jerry") 11 jerry.eat() # Jerry吃魚
上面的代碼中，我們在 Cat 類中定義了一個 __init__() 的方法，該方法是類自帶的方法，第一個參數必須為 self，我們可以在里面定義自己所需的變量。如上，我們在實例化 Cat 類的時候就將 Tom ，Jeery 傳入，然后在 self 形參后面添加形參，該形參與傳入參數的順序意義對應，這樣我們就可以使用傳入的參數了，定義和使用時需要在前面加 self.
在上面的代碼演示中，我們可以看出當我們實例化一個類之后，就能調用該類的方法，這種方法叫公有方法，還有一種方法叫私有方法，就是實例化后不能被調用，只有自己內部可以調用，如下：
1 class Cat: 2 def __init__(self,name): 3 self.name= name 4 def eat(self): 5 print(self.name+"吃魚") 6 self.__run() 7 def __run(self): 8 print("私有方法") 9 10 tom = Cat("Tom") 11 tom.eat() # Tom吃魚 私有方法 12 tom.__run() # AttributeError: 'Cat' object has no attribute '__run'
上面的代碼中當我們實例化 tom 后，可以通過 eat() 方法調用到 __run() 方法，但是直接調用 __run() 會報錯。
不僅私有方法不能被調用，私有屬性也不能，如下：
1 class Cat: 2 age = 11 3 __height = 120 4 def add(self): 5 self.age += 1 6 self.__height += 1 7 8 tom = Cat() 9 tom.add() 10 print(tom.age) # 12 11 print(tom.__height) # AttributeError: 'Cat' object has no attribute '__height'
接下來我們看一下類中的繼承，在上面的代碼中我們定義了一個 Cat 的類，里面有一個 eat() 方法，當我們定義一個 Dog 類時，它也有一個 eat() 方法，而且 eat() 方法是一樣的，現在 Cat 類有一個 bark() 方法，Dog 類里也有一個 bark() 方法，但是這兩個方法執行的結果不一樣，而且 Dog 類里有一個 swim() 方法，而 Cat 里沒有，如果我們都分別定義這兩個類的話，代碼會很長，而且如果兩個相同的 eat() 方法需要修改時需要修改兩個地方，這時我們可以用繼承的方式解決，如下：
1 class Animal: 2 def eat(self): 3 print("吃吃吃") 4 5 class Cat(Animal): 6 def bark(self): 7 print("喵喵喵") 8 9 class Dog(Animal): 10 def bark(self): 11 print("汪汪汪") 12 13 def swim(self): 14 print("狗刨式") 15 16 cat = Cat() 17 cat.eat() # 吃吃吃 18 cat.bark() # 喵喵喵 19 cat.swim() # AttributeError: 'Cat' object has no attribute 'swim' 20 21 dog = Dog() 22 dog.eat() # 吃吃吃 23 dog.bark() # 汪汪汪 24 dog.swim() # 狗刨式
我們將 Cat 類和 Dog 類相同的 eat() 方法定義在了 Animal 類里，然后在創建 Cat 和 Dog 類時添加了 (Animal)，意思是繼承 Animal 類，這樣我們在實例化 Cat 和 Dog 類后就能調用 Animal 類里的方法 eat()，而且還能調用各自實例里的 bark() 方法，但是如果沒有另一個類，則不能使用該類的方法，如 cat 調用 dog 的 swim() 方法就會報錯。
當然我們可以讓 Cat 類也繼承 Dog 類，如下：
1 class Animal: 2 def eat(self): 3 print("吃吃吃") 4 # Cat 類要想繼承 Dog 類必須寫在 Dog 類后面 5 # class Cat(Dog,Animal): 6 # def bark(self): 7 # print("喵喵喵") 8 9 class Dog(Animal): 10 def bark(self): 11 print("汪汪汪") 12 def swim(self): 13 print("狗刨式") 14 15 class Cat(Dog,Animal): 16 def bark(self): 17 print("喵喵喵") 18 19 cat = Cat() 20 cat.eat() # 吃吃吃 21 cat.bark() # 喵喵喵 22 cat.swim() # 狗刨式 23 24 dog = Dog() 25 dog.eat() # 吃吃吃 26 dog.bark() # 汪汪汪 27 dog.swim() # 狗刨式
如上，我們可以讓 Cat 同時繼承 Dog 和 Animal 兩個類，但是如若想要繼承某類，必須先創建該類。
我們也可以多重繼承，即讓 Animal 類也繼承某類，這樣 Cat 和 Dog 如果繼承了 Animal 類，那么也可以使用 Animal 類繼承的父類的屬性和方法。
只得注意的是私有屬性和方法不能被繼承，因為私有屬性和方法只能在自己的類中使用。
接下來我們看一下類中方法的重寫：
1 class Animal: 2 def eat(self): 3 print("吃吃吃") 4 5 class Cat(Animal): 6 pass 7 8 class Dog(Animal): 9 def eat(self): 10 print("大口大口吃") 11 12 cat = Cat() 13 cat.eat() # 吃吃吃 14 15 dog = Dog() 16 dog.eat() # 大口大口吃
在上面的代碼中，我們讓 Cat 和 Dog 類都繼承了 Animal 類，但是在 Dog 類中，我們定義了一個和 Animal 類中一樣的方法名，但是執行的結果不一樣，當我們分別調用實例化的 cat 和 dog 的 eat() 方法時，Cat 類由於沒有自己的 eat() 方法，所以向上尋找，發現繼承的 Animal 類中有 eat() 方法，所以就調用了 Animal 類中的 eat() 方法，但是 Dog 類中有 eat() 方法，所以就調用自己的 eat() 方法，不在向上尋找，這就是類中方法的重寫。
在上面我們說過了類屬性和實例方法，接下來我們來看一下類方法：
1 class Cat: 2 # 類屬性 3 age = 10 4 5 # 實例方法 6 def __init__(self): 7 self.name = "Tom" 8 9 def info(self): 10 print(self.name, self.age) 11 12 # 類方法 13 @classmethod 14 def addAge(cls): 15 cls.age = 22 16 17 tom = Cat() 18 tom.info() # Tom 10 19 Cat.info() # TypeError: info() missing 1 required positional argument: 'self' 20 21 tom.addAge() 22 print(tom.age) # 22 23 print(Cat.age) # 22 24 25 Cat.addAge() 26 print(tom.age) # 22 27 print(Cat.age) # 22
如果我們在類里面的方法前面加 @classmethod，就表明該方法為類方法，在說類方法前我們再來看一下實例方法。
當我們實例化一個 tom 后，我們就可以調用 tom 里面的實例方法，我們之前說過 self 指的是該類的實例化，所以當我們調用 tom.info() 時能正常調用，但是 Cat.info() 時則會報錯，因為里面的 self 指向的是實例化的 tom，而不是 Cat 類，所以會報錯。
在類方法中，我們同樣謠傳一個默認的形參，默認叫 cls，它指向的是類本身，而不是該類的實例化，所以我們可以通過 cls.age=22 來更改類里面的類屬性，而且類方法 addAge() 可以使用實例化的 tom 來調用，也可以使用 Cat 類本身來調用。