python中的面向物件學習以及類的封裝（這篇文章初學者一定要好好看）
這篇文章對於初學者可以很有效的理解面對過程、面對物件
一、首先介紹一下面向過程和麵向物件的比較：
面向過程 VS 面向物件
程式設計正規化
程式設計是程式設計師用特定的語法+資料結構+演算法組成的程式碼來告訴計算機如何執行任務的過程 ， 一個程式是程式設計師為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有很多種不同的方式， 對這些不同的程式設計方式的特點進行歸納總結得出來的程式設計方式類別，即為程式設計正規化。 不同的程式設計正規化本質上代表對各種型別的任務採取的不同的解決問題的思路， 大多數語言只支援一種程式設計正規化，當然也有些語言可以同時支援多種程式設計正規化。 兩種最重要的程式設計正規化分別是面向過程程式設計和麵向物件程式設計。
面向過程程式設計(Procedural Programming)
面向過程程式設計，就是程式從上到下一步步執行，一步步從上到下，從頭到尾的解決問題 。基本設計思路就是程式一開始是要著手解決一個大的問題，然後把一個大問題分解成很多個小問題或子過程，這些子過程再執行的過程再繼續分解直到小問題足夠簡單到可以在一個小步驟範圍內解決。
舉個典型的面向過程的例子， 資料庫備份， 分三步，連線資料庫，備份資料庫，測試備份檔案可用性。
程式碼如下：
def db_conn():
print("connecting db...")
def db_backup(dbname):
print 這樣做的問題也是顯而易見的，就是如果你要對程式進行修改，對你修改的那部分有依賴的各個部分你都也要跟著修改，舉個例子，如果程式開頭你設定了一個變數值 為1 ， 但如果其它子過程依賴這個值 為1的變數才能正常執行，那如果你改了這個變數，那這個子過程你也要修改，假如又有一個其它子程式依賴這個子過程 ， 那就會發生一連串的影響，隨著程式越來越大， 這種程式設計方式的維護難度會越來越高。
所以我們一般認為， 如果你只是寫一些簡單的指令碼，去做一些一次性任務，用面向過程的方式是極好的，但如果你要處理的任務是複雜的，且需要不斷迭代和維護 的， 那還是用面向物件最方便了。
面向物件程式設計（OOP）
OOP程式設計是利用“類”和“物件”來建立各種模型來實現對真實世界的描述，使用面向物件程式設計的原因一方面是因為它可以使程式的維護和擴充套件變得更簡單，並且可以大大提高程式開發效率 ，另外，基於面向物件的程式可以使它人更加容易理解你的程式碼邏輯，從而使團隊開發變得更從容。
面向物件的幾個核心特性如下:
（可以通過聯想人類來理解）
1. Class 類（人類）
一個類即是對一類擁有相同屬性的物件的抽象、藍圖、原型。在類中定義了這些物件的都具備的屬性（variables(data)）、共同的方法
2. Object 物件（不同的具體的人）
一個物件即是一個類的例項化後例項，一個類必須經過例項化後方可在程式中呼叫，一個類可以例項化多個物件，每個物件亦可以有不同的屬性，就像人類是指所有人，每個人是指具體的物件，人與人之前有共性，亦有不同
3. Encapsulation 封裝
在類中對資料的賦值、內部呼叫對外部使用者是透明的，這使類變成了一個膠囊或容器，裡面包含著類的資料和方法
Inheritance 繼承
一個類可以派生出子類，在這個父類裡定義的屬性、方法自動被子類繼承
4. Polymorphism 多型
多型是面向物件的重要特性,簡單點說:“一個介面，多種實現”，指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。
程式設計其實就是一個將具體世界進行抽象化的過程，多型就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。
對不同類的物件發出相同的訊息將會有不同的行為。比如，你的老闆讓所有員工在九點鐘開始工作, 他只要在九點鐘的時候說：“開始工作”即可，而不需要對銷售人員說：“開始銷售工作”，對技術人員說：“開始技術工作”, 因為“員工”是一個抽象的事物, 只要是員工就可以開始工作，他知道這一點就行了。至於每個員工，當然會各司其職，做各自的工作。
多型允許將子類的物件當作父類的物件使用，某父型別的引用指向其子型別的物件,呼叫的方法是該子型別的方法。這裡引用和呼叫方法的程式碼編譯前就已經決定了,而引用所指向的物件可以在執行期間動態繫結。
OOP介紹：
對於程式語言的初學者來講，OOP不是一個很容易理解的程式設計方式，大家雖然都按老師講的都知道OOP的三大特性是繼承、封裝、多型，並且大家也都知道了如何定義類、方法等面向物件的常用語法，但是一到真正寫程式的時候，還是很多人喜歡用函數語言程式設計來寫程式碼，特別是初學者，很容易陷入一個窘境就是“我知道面向物件，我也會寫類，但我依然沒發現在使用了面向物件後，對我們的程式開發效率或其它方面帶來什麼好處，因為我使用函式程式設計就可以減少重複程式碼並做到程式可擴充套件了，為啥子還用面向物件？”。 對於此，我個人覺得原因應該還是因為你沒有充分了解到面向物件能帶來的好處，今天我就寫一篇關於面向物件的入門文章，希望能幫大家更好的理解和使用面向物件程式設計。
無論用什麼形式來程式設計，我們都要明確記住以下原則：
1. 寫重複程式碼是非常不好的低階行為
2. 你寫的程式碼需要經常變更
如果你把一段同樣的程式碼複製、貼上到了程式的多個地方以實現在程式的各個地方呼叫 這個功能，那日後你再對這個功能進行修改時，就需要把程式裡多個地方都改一遍，這種寫程式的方式是有問題的，因為如果你不小心漏掉了一個地方沒改，那可能會導致整個程式的執行都 出問題。 因此我們知道 在開發中一定要努力避免寫重複的程式碼，否則就相當於給自己再挖坑。
還好，函式的出現就能幫我們輕鬆的解決重複程式碼的問題，對於需要重複呼叫的功能，只需要把它寫成一個函式，然後在程式的各個地方直接呼叫這個函式名就好了，並且當需要修改這個功能時，只需改函式程式碼，然後整個程式就都更新了。
其實OOP程式設計的主要作用也是使你的程式碼修改和擴充套件變的更容易，那麼小白要問了，既然函式都能實現這個需求了，還要OOP幹毛線用呢？ 呵呵，說這話就像，古時候，人們打仗殺人都用刀，後來出來了槍，它的主要功能跟刀一樣，也是殺人，然後小白就問，既然刀能殺人了，那還要槍幹毛線，哈哈，顯而易見，因為槍能更好更快更容易的殺人。函式程式設計與OOP的主要區別就是OOP可以使程式更加容易擴充套件和易更改。
開發一個簡單版的CS來玩一玩。
暫不考慮開發場地等複雜的東西，我們先從人物角色下手， 角色很簡單，就倆個，恐怖份子、警察，他們除了角色不同，其它基本都 一樣，每個人都有生命值、武器等。 咱們先用非OOP的方式寫出遊戲的基本角色 。
#role 1
name = 'Yanfeixu'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100
上面定義了一個恐怖份子Yanfeixu和一個警察Jack,但只2個人不好玩呀，一干就死了，沒意思，那我們再分別一個恐怖分子和警察吧，
#role 1
name = 'Yanfeixu'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
money = 10000
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100
money2 = 10000
#role 3
name3 = 'Rain'
role3 = 'terrorist'
weapon3 = 'C33'
life_value3 = 100
money3 = 10000
#rolw 4
name4 = 'Eric'
role4 = 'police'
weapon4 = 'B51'
life_value4 = 100
money4 = 10000
4個角色雖然建立好了，但是有個問題就是，每建立一個角色，我都要單獨命名，name1,name2,name3,name4…，後面的呼叫的時候這個變數名你還都得記著，要是再讓多加幾個角色，估計呼叫時就很容易弄混啦，所以我們想一想，能否所有的角色的變數名都是一樣的，但呼叫的時候又能區分開分別是誰？
當然可以，我們只需要把上面的變數改成字典的格式就可以啦。
roles = {
1:{'name':'Yanfeiux',
'role':'terrorist',
'weapon':'AK47',
'life_value': 100,
'money': 15000,
},
2:{'name':'Jack',
'role':'police',
'weapon':'B22',
'life_value': 100,
'money': 15000,
},
3:{'name':'Rain',
'role':'terrorist',
'weapon':'C33',
'life_value': 100,
'money': 15000,
},
4:{'name':'Eirc',
'role':'police',
'weapon':'B51',
'life_value': 100,
'money': 15000,
},
}
print(roles[1]) #Yanfeixu
print(roles[2]) #Jack
很好，這個以後呼叫這些角色時只需要roles[1],roles[2]就可以啦，角色的基本屬性設計完了後，我們接下來為每個角色開發以下幾個功能：
- 被打中後就會掉血的功能：
- 開槍功能
- 換子彈
- 買槍
- 跑、走、跳、下蹲等動作
- 保護人質（僅適用於警察）
- 不能殺同伴
- 。。。
我們可以把每個功能寫成一個函式，類似如下：
def shot(by_who):
#開了槍後要減子彈數
pass
def got_shot(who):
#中槍後要減血
who[‘life_value’] -= 10
pass
def buy_gun(who,gun_name):
#檢查錢夠不夠,買了槍後要扣錢
pass
...
so far so good, 繼續按照這個思路設計，再完善一下程式碼，遊戲的簡單版就出來了，但是在往下走之前，我們來看看上面的這種程式碼寫法有沒有問題，至少從上面的程式碼設計中，我看到以下幾點缺陷：
- 每個角色定義的屬性名稱是一樣的，但這種命名規則是我們自己約定的，從程式上來講，並沒有進行屬性合法性檢測，也就是說role 1定義的代表武器的屬性是weapon, role 2 ,3,4也是一樣的，不過如果我在新增一個角色時不小心把weapon 寫成了wepon , 這個程式本身是檢測 不到的
- terrorist 和police這2個角色有些功能是不同的，比如police是不能殺人質的，但是terrorist可能，隨著這個遊戲開發的更復雜，我們會發現這2個角色後續有更多的不同之處， 但現在的這種寫法，我們是沒辦法 把這2個角色適用的功能區分開來的，也就是說，每個角色都可以直接呼叫任意功能，沒有任何限制。
- 我們在上面定義了got_shot()後要減血，也就是說減血這個動作是應該通過被擊中這個事件來引起的,我們呼叫get_shot()，got_shot（）這個函式再呼叫每個角色裡的life_value變數來減血。 但其實我不通過got_shot()，直接呼叫角色roles[role_id][‘life_value’] 減血也可以呀，但是如果這樣呼叫的話，那可以就是簡單粗暴啦，因為減血之前其它還應該判斷此角色是否穿了防彈衣等，如果穿了的話，傷害值肯定要減少，got_shot()函式裡就做了這樣的檢測，你這裡直接繞過的話，程式就亂了。 因此這裡應該設計 成除了通過got_shot(),其它的方式是沒有辦法給角色減血的，不過在上面的程式設計裡，是沒有辦法實現的。
- 現在需要給所有角色新增一個可以穿防彈衣的功能，那很顯然你得在每個角色裡放一個屬性來儲存此角色是否穿 了防彈衣，那就要更改每個角色的程式碼，給新增一個新屬性，這樣太low了，不符合程式碼可複用的原則
上面這4點問題如果不解決，以後肯定會引出更大的坑，有同學說了，解決也不復雜呀，直接在每個功能呼叫時做一下角色判斷啥就好了，沒錯，你要非得這麼霸王硬上弓的搞也肯定是可以實現的，那你自己就開發相應的程式碼來對上面提到的問題進行處理好啦。 但這些問題其實能過OOP就可以很簡單的解決。
之前的程式碼改成用OOP中的“類”來實現的話如下：
class Role(object): #類的名字
n = "123"
# 類變數：例項變數的改變不會影響他，但是類變數的改變會影響例項變數，提前定義，節省記憶體
def __init__(self,name,role,weapon,life_value=100,money=15000):
# 建構函式：在例項化時做一些類的初始化的工作
self.name = name # 例項變數（靜態屬性）：這些變數是賦值給了例項，其作用域就是例項本身
self.role = role
self.weapon = weapon
self.life_value = life_value
self.money = money
def shot(self): # 類的方法，功能（靜態屬性）
print("shooting...")
def got_shot(self):
print("ah...,I got shot...")
def buy_gun(self,gun_name):
print("just bought %s" %gun_name)
r1 = Role('Alex','police','AK47’)
# 生成一個角色，也就是role的一個例項，例項可以增減自己的（屬性）例項變數，但不會影響類變數
r2 = Role('Jack','terrorist','B22’) #生成一個角色
先不考慮語法細節，相比靠函式拼湊出來的寫法，上面用面向物件中的類來寫最直接的改進有以下2點：
- 程式碼量少了近一半
- 角色和它所具有的功能可以一目瞭然看出來
————————————————————————————————————————————
在真正開始分解上面程式碼含義之之前，我們現來了解一些類的基本定義
類的語法
class Dog(object):
print("hello,I am a dog!")
d = Dog() #例項化這個類，
#此時的d就是類Dog的例項化物件
#例項化，其實就是以Dog類為模版，在記憶體裡開闢一塊空間，存上資料，賦值成一個變數名
上面的程式碼其實有問題，想給狗起名字傳不進去。
class Dog(object):
def __init__(self,name,dog_type):
self.name = name
self.type = dog_type
def sayhi(self):
print("hello,I am a dog, my name is ",self.name)
d = Dog('LiChuang',"京巴")
d.sayhi()
為什麼有__init__? 為什麼有self? 此時的你一臉蒙逼，相信不畫個圖，你的智商是理解不了的！
畫圖之前， 你先註釋掉這兩句
# d = Dog('LiChuang', "京巴")
# d.sayhi()
print(Dog)
沒例項直接列印Dog輸出如下：
<class '__main__.Dog'>
這代表什麼?代表 即使不例項化，這個Dog類本身也是已經存在記憶體裡的對不對， yes, cool，那例項化時，會產生什麼化學反應呢？
這張圖非常重要，可以幫助理解類的記憶體存放的原理！！
根據上圖我們得知，其實self,就是例項本身！你例項化時python會自動把這個例項本身通過self引數傳進去。
小福利：
解構函式：在例項釋放、銷燬的時候自動執行的，通常用於做一些收尾工作，如關閉一些資料庫的連線、關閉開啟的臨時檔案。 簡單通俗來講就是，每一個例項或者程式結束的時候，解構函式就會執行。例項結束了幾個，解構函式就會執行幾次。，可以用於CS中死亡的玩家
def __del__(self):
print("%s 徹底死了。。。。" %self.name)
私有屬性 ： 在定義例項變數的時候，在變數的前面加__就可以把該變數設定為私有變數，也就是說只可以在內部訪問或更改，一旦例項化之後外部就不可以在訪問或更改。可以用於CS中的玩家，玩家是不可以更改其他玩家的資料的。
self.__life_value = life_value
私有方法：和私有屬性的用法幾乎一樣，在定義例項變數的時候，在變數的前面加__就可以把該方法設定為私有方法，一旦例項化之後，外部就不可以再訪問或者更改。可以用與CS中的玩家，玩家的一些技能是不可以被其他玩家更改的。
def __shot(self): # 類的方法，功能 （動態屬性）
print("shooting...")