Python - 面對對象(基礎)

目錄

• Python - 面對對象(基礎)
  • 一. 概述
  • 二. 建立類和對象
  • 三. 面向對象三大特徵
    • 封裝
    • 繼承
    • 多態

Python - 面對對象(基礎)

一. 概述

• 面向過程：根據業務邏輯從上到下寫壘代碼

• 函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可

• 面向對象：對函數進行分類和封裝，讓開發「更快更好更強...」

面向過程編程(Object Oriented Programming，OOP，面向對象程序設計) 最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。

二. 建立類和對象

面向對象編程是一種編程方式，此編程方式的落地須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。

類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能

對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數

class是關鍵字，表示類

建立對象，類名稱後加括號便可

類中的函數第一個參數必須是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方法

三. 面向對象三大特徵

封裝

第一步: 將內容封裝到某處

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間接獲取被封裝的內容.

練習：遊戲人生程序

一、建立三個遊戲人物，分別是：

蒼井井，女，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()

繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。

例如：

　　貓能夠：喵喵叫、吃、喝、拉、撒

　　狗能夠：汪汪叫、吃、喝、拉、撒

若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，以下所示：

僞代碼

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 '汪汪叫'
    

# ######### 執行 #########

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類中找，若是仍是未找到，則報錯

注意：在上述查找過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了

多態

Pyhon不支持Java和C#這一類強類型語言中多態的寫法，可是原生多態，其Python崇尚「鴨子類型」。

Python僞代碼實現Jave或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

Python "鴨子類型"

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)