一 引子

从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。在面向对象中，麻袋就是你的类或者对象，类或者对象这俩麻袋内部装有数据属性和函数属性。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的。

封装的本质是要明确地区分内外。是的类实现者可以修改封装内的东西而不影响外部调用者；而外部调用者也可以知道自己不可以碰哪里，从而提供了一个良好的合作基础。只要接口这个基础约定不变，则代码改变不足为虑。

二 先看如何隐藏

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式：
#因此外部还是可以访问到重命名后的class A:__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__Ndef __init__(self):self.__X=10 #变形为self._A__Xdef __foo(self): #变形为_A__fooprint('from A')def bar(self):self.__foo() #只有在类内部才可以通过__foo的形式访问到.#这种，在外部是无法通过__x这个名字访问到。
#但可以通过 obj._A__N是可以访问到的。

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。

2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形

对于两种不同的编码约定（单下划线和双下划线）来命名私有属性的选用：

（1）非公共名称以单下划线开头

（2）若代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划綫

3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

 View Code

三 封装不是单纯意义的隐藏

封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，那这么做的意义何在？？？

1：封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

 View Code

2：封装方法：目的是隔离复杂度

封装方法举例：

1. 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。

2. 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！

3. 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

 隔离复杂度的例子

3: 了解

有三个层面的封装：

第一层面是类本身就是一种封装。

第二层面是类中定义私有的，只有在类的内部使用，外部无法访问（实际通过找到修改后的名字还是可以访问的）。

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的。

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点。对于双下划线开头的外部可以通过对象obj结合类名A：通过 obj._A__N访问到。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'class People:__star='earth111111111111'__star1='earth111111111111'__star2='earth111111111111'__star3='earth111111111111'def __init__(self,id,name,age,salary):print('----->',self.__star)   #能够成功访问自己内部的双下划綫的self.id=idself.name=nameself.age=ageself.salary=salarydef get_id(self):print('我是私有方法啊,我找到的id是[%s]' %self.id)#访问函数/接口函数：内部访问双下划綫的数据def get_star(self):     print(self.__star)    #通过这个函数可以访问到内部的一个访问接口

p1=People('123123123123','alex','18',100000000)
# print(p1.__star)    #双下划线开头的__star函数，外部对象不能直接访问
print(People.__dict__)   #查看装了什么
# print(p1.__star)
print(p1._People__star)  #外部不能直接访问，但像这样就可以访问到了。所以不是真正的限制，只是一种约定。# p1.get_star()   #不可以
p1.get_star()    #因此实例可以通过调用类内部的函数来访问
# 因此，封装实质就是区分内外，内部就是能用，外部不能直接用

第二层面

第三层面的封装才是真的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用。

这样做的好处是，为外部类的使用者提供一个方便访问，原有已经定义好的内置私有数据的“接口”。

但如果定义了太多不该对外部隐藏的数据，后续又通过这种“凿洞”的方式，很可能把程序弄得千疮百孔。所以定义双下划线之前一定要想清楚。

（这或许也可以用来解释为什么python被设计为非严格限制外部对内部私有属性的访问，从而避免滥用封装。）

python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__，详见面向对象进阶。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'class Room:def __init__(self,name,owner,width,length,high):self.name=nameself.owner=ownerself.__width=width        #在内部对数据做了一个封装self.__length=lengthself.__high=high#累的设计者不想直接给类的使用者看具体数据def tell_area(self): #此时我们想求的是面积return self.__width * self.__length *self.__highdef tell_width(self):return self.__width    #不能采用直接去掉双下划线变width供外部使用，因为__width很可能会在别的逻辑中被调用了#如果贸然修改，很可能出现很多错误、很多需要修改的

r1=Room('卫生间','alex',100,100,10000)# arear=r1.__width * r1.__length   #不给访问
print(r1.tell_area())

第三层面

四 特性(property)

什么是特性property

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

 View Code

例二：圆的周长和面积

 View Code

#注意：此时的特性arear和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

除此之外，看下

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class Foo:def __init__(self,val):self.__NAME=val #将所有的数据属性都隐藏起来@propertydef name(self):return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)@name.setterdef name(self,value):if not isinstance(value,str):  #在设定值之前进行类型检查raise TypeError('%s must be str' %value)self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME@name.deleterdef name(self):raise TypeError('Can not delete')f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

 了解：一种property的古老用法

五 封装与扩展性

 View Code