面向對象編程其實很簡單——Python 面向對象（初級篇）
今天看到武sir發了一篇關於python面向對象編程的博文，感受很好，從新溫習了一遍封裝、繼承、多態，特轉載一下，在看的時候，請自動忽略裏面一些猥瑣的字段
python
在Python教學中發現，不少同窗在走到面向對象編程這塊就開始蒙圈了，爲了幫助你們更好的理解面向對象編程並其能將其用到本身的開發過程當中，特寫此文。
編程
概述
面向過程：根據業務邏輯從上到下寫壘代碼服務器
函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可ide
面向對象：對函數進行分類和封裝，讓開發「更快更好更強...」函數式編程
面向過程編程最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。函數
while True： if cpu利用率 > 90%: #發送郵件提醒 鏈接郵箱服務器 發送郵件 關閉鏈接 if 硬盤使用空間 > 90%: #發送郵件提醒 鏈接郵箱服務器 發送郵件 關閉鏈接 if 內存佔用 > 80%: #發送郵件提醒 鏈接郵箱服務器 發送郵件 關閉鏈接隨着時間的推移，開始使用了函數式編程，加強代碼的重用性和可讀性，就變成了這樣：
def 發送郵件(內容)
#發送郵件提醒
鏈接郵箱服務器
發送郵件
關閉鏈接
while True：
if cpu利用率 > 90%:
發送郵件('CPU報警')
if 硬盤使用空間 > 90%:
發送郵件('硬盤報警')
if 內存佔用 > 80%:
發送郵件('內存報警')
今天咱們來學習一種新的編程方式：面向對象編程（Object Oriented Programming，OOP，面向對象程序設計）
注：Java和C#來講只支持面向對象編程，而python比較靈活即支持面向對象編程也支持函數式編程學習
建立類和對象
面向對象編程是一種編程方式，此編程方式的落地須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。spa
類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能設計
對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數3d
class是關鍵字，表示類
建立對象，類名稱後加括號便可
ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）
類中定義的函數叫作 「方法」
# 建立類
class Foo:
def Bar(self):
print 'Bar'
def Hello(self, name):
print 'i am %s' %name
# 根據類Foo建立對象obj
obj = Foo()
obj.Bar() #執行Bar方法
obj.Hello('wupeiqi') #執行Hello方法
誒，你在這裏是否是有疑問了？使用函數式編程和麪向對象編程方式來執行一個「方法」時函數要比面向對象簡便
面向對象：【建立對象】【經過對象執行方法】
函數編程：【執行函數】
觀察上述對比答案則是確定的，而後並不是絕對，場景的不一樣適合其的編程方式也不一樣。
總結：函數式的應用場景 --> 各個函數之間是獨立且無共用的數據
面向對象三大特性
面向對象的三大特性是指：封裝、繼承和多態。
1、封裝
封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。
因此，在使用面向對象的封裝特性時，須要：
將內容封裝到某處
從某處調用被封裝的內容
第一步：將內容封裝到某處
self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1
當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2
因此，內容其實被封裝到了對象 obj1 和 obj2 中，每一個對象中都封裝了 name 和 age ，以前說的「內容封裝到某處」其在內容裏相似於下圖來保存。
第二步：從某處調用被封裝的內容
調用被封裝的內容時，有兩種狀況：
經過對象直接調用
經過self間接調用
一、經過對象直接調用被封裝的內容
上圖展現了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Foo('wupeiqi', 18)
print obj1.name # 直接調用obj1對象的name屬性
print obj1.age # 直接調用obj1對象的age屬性
obj2 = Foo('alex', 73)
print obj2.name # 直接調用obj2對象的name屬性
print obj2.age # 直接調用obj2對象的age屬性
二、經過self間接調用被封裝的內容
執行類中的方法時，須要經過self間接調用被封裝的內容
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self):
print self.name
print self.age
obj1 = Foo('wupeiqi', 18)
obj1.detail() # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，因此，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail() # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，因此，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
綜上所述，對於面向對象的封裝來講，其實就是使用構造方法將內容封裝到 對象 中，而後經過對象直接或者self間接獲取被封裝的內容。
練習一：在終端輸出以下信息
小明，10歲，男，上山去砍柴
小明，10歲，男，開車去東北
小明，10歲，男，最愛大保健
老李，90歲，男，上山去砍柴
老李，90歲，男，開車去東北
老李，90歲，男，最愛大保健
函數式編程
def kanchai(name, age, gender):
print "%s,%s歲,%s,上山去砍柴" %(name, age, gender)
def qudongbei(name, age, gender):
print "%s,%s歲,%s,開車去東北" %(name, age, gender)
def dabaojian(name, age, gender):
print "%s,%s歲,%s,最愛大保健" %(name, age, gender)
kanchai('小明', 10, '男')
qudongbei('小明', 10, '男')
dabaojian('小明', 10, '男')
kanchai('老李', 90, '男')
qudongbei('老李', 90, '男')
dabaojian('老李', 90, '男')
class Foo:
def __init__(self, name, age ,gender):
self.name = name
self.age = age
self.gender = gender
def kanchai(self):
print "%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender)
def qudongbei(self):
print "%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender)
def dabaojian(self):
print "%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender)
xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()
laoli = Foo('小明', 10, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()
上述對比能夠看出，若是使用函數式編程，須要在每次執行函數時傳入相同的參數，若是參數多的話，又須要粘貼複製了... ；而對於面向對象只須要在建立對象時，將全部須要的參數封裝到當前對象中，以後再次使用時，經過self間接去當前對象中取值便可。
練習二：遊戲人生程序
一、建立三個遊戲人物，分別是：
蒼井井，女，18，初始戰鬥力1000
東尼木木，男，20，初始戰鬥力1800
波多多，女，19，初始戰鬥力2500
二、遊戲場景，分別：
草叢戰鬥，消耗200戰鬥力
自我修煉，增加100戰鬥力
多人遊戲，消耗500戰鬥力
# -*- coding:utf-8 -*-
# ##################### 定義實現功能的類 #####################
class Person:
def __init__(self, na, gen, age, fig):
self.name = na
self.gender = gen
self.age = age
self.fight =fig
def grassland(self):
"""註釋：草叢戰鬥，消耗200戰鬥力"""
self.fight = self.fight - 200
def practice(self):
"""註釋：自我修煉，增加100戰鬥力"""
self.fight = self.fight + 200
def incest(self):
"""註釋：多人遊戲，消耗500戰鬥力"""
self.fight = self.fight - 500
def detail(self):
"""註釋：當前對象的詳細狀況"""
temp = "姓名:%s ; 性別:%s ; 年齡:%s ; 戰鬥力:%s" % (self.name, self.gender, self.age, self.fight)
print temp
# ##################### 開始遊戲 #####################
cang = Person('蒼井井', '女', 18, 1000) # 建立蒼井井角色
dong = Person('東尼木木', '男', 20, 1800) # 建立東尼木木角色
bo = Person('波多多', '女', 19, 2500) # 建立波多多角色
cang.incest() #蒼井空參加一次多人遊戲
dong.practice()#東尼木木自我修煉了一次
bo.grassland() #波多多參加一次草叢戰鬥
#輸出當前全部人的詳細狀況
cang.detail()
dong.detail()
bo.detail()
cang.incest() #蒼井空又參加一次多人遊戲
dong.incest() #東尼木木也參加了一個多人遊戲
bo.practice() #波多多自我修煉了一次
#輸出當前全部人的詳細狀況
cang.detail()
dong.detail()
bo.detail()
遊戲人生
2、繼承
繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。
例如：
貓能夠：喵喵叫、吃、喝、拉、撒
狗能夠：汪汪叫、吃、喝、拉、撒
若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，以下所示：
僞代碼 class 貓： def 喵喵叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something class 狗： def 汪汪叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something
上述代碼不難看出，吃、喝、拉、撒是貓和狗都具備的功能，而咱們卻分別的貓和狗的類中編寫了兩次。若是使用 繼承 的思想，以下實現：
動物：吃、喝、拉、撒
貓：喵喵叫（貓繼承動物的功能）
狗：汪汪叫（狗繼承動物的功能）
僞代碼
class 動物: def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類 class 貓(動物)： def 喵喵叫(self): print '喵喵叫' # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類 class 狗(動物)： def 汪汪叫(self): print '喵喵叫'
代碼實例
class Animal:
def eat(self):
print "%s 吃 " %self.name
def drink(self):
print "%s 喝 " %self.name
def shit(self):
print "%s 拉 " %self.name
def pee(self):
print "%s 撒 " %self.name
class Cat(Animal):
def __init__(self, name):
self.name = name
self.breed ＝ '貓'
def cry(self):
print '喵喵叫'
class Dog(Animal):
def __init__(self, name):
self.name = name
self.breed ＝ '狗'
def cry(self):
print '汪汪叫'
# ######### 執行 #########
c1 = Cat('小白家的小黑貓')
c1.eat()
c2 = Cat('小黑的小白貓')
c2.drink()
d1 = Dog('胖子家的小瘦狗')
d1.eat()
因此，對於面向對象的繼承來講，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而沒必要一一實現每一個方法。
注：除了子類和父類的稱謂，你可能看到過 派生類 和 基類 ，他們與子類和父類只是叫法不一樣而已。
學習了繼承的寫法以後，咱們用代碼來是上述阿貓阿狗的功能：
代碼實例
class Animal:
def eat(self):
print "%s 吃 " %self.name
def drink(self):
print "%s 喝 " %self.name
def shit(self):
print "%s 拉 " %self.name
def pee(self):
print "%s 撒 " %self.name
class Cat(Animal):
def __init__(self, name):
self.name = name
self.breed ＝ '貓'
def cry(self):
print '喵喵叫'
class Dog(Animal):
def __init__(self, name):
self.name = name
self.breed ＝ '狗'
def cry(self):
print '汪汪叫'
# ######### 執行 #########
c1 = Cat('小白家的小黑貓')
c1.eat()
c2 = Cat('小黑的小白貓')
c2.drink()
d1 = Dog('胖子家的小瘦狗')
d1.eat()
那麼問題又來了，多繼承呢？
是否能夠繼承多個類
若是繼承的多個類每一個類中都定了相同的函數，那麼那一個會被使用呢？
一、Python的類能夠繼承多個類，Java和C#中則只能繼承一個類
二、Python的類若是繼承了多個類，那麼其尋找方法的方式有兩種，分別是：深度優先和廣度優先
當類是經典類時，多繼承狀況下，會按照深度優先方式查找
當類是新式類時，多繼承狀況下，會按照廣度優先方式查找
經典類和新式類，從字面上能夠看出一個老一個新，新的必然包含了跟多的功能，也是以後推薦的寫法，從寫法上區分的話，若是 當前類或者父類繼承了object類，那麼該類即是新式類，不然即是經典類。
經典類多繼承 class D: def bar(self): print 'D.bar' class C(D): def bar(self): print 'C.bar' class B(D): def bar(self): print 'B.bar' class A(B, C): def bar(self): print 'A.bar' a = A() # 執行bar方法時 # 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯 # 因此，查找順序：A --> B --> D --> C # 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了 a.bar()
新式類多繼承 class D(object): def bar(self): print 'D.bar' class C(D): def bar(self): print 'C.bar' class B(D): def bar(self): print 'B.bar' class A(B, C): def bar(self): print 'A.bar' a = A() # 執行bar方法時 # 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯 # 因此，查找順序：A --> B --> C --> D # 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了 a.bar()
經典類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯
新式類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯
注意：在上述查找過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
3、多態
Pyhon不支持多態而且也用不到多態，多態的概念是應用於Java和C#這一類強類型語言中，而Python崇尚「鴨子類型」。
Python僞代碼實現Java或C#的多態 class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' # 因爲在Java或C#中定義函數參數時，必須指定參數的類型 # 爲了讓Func函數既能夠執行S1對象的show方法，又能夠執行S2對象的show方法，因此，定義了一個S1和S2類的父類 # 而實際傳入的參數是：S1對象和S2對象 def Func(F1 obj): """Func函數須要接收一個F1類型或者F1子類的類型""" print obj.show() s1_obj = S1() Func(s1_obj) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show s2_obj = S2() Func(s2_obj) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show
ython 「鴨子類型」 class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' def Func(obj): print obj.show() s1_obj = S1() Func(s1_obj) s2_obj = S2() Func(s2_obj)
- 1. 面向對象編程其實很簡單——Python 面向對象（初級篇）
- 2. Python - 面向對象編程 - 初級篇
- 3. 面向對象（初級篇）
- 4. 面向對象初級篇
- 5. Python面向對象初級篇
- 6. Python面向對象（初級篇）
- 7. 【python之路面向對象】初級篇
- 8. Python 面向對象【初級篇】
- 9. Python 面向對象（初級篇）
- 10. python 面向對象編程
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • Github 簡明教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
- 1. 面向對象編程其實很簡單——Python 面向對象（初級篇）
- 2. Python - 面向對象編程 - 初級篇
- 3. 面向對象（初級篇）
- 4. 面向對象初級篇
- 5. Python面向對象初級篇
- 6. Python面向對象（初級篇）
- 7. 【python之路面向對象】初級篇
- 8. Python 面向對象【初級篇】
- 9. Python 面向對象（初級篇）
- 10. python 面向對象編程