2. 程式人生 > >面向對象三大特性——封裝（含property）

面向對象三大特性——封裝（含property）

阿新 • • 發佈：2018-04-24
普通 金額 訪問 控制 instance @property 進行 安全 AI

　　封裝是面向對象的特征之一，是對象和類概念的主要特性。

封裝概念

　　封裝就是把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏。

隱藏屬性

　　在python中用雙下劃線開頭的方式將屬性隱藏起來（設置成私有的）

　　其實這僅僅這是一種變形操作，類中所有雙下劃線開頭的名稱如__x都會自動變形成：_類名__x的形式。

class A:
    __x = 1  # _A__x = 1

    def __init__(self, name):
        self.__name = name  # self._A__name=‘egon‘
 


    def __foo(self):   # _A__foo
        print(‘%s foo run‘ % self.__name)

    def bar(self):
        self.__foo()  # self._A__foo()
        print(‘from bar‘)

# 無法找到類的屬性和函數：
# print(A.__x)
# print(A.__foo)

print(A.__dict__)   # 可以查看到_A__foo;bar這兩個函數
# 輸出：{‘__module__‘: ‘__main__‘, ‘_A__x‘: 1, ‘__init__‘: <function A.__init__ at 0x101f211e0>, ‘_A__foo‘: <function A.__foo at 0x101f21378>, ‘bar‘: <function A.bar at 0x101f212f0>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘A‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘A‘ objects>, ‘__doc__‘: None}
 


a = A(‘egon‘)
a._A__foo()  # 通過這種方式可以訪問類隱藏函數
# 輸出：egon foo run
a.bar()
"""
egon foo run
from bar
"""

　　可以看到類的屬性和函數在前面加‘__‘，在類定義階段就發生了變形，變形後在外部就無法通過.__x或.__func來調用。

這種自動變形的特點

　　1、類中定義的__x只能在內部使用，如self.__x，引用的就是變形的結果。

　　2、這種變形其實正是針對外部的變形，在外部是無法通過__x這個名字訪問到的。

　　3、在子類定義的__x不會覆蓋在父類定義的__x，因為子類中變形成了：_子類名__x,而父類中變形成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是無法覆蓋的。

class Foo:
    def __func(self):   # _Foo_func
        print(‘from foo‘)


class Bar(Foo):
    def __func(self):   # _Bar__func
        print(‘from bar‘)
        
b = Bar()
# b.func()   # AttributeError：沒有這個屬性
b._Bar__func()  # 輸出：from bar

變形需要註意的問題

　　1、知道了類名和屬性名就可以拼出名字：_類名__屬性，然後就可以訪問了

class B:
    __x = 1

    def __init__(self, name):
        self.__name = name

print(B._B__x)
"""
1
"""

　　2、變形的過程只在類的定義時發生一次，定義後的賦值操作，不會變形

>>> class A:
...     def __init__(self):
...             self.__X=10
... 
>>> a=A()
>>> a.__dict__
{‘_A__X‘: 10}
>>> a.__Y=2131
>>> a.__dict__
{‘_A__X‘: 10, ‘__Y‘: 2131}    # __Y沒有變形

　　3、在繼承中，父類如果不想讓子類覆蓋自己的方法，可以將方法定義為私有的

class A:
    def __foo(self):  # _A__foo
        print(‘A foo‘)

    def bar(self):
        print(‘A.bar‘)
        self.__foo()  # self._A__foo()

class B(A):
    def __foo(self):  # _B__foo
        print(‘B.foo‘)

b = B()
b.bar()
"""
A.bar
A foo  # 只在自己類找方法不去其他類查找，子類不覆蓋父類方法
"""
技術分享圖片 
#正常情況
>>> class A:
...     def fa(self):
...         print(‘from A‘)
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print(‘from B‘)
... 
>>> b=B()
>>> b.test()
from B


#把fa定義成私有的，即__fa
>>> class A:
...     def __fa(self): #在定義時就變形為_A__fa
...         print(‘from A‘)
...     def test(self):
...         self.__fa() #只會與自己所在的類為準,即調用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print(‘from B‘)
... 
>>> b=B()
>>> b.test()
from A
方法私有的情況

封裝的意義

　　封裝不是單純意義的隱藏

一、封裝數據屬性

　　將數據隱藏起來這不是目的。隱藏起來然後對外提供操作該數據的接口，然後我們可以在接口附加上對該數據操作的限制，以此完成對數據屬性操作的嚴格控制。

提示：在編程語言裏，對外提供的接口（接口可理解為了一個入口），可以是函數，稱為接口函數，這與接口的概念還不一樣，接口代表一組接口函數的集合體。

技術分享圖片 
class People:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def tell_info(self):
        print(‘Name:<%s> Age:<%s>‘ % (self.__name, self.__age))

    def set_info(self, name, age):
        if not isinstance(name, str):
            print(‘名字必須是字符串類型‘)
            return
        if not isinstance(age, int):
            print(‘年齡必須是數字類型‘)
            return
        self.__name = name
        self.__age = age


p = People(‘egon‘, 18)

# p.tell_info()
"""
Name:<egon> Age:<18>  # 封裝數據，開放接口給外部訪問
"""

# p.set_info(‘Egon‘, 38) # 修改數據只能通過接口來完成，可以通過接口完成各種限制
# p.tell_info()
"""
Name:<Egon> Age:<38>
"""

# p.set_info(123, 38)
"""
名字必須是字符串類型
"""
p.set_info(‘egon‘, ‘38‘)
p.tell_info()
"""
年齡必須是數字類型
Name:<egon> Age:<18>
"""
封裝數據屬性

二、封裝方法

　　隔離復雜度。

技術分享圖片 
class ATM:
    def __card(self):
        print(‘插卡‘)
    def __auth(self):
        print(‘輸入取款金額‘)
    def __input(self):
        print(‘輸入取款金額‘)
    def __print_bill(self):
        print(‘打印賬單‘)
    def __take_money(self):
        print(‘取款‘)

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()


a = ATM()
a.withdraw()
"""
插卡
輸入取款金額
輸入取款金額
打印賬單
取款
"""
封裝方法

　　由上例可以看到，取款是功能,而這個功能有很多功能組成:插卡、密碼認證、輸入金額、打印賬單、取錢；對使用者來說,只需要知道取款這個功能即可,其余功能我們都可以隱藏起來,很明顯這麽做隔離了復雜度,同時也提升了安全性

封裝和擴展性

　　封裝在於明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。

class Room:
    def __init__(self, name, owner, weight, length, height):
        self.name = name
        self.owner = owner

        self.__weight = weight
        self.__length = length
        self.__height = height

    def tell_area(self):
        return self.__weight * self.__length


r = Room(‘衛生間‘, ‘alex‘, 10, 10, 10)

print(r.tell_area())  # 不管是求面積還是體積，用戶調用的方式不變

　　由上例可以看出，只要接口這個基礎約定不變，就不用擔心代碼的改動。

技術分享圖片 
#類的設計者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏了內部的實現細節，此時我們想求的是面積
        return self.__width * self.__length


#使用者
>>> r1=Room(‘臥室‘,‘egon‘,20,20,20)
>>> r1.tell_area() #使用者調用接口tell_area


#類的設計者，輕松的擴展了功能，而類的使用者完全不需要改變自己的代碼
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏內部實現，此時我們想求的是體積,內部邏輯變了,只需求修該下列一行就可以很簡答的實現,而且外部調用感知不到,仍然使用該方法，但是功能已經變了
        return self.__width * self.__length * self.__high


#對於仍然在使用tell_area接口的人來說，根本無需改動自己的代碼，就可以用上新功能
>>> r1.tell_area()
封裝與擴展

特性（property）

property概念

　　property是一種特殊的屬性，訪問它時會執行一段功能（函數）然後返回值。

　　下面以計算BMI指數為例：（bmi是計算而來的，但很明顯它聽起來像是一個屬性而非方法，如果我們將其做成一個屬性，更便於理解）

　　BMI指數：（BMI是計算而來的，很明顯它聽起來像一個屬性而非方法，如果我們將其作為一個屬性，更便於理解）
　　成人的BMI數值：
　　過輕：低於18.5
　　正常：18.5-23.9
　　過重：24-27
　　肥胖：28-32
　　非常肥胖：高於32
　　體質指數（BMI）= 體重（KG）/ 身高^2（M）
　　EX：70KG / (1.75*1.75) = 22.86

方法一：普通解決辦法

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

p = People(‘jack‘, 48, 1.65)
p.bmi = p.weight / (p.height ** 2)

print(p.bmi)
"""
17.63085399449036
egon
dragon
名字必須是字符串類型
dragon
不允許刪除
"""

方法二：添加函數改寫

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    def bmi(self):
        print(‘===>‘)
        return self.weight / (self.height ** 2)

p = People(‘SH‘, 53, 1.70)
print(p.bmi())  # bmi是一個名詞，卻使用bmi()，容易誤解為一個動作

方法三：添加property裝飾器

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    @property    # 應用場景：有一個值是通過計算得來的，首選定義方法，運用property讓使用者感知不到
    def bmi(self):
        print(‘===>‘)
        return self.weight / (self.height ** 2)  # 必須有返回值

p = People(‘SH‘, 53, 1.70)
print(p.bmi)   # 使用者像訪問數據屬性一樣訪問bmi，方法被偽裝
"""
===>
18.339100346020764
"""
p.height = 1.82
print(p.bmi)
"""
===>
16.000483033450067
"""
p.bmi = 333  # 報錯，看起來像數據屬性，其實還是一個方法，不能賦值

property好處

　　將一個類的函數定義成特性以後，對象再去使用的時候obj.name,根本無法察覺自己的name是執行了一個函數然後計算出來的，這種特性的使用方式遵循了統一訪問的原則。總結來說：把一些計算得到的屬性偽裝得像數據屬性一樣被用戶訪問。

property其他用法（set\get\delete方法）

　　在C++裏一般會將所有的所有的數據都設置為私有的，然後提供set和get方法（接口）。Python中通過property來實現這個功能：

class People:
    def __init__(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

p = People(‘egon‘)
print(p.get_name())  # 輸出：egon

　　在上面的代碼中，People的name屬性被封裝，不能直接訪問，因此給類添加了一個get_name()方法來查看內部已經封裝的屬性。

　　但是這種這種情況下，用戶的屬性調用方式發生了改變。可以通過@property解決該問題。

class People:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

p = People(‘egon‘)
print(p.name)   # 輸出：egon

　　調用方式已經和普通屬性相同，但是在上面bmi的代碼中可以看到，這種情況下是不能對隱藏屬性賦值的。要實現賦值，需要運用@name.setter裝飾器(name被property裝飾後才可用)進行如下修改：

class People:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        # print(‘getter‘)
        return self.__name

    @name.setter
    def name(self, val):
        # print(‘setter‘, val)
        if not isinstance(val, str):
            print(‘名字必須是字符串類型‘)
            return
        self.__name=val

    @name.deleter
    def name(self):
        # print(‘deleter‘)
        print(‘不允許刪除‘)

p = People(‘egon‘)
print(p.name)    # 輸出：egon
p.name = ‘dragon‘
print(p.name)   # 輸出：dragon  # name修改成功

p.name = 123   # 輸出：名字必須是字符串類型（報錯）
print(p.name)  # 輸出：dragon

del p.name  # 輸出：不允許刪除（報錯）

　　如代碼所示，實現了name屬性的修改和刪除，@name.deleter和@name.setter都是基於name被@property裝飾才可用的。

面向對象三大特性——封裝（含property）

相關推薦

面向對象三大特性——封裝（含property）

普通 金額 訪問 控制 instance @property 進行 安全 AI 　　封裝是面向對象的特征之一，是對象和類概念的主要特性。 封裝概念 　　封裝就是把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏。 隱

python全棧開發【第十五篇】面向對象三大特性——封裝

inf delete 面向對象 修改 turn 外部 clas fun 內部 1.封裝： 什麽是封裝呢？（封裝不是單純意義的隱藏，其實它還是可以查看的） 　　就是把一些不想讓別人看的給隱藏起來了 封裝數據：目的是保護隱私 功能封裝：目的是隔離復雜度 如果用了私有的，在類的外

面向對象三大特性: 封裝

界面 內部 我們 summary 特性 .sh 不同 更改 要點 封裝 封裝：每個對象都包含有它能進行操作的所有信息，這個特性稱為封裝。這樣的方法包含在類中，通過類的實例來實現。 e.g. 我們可以使用遙控器。 遙控器有多個功能 封裝的優點 A.良好的封裝能夠減少耦合（比如

JAVA基礎——面向對象三大特性：封裝、繼承、多態

code bool anim 進行 print 方式 補充 信息 多態 JAVA面向對象三大特性詳解 一、封裝 　　1、概念： 　　　　將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問。 　　2、好處： 　　　只能通

C# 面向對象三大特性：封裝、繼承、多態

耦合 tar for rime str strong rim sum 實現 面向對象有封裝、繼承、多態這三個特性，面向對象編程按照現實世界的特點來管理復雜的事物，把它們抽象為對象，具有自己的狀態和行為，通過對消息的反應來完成任務。這種編程方法提供了非常強大的多樣性，大大增

java面向對象三大特性之封裝

javase封裝 其實以前一直在做Java開發的過程中或者剛開始初學的時候沒有想那麽多，都是單純的一直去做，但是自從做了某個項目之後也慢慢發現很多時候，人的精力和腦力是有限的，總是會忘記以前做過或者學過的東西，慢慢就開始了寫博客的習慣，一是可以自己加強一下，二是可以分享給別人可以和大家一起討論一下，因為每個人

面向對象三大特性之一-------封裝的意義

現實 block 電腦 升級 以及 申請 沒有 功能性 地理 思考 封裝的意義： 封裝從形式上來說，它將數據和操作界定在了某個圈子內，如果外界想要訪問數據，或者使用某個操作，必須通過特殊的手段向這個圈子申請。 這個圈子便是類，特殊的手段就是接口。 即假如外界想要訪問類中的數

python面向對象三大特性之一封裝

pac 修改 不變 containe erro delet 異常 內部 自己的 一、什麽是封裝 　　在程序設計中，封裝（Encapsulation）是對具體對象的一種抽象，即將某些部分隱藏起來，在程序外部看不到，其 含義是其他程序無法調用。 　　要了解封裝，離不開&l

java面向對象三大特性：封裝、繼承、多態

傳遞 大於 精確 沒有 left 返回值 數據 public 對象引用 一、封裝 封裝也稱信息隱藏，是指利用抽象數據類型把數據和基於數據的操作封裝起來，使其成為一個不可分割的整體，數據隱藏在抽象數據內部，盡可能的隱藏數據細節，只保留一些接口使其與外界發生聯系。也就是說用戶

十二、面向對象三大特性：繼承、封裝、多態

ini 子類 span 特性 code color alex pan div 一、繼承 　　python中的繼承分為：單繼承、多繼承 class P1: pass class P2: pass class Son1(P1):

python學習_day24_面向對象三大特性之繼承

wan 桌子 python super 特性 sub zhong 多重 family 一、繼承的定義 　　繼承在python中是創建一種新類的方法，新建的類可以繼承一個或者多個父類，其中父類稱為超類或者基類，新建的類稱為派生類或者子類。繼承表達的是什麽是什麽的關系，如：高桌

面向對象三大特性總結

不同 另一個 世界 代碼 如果 面向 獲取 隱藏對象 例如 封裝： 　　概念: 　　指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。 　　好處: 　　* 隱藏實現細節，提供公共的訪問方式 　　* 提高了代碼的復用性 　　* 提高安全性。 　　原則: 　　* 將不需要對外

面向對象三大特性

組件 python3 處理 提高 方法 直接 使用實例 方法名 nbsp 面向對象三大特性 一、繼承 1、定義： 繼承是一種創建新類的方式，在python中新建的類可以繼承一個或多個父類，父類又可稱為基類或超類，新建的類稱為派生類或子類 2、繼承的使用場景：什麽是什麽

二 面向對象三大特性

代碼 重用 派生 多態性 tcl pytho bsp 單繼承 pan 一 繼承與派生 　　一、繼承定義 　　二、繼承與抽象的關系 　　三、繼承與重用性 　　四、派生 　　五、組合與重用性 　　六、接口與歸一化設計 　　七、抽象類 　　八、繼承實現的原理 　

python全棧開發【第十四篇】面向對象三大特性——繼承

blog area ear person subclass rom from 指定 實現 一、組合 組合：組合指的是，在一個類中以另外一個類的對象（也就是實例）作為數據屬性，稱為類的組合 　　　也就是說：一個類的屬性是另一個類的對象，就是組合 例子： 　　圓環是由兩個圓組成

python全棧開發【第十六篇】面向對象三大特性——多臺和繼承補充

全棧 space 其他 到你 使用 方法名 調用父類 大眾 chat 一、回顧 面向對象 　　1.類：具有相同屬性和方法 的一類事物 　　　　　類名可以實例化一個對象 　　　　　類名可以調用類屬性，（靜態屬性 和（方法）動態屬性） 　　2.對象：也就是實例 　　　　

python面向對象三大特性之繼承、多態

nim 類的屬性 pri dog name 復用性 繼承 python2 調用方法 繼承 什麽是繼承 　 　　所謂繼承指提供了同一類對象共性的處理方法，子類繼承父類共性的東西。 這樣有利於代碼的復用性，即子類擁有父類的方法。通過繼承創建的新類稱為“子類”或“

Python()- 面向對象三大特性----繼承

obj kit 當前 酷狗 子類 jin 但是 init 情況下 繼承: 繼承是一種創建新類的方式，在python中，新建的類可以繼承一個或多個父類(基類或超類)，新建的類是所繼承的類的(派生類或子類) 人類和狗 有相同的屬性, 提取了一個__init__方法,在這個方法裏

Java——面向對象三大特性

分別是 rac 操作 動物 extends 影響 多個 super關鍵字 super java是一門純面向對象的程序設計語言，它具有三大特性，分別是封裝，繼承和多態。 一、封裝 　　封裝，就是將對象的屬性和方法封裝起來，使用戶知道對象提供的屬性和方法，而不必去探究它的內部實

面向對象三大特性五大原則

應該 軟件工程 如果 obj idt AS close 抽象 無需 　　面向對象(Object Oriented,OO)是軟件開發方法。面向對象的概念和應用已超越了程序設計和軟件開發，擴展到如數據庫系統、交互式界面、應用結構、應用平臺、分布式系統、網絡管理結構、CAD技術、