2. 程式人生 > >Python面向對象之：三大特性：繼承，封裝，多態。

Python面向對象之：三大特性：繼承，封裝，多態。

阿新 • • 發佈：2019-01-26
為什麽 打包 alex pytho 耦合性 per contain x11 順序

前言：

python面向對象的三大特性：繼承，封裝，多態。

1. 封裝: 把很多數據封裝到?個對象中. 把固定功能的代碼封裝到?個代碼塊, 函數, 對象, 打包成模塊. 這都屬於封裝的思想. 具體的情況具體分析. 比如. 你寫了?個很?B的函數. 那這個也可以被稱為封裝. 在?向對象思想中. 是把?些看似?關緊要的內容組合到?起統?進?存儲和使?. 這就是封裝.

2. 繼承: ?類可以?動擁有?類中除了私有屬性外的其他所有內容. 說?了, ??可以隨便?爹的東?. 但是朋友們, ?定要認清楚?個事情. 必須先有爹, 後有??. 順序不能亂, 在python中實現繼承非常簡單. 在聲明類的時候, 在類名後?添加?個?括號,就可以完成繼承關系. 那麽什麽情況可以使?繼承呢? 單純的從代碼層?上來看. 兩個類具有相同的功能或者特征的時候. 可以采?繼承的形式. 提取?個?類, 這個?類中編寫著兩個類相同的部分. 然後兩個類分別取繼承這個類就可以了. 這樣寫的好處是我們可以避免寫很多重復的功能和代碼. 如果從語義中去分析的話. 會簡單很多. 如果語境中出現了x是?種y. 這時, y是?種泛化的概念. x比y更加具體. 那這時x就是y的?類. 比如. 貓是?種動物. 貓繼承動物. 動物能動. 貓也能動. 這時貓在創建的時候就有了動物的"動"這個屬性. 再比如, ?骨精是?個妖怪. 妖怪天?就有?個比較不好的功能叫"吃?", ?骨精?出?就知道如何"吃?". 此時 ?骨精繼承妖精.

3. 多態: 同?個對象, 多種形態. 這個在python中其實是很不容易說明?的. 因為我們?直在?. 只是沒有具體的說. 比如. 我們創建?個變量a = 10 , 我們知道此時a是整數類型. 但是我們可以通過程序讓a = "alex", 這時, a?變成了字符串類型. 這是我們都知道的. 但是, 我要告訴你的是. 這個就是多態性. 同?個變量a可以是多種形態。

一 封裝

封裝，顧名思義就是將內容封裝到某個地方，以後再去調用被封裝在某處的內容。

所以，在使用面向對象的封裝特性時，需要：

  • 將內容封裝到某處
  • 從某處調用被封裝的內容

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

技術分享圖片

self 是一個形式參數，當執行 obj1 = Foo(‘wupeiqi‘, 18 ) 時，self 等於 obj1

當執行 obj2 = Foo(‘alex‘, 78 ) 時，self 等於 obj2

所以，內容其實被封裝到了對象 obj1 和 obj2 中，每個對象中都有 name 和 age 屬性，在內存裏類似於下圖來保存。

技術分享圖片

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種情況：

  • 通過對象直接調用
  • 通過self間接調用

1、通過對象直接調用被封裝的內容

上圖展示了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式可以如此調用被封裝的內容：對象.屬性名

1 2 3 4 5 6 7 8 9 10 11 12 13 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屬性

2、通過self間接調用被封裝的內容

執行類中的方法時，需要通過self間接調用被封裝的內容

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 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間接獲取被封裝的內容。

二 多態

多態，同一個對象，多種形態。python默認支持多態。

# 在java或者c#定義變量或者給函數傳值必須定義數據類型，否則就報錯。

def func(int a):
print(‘a必須是數字‘)

# 而類似於python這種弱定義類語言,a可以是任意形態（str,int,object等等）。
def func(a):
print(‘a是什麽都可以‘)

# 再比如：
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偽代碼實現Java或C # 的多態 python中有一句諺語說的好，你看起來像鴨子，那麽你就是鴨子。
對於代碼上的解釋其實很簡答：
class A:
def f1(self):
print(‘in A f1‘)

def f2(self):
print(‘in A f2‘)


class B:
def f1(self):
print(‘in A f1‘)

def f2(self):
print(‘in A f2‘)

obj = A()
obj.f1()
obj.f2()

obj2 = B()
obj2.f1()
obj2.f2()
# A 和 B兩個類完全沒有耦合性，但是在某種意義上他們卻統一了一個標準。
# 對相同的功能設定了相同的名字，這樣方便開發，這兩個方法就可以互成為鴨子類型。

# 這樣的例子比比皆是：str tuple list 都有 index方法，這就是統一了規範。
# str bytes 等等 這就是互稱為鴨子類型。

三 類的約束

?先, 你要清楚. 約束是對類的約束.

用一個例子說話：

公司讓小明給他們的網站完善一個支付功能，小明寫了兩個類，如下：

技術分享圖片 
class QQpay:
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay:
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

a = Alipay()
a.pay(100)

b = QQpay()
b.pay(200)
技術分享圖片

但是上面這樣寫不太放方便，也不合理，老大說讓他整改，統一一下付款的方式，小明開始加班整理：

技術分享圖片 
class QQpay:
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay:
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

def pay(obj,money):  # 這個函數就是統一支付規則，這個叫做： 歸一化設計。
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)
技術分享圖片

寫了半年的接口，小明終於接了大項目了，結果公司沒品位，招了一個野生的程序員春哥接替小明的工作，老大給春哥安排了任務，讓他寫一個微信支付的功能：

技術分享圖片 
class QQpay:
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay:
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

class Wechatpay:  # 野生程序員一般不會看別人怎麽寫，自己才是最好，結果......
    def fuqian(self,money):
        print(‘使用微信支付%s元‘ % money)

def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)

c = Wechatpay()
c.fuqian(300)
技術分享圖片

結果春哥，受懲罰了，限期整改，那麽春哥，發奮圖強，看了太白教你學python的相關資料，重新梳理的代碼：

技術分享圖片 
class Payment: 
　　""" 此類什麽都不做，就是制定一個標準，誰繼承我，必須定義我裏面的方法。
   """
    def pay(self,money):pass

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay(Payment):
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print(‘使用微信支付%s元‘ % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)

c = Wechatpay()
c.fuqian(300)
技術分享圖片

但是，這樣還會有問題，如果再來野生程序員，他不看其他的支付方式，也不知道為什麽繼承的類中要定義一個沒有意義的方法，所以他會是會我行我素：

技術分享圖片 
class Payment: 
　　""" 此類什麽都不做，就是制定一個標準，誰繼承我，必須定義我裏面的方法。
   """
    def pay(self,money):pass

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay(Payment):
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print(‘使用微信支付%s元‘ % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)

c = Wechatpay()
c.fuqian(300)
技術分享圖片

所以此時我們要用到對類的約束，對類的約束有兩種：

1. 提取?類. 然後在?類中定義好?法. 在這個?法中什麽都不??. 就拋?個異常就可以了. 這樣所有的?類都必須重寫這個?法. 否則. 訪問的時候就會報錯.

2. 使?元類來描述?類. 在元類中給出?個抽象?法. 這樣?類就不得不給出抽象?法的具體實現. 也可以起到約束的效果.

先用第一種方式解決：

技術分享圖片 
class Payment:
    """
    此類什麽都不做，就是制定一個標準，誰繼承我，必須定義我裏面的方法。
    """
    def pay(self,money):
        raise Exception("你沒有實現pay方法")

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付%s元‘ % money)

class Alipay(Payment):
    def pay(self,money):
        print(‘使用阿裏支付%s元‘ % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print(‘使用微信支付%s元‘ % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)
技術分享圖片

第二種方式：引入抽象類的概念處理。

技術分享圖片 
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    # 抽象類 接口類  規範和約束  metaclass指定的是一個元類
    @abstractmethod
    def pay(self):pass  # 抽象方法

class Alipay(Payment):
    def pay(self,money):
        print(‘使用支付寶支付了%s元‘%money)

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付了%s元‘%money)

class Wechatpay(Payment):
    # def pay(self,money):
    #     print(‘使用微信支付了%s元‘%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 歸一化設計：不管是哪一個類的對象，都調用同一個函數去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的時候才會報錯



# 抽象類和接口類做的事情 ：建立規範
# 制定一個類的metaclass是ABCMeta，
# 那麽這個類就變成了一個抽象類(接口類)
# 這個類的主要功能就是建立一個規範
技術分享圖片

總結: 約束. 其實就是?類對?類進?約束. ?類必須要寫xxx?法. 在python中約束的?式和?法有兩種:

1. 使?抽象類和抽象?法, 由於該?案來源是java和c#. 所以使?頻率還是很少的

2. 使??為拋出異常的?案. 並且盡量拋出的是NotImplementError. 這樣比較專業, ?且錯誤比較明確.(推薦)

四. super()深入了解

super是嚴格按照類的繼承順序執行！！！

class A:
def f1(self):
print(‘in A f1‘)

def f2(self):
print(‘in A f2‘)


class Foo(A):
def f1(self):
super().f2()
print(‘in A Foo‘)


obj = Foo()
obj.f1() class A:
def f1(self):
print(‘in A‘)

class Foo(A):
def f1(self):
super().f1()
print(‘in Foo‘)

class Bar(A):
def f1(self):
print(‘in Bar‘)

class Info(Foo,Bar):
def f1(self):
super().f1()
print(‘in Info f1‘)

obj = Info()
obj.f1()

‘‘‘
in Bar
in Foo
in Info f1
‘‘‘
print(Info.mro()) # [<class ‘__main__.Info‘>, <class ‘__main__.Foo‘>, <class ‘__main__.Bar‘>, <class ‘__main__.A‘>, <class ‘object‘>]

不是底

Python面向對象之：三大特性：繼承，封裝，多態。

相關推薦

Python面向對象之：三大特性：繼承，封裝，多態。

為什麽 打包 alex pytho 耦合性 per contain x11 順序 前言： python面向對象的三大特性：繼承，封裝，多態。 1. 封裝: 把很多數據封裝到?個對象中. 把固定功能的代碼封裝到?個代碼塊, 函數, 對象, 打包成模塊. 這都屬於封裝的思想.

python面向對象之 封裝（Day25）

imp disco font 使用 ati 所有 下劃線 error: 無法 封裝： 　　隱藏對象的屬性和實現細節，僅對外提供公共訪問方式 好處：1.將變化隔離 　　　2.便於使用 　　　3.提高復用性 　　　4.提高安全性 封裝原則： 　　　1.將不需要對外提供的內容隱藏

Python 面向對象之高級編程

sel turn 直接 item imp metaclass slots 屬性和方法 __slots__ 7.面向對象高級編程 7.1使用__slots__ python動態語言，new 對象後綁定屬性和方法 Tip:給一個實例綁定的方法，對其他對象無效。可以通過對clas

Python--面向對象之封裝

自己的 一次 嚴格 類的設計 ise 三種方式 無需 mon cache 一、引子 從封裝本身的意思去解釋，封裝好像是拿來一個麻袋，把小貓，小狗，小王八，還有alex一起裝進麻袋，然後吧麻袋封上口子。照這種邏輯看，封裝=‘隱藏’，這種理解是相當片面的 二、先看如何隱藏 在p

Python面向對象之異常處理

host clas var traceback 垃圾回收 str 語法錯誤 except 編碼 1：什麽是異常 　　異常就是在我們的程序在運行過程中由於某種錯誤而引發Python拋出的錯誤： 　　異常就是程序運行時發生錯誤的信號（在程序出現錯誤時，則會產生一個異常，若程

Java面向對象概述和三大特性

obi bcf 類對象 編譯 開發者 set 包含 parent 默認 　　Java 是面向對象的高級編程語言，類和對象是 Java 程序的構成核心。圍繞著 Java 類和 Java 對象，有三大基本特性：封裝是 Java 類的編寫規範、繼承是類與類之間聯系的一種形式、

Python面向對象之運算符重載

Python 面向對象 運算符重載 運算符重載只是意味著在類方法中攔截內置的操作，也就是說當類的實例出現在內置操作中，Python自動調用我們的方法，並且我們的方法的返回值變成了相應操作的結果。 關於重載的關鍵知識點： 運算符重載讓類攔截常規的Python運算 類可重載所有Python表達式運

Python面向對象之-對象可視化

Python 對象可視化 繼續前面的例子：http://blog.51cto.com/lavenliu/2126344 看前面的復數的例子，這裏增加__str__屬性， class Complex: def __init__(self, real, imag): self.re

Python面向對象之繼承

main __init__ argv .com 實例 obj 對象 name 經典 繼承： 單繼承和多繼承 1.初識 class Father(object): #如果不寫object默認繼承 pass class Son(Father): #括號裏面的

Python面向對象之結構與成員

bim 使用 person %s 成員 分析 true main sel 1.面向對象結構分析： ----面相對象整體大致分為兩塊區域： --------第一部分：靜態字段（靜態變量）部分 --------第二部分：方法部分 --每個大區域可以分為多個小部分： class

python 面向對象之路 方法和函數 反射

ron 創建 print sub *args port style 被調用 pre 一. isinstance(檢查第一個參數是否是第二個參數的 子子孫孫類) class Base(object): pass

Python面向對象之反射

被調用 img count bsp python面向對 pre python true 類方法 一、補充： @classmethod 整個方法中沒有用到對象命名空間中的名字，且用到了類的命名空間中的名字（普通方法和屬性property除外） 類方法的默認參數：cls 調用這

Python-面向對象之單繼承

調用父類 屬性和方法 ati 效果 from borde 支持 對象 實例 、基本概念 　　面向對象三要素之一：繼承inheritance 　　繼承表達式：class Cat(Anaimal),繼承可以讓子類從父類獲取特征（屬性和方法） 　　父類：Anaimal 就是Cat

Python-面向對象之property裝飾器的實現（數據描述器）

裝飾 直接 ret png Owner data 修改 ins turn 參考代碼： 1 from functools import partial 2 3 class Property: # 數據描述符 4 def __init__(self

Python面向對象之靜態方法和類方法

pac local 面向對象語言 borde border time cme def 靜態方法 常規的類定義中，所有函數都被假定在實例上操作，該實例總是作為第一個參數self傳遞。但還有可以定義兩種常見的方法。 靜態方法是一種普通函數，它不會對任何實例類型進行操作。使用@s

python面向對象之靜態屬性/靜態方法/類方法/組合

int html pan 定義 都是 itl 接口繼承 操作 icm #!/usr/bin/env python # coding:utf-8 class Campus: def __init__(self,name,addr,type): s

python面向對象之成員

code 聲明 函數 兩個 method 公開 init property 結果 成員在類中寫的所有內容都是類的成員變量實例變量: 由對象去訪問的變量 class Person: def __init__(self,name,birth): sel

python面向對象之命名空間及組合

name 命名 ice ssi style teacher self. 一個 空間 命名空間 類的靜態屬性不能通過__dic__方法進行修改，但是可以通過 類名.屬性的方式修改 class Course: # 定義了一個課程類 language

Python面向對象之-反射

int pri 反射 color ini 返回 pre getattr del Python中一切皆對象，在Python中的反射：通過字符串的形式操作對象的屬性 hasattr 判斷是否有改屬性或者方法，有返回True,沒有返回false getattr 如果是屬性獲

Python面向對象之魔術方法

賦值 添加屬性 single 釋放 都是 lse let for 語言 __str__ 改變對象的字符串顯示。可以理解為使用print函數打印一個對象時，會自動調用對象的__str__方法 class Student: def __init__(self,