python面向對象三大特性

時間 2019-12-01

標籤 python 面向對象三大特性欄目 Python 简体版

原文原文鏈接

面向對象的三大特性: 封裝、繼承和多態編程

1、封裝ide

封裝，顧名思義就是將內容封裝到某個地方，之後能夠直接調用被封裝到某處的內容。
函數式編程

　　- 將內容封裝到某處
函數

　　- 從某處調用被封裝的內容spa

第一步，將內容封裝到某處：code

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
obj1=Foo('梅西','31')
obj2=Foo('C羅','33')
print(obj1.name,obj1.age)
print(obj2.name,obj2.age)

輸出結果：
梅西 31
C羅 33

View Code

self 是一個形式參數, 當執行 obj1=Foo('梅西','31'),self 就等於obj1對象

　　　　　　　　　當執行obj2=Foo('C羅','33'),self就等於obj2blog

第二部,從某處調用被封裝的內容:繼承

　　- 經過對象直接調用it

　　- 同過self間接調用

1,經過對象直接調用被封裝的內容(格式:對象.屬性名)

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
obj1=Foo('梅西','31')
print(obj1.name)      #直接調用obj1的name屬性
print(obj1.age)         #直接調用obj1的age屬性

obj2=Foo('C羅','33')
print(obj2.name)     #直接調用obj2的name屬性
print(obj2.age)        #直接調用obj2的age屬性

View Code

2,執行類中的方法時，經過 self 間接調用被封裝的內容：

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def detail(self):
        print(self.name,self.age)

obj1=Foo('梅西','31')
obj1.detail()

obj2=Foo('C羅','33')
obj2.detail()

>>>
梅西 31
C羅 33

View Code

綜上所述,對於面向對象的封裝來講,其實就是使用構造方法將內容封裝到對象中,而後經過對象直接或self間接獲取被封裝的內容。

練習一：在終端輸出以下信息

小明，10歲，男，上山去砍柴
小明，10歲，男，開車去東北
小明，10歲，男，最愛大保健
老李，90歲，男，上山去砍柴
老李，90歲，男，開車去東北
老李，90歲，男，最愛大保健
老張...

函數式

面向對象

上述對比能夠看出，若是使用函數式編程，須要在每次執行函數時傳入相同的參數，若是參數多的話......

面向對象只須要在建立對象時,將所須要的參數封裝到對象中,以後使用時,經過self間接去對象中取值便可。

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

View Code

上述代碼能夠看出，吃喝拉撒是貓和狗都具備的功能，而咱們卻分別爲貓和狗的類中編寫了兩次，若是使用繼承的思想，以下實現：

動物：吃、喝、拉、撒

　　貓：喵喵叫、（貓繼承動物的功能）

　　狗：汪汪叫、（狗繼承動物的功能）

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()

View Code

因此對於面向對象的繼承來講，其實就是將多個類中共有的方法提取到父類中，子類繼承父類，而沒必要一一實現每一個方法。

注：除了子類和父類的稱謂，也能夠叫他們派生類和基類。

-- 多繼承

一、Python的類能夠繼承多個類，Java和C#中則只能繼承一個類

二、Python的類若是繼承了多個類，那麼其尋找方法的方式有兩種，分別是：深度優先和廣度優先

繼承順序

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

3、多態

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

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(arg):
    """Func函數須要接收一個F1類型或者F1子類的類型"""

    arg.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