面向对象之封装
一 引子
从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。在面向对象中，麻袋就是你的类或者对象，类或者对象这俩麻袋内部装有数据属性和函数属性。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的。
封装的本质是要明确地区分内外。是的类实现者可以修改封装内的东西而不影响外部调用者；而外部调用者也可以知道自己不可以碰哪里，从而提供了一个良好的合作基础。只要接口这个基础约定不变，则代码改变不足为虑。
二 先看如何隐藏
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形 #类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式： #因此外部还是可以访问到重命名后的 class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print('from A') def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到. #这种，在外部是无法通过__x这个名字访问到。 #但可以通过 obj._A__N是可以访问到的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。
2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形
对于两种不同的编码约定（单下划线和双下划线）来命名私有属性的选用：
（1）非公共名称以单下划线开头
（2）若代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划綫
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
View Code三 封装不是单纯意义的隐藏
封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，那这么做的意义何在？？？
1：封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。
View Code2：封装方法：目的是隔离复杂度
封装方法举例：
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=id self.name=name self.age=age self.salary=salary def 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=name self.owner=owner self.__width=width #在内部对数据做了一个封装 self.__length=length self.__high=high #累的设计者不想直接给类的使用者看具体数据 def tell_area(self): #此时我们想求的是面积 return self.__width * self.__length *self.__high def 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 #将所有的数据属性都隐藏起来
@property
def name(self):
return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
@name.setter
def name(self,value):
if not isinstance(value,str): #在设定值之前进行类型检查
raise TypeError('%s must be str' %value)
self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
@name.deleter
def 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