67.类的封装
一、封装的概念和意义
1.1 封装
从封装字面上去理解，封装就好像是拿来一个麻袋，把很多的东西一起装进麻袋，然后把麻袋封上口子。按照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的
在程序中，封装封装是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。封装是实现面向对象程序设计的第一步，它将数据或函数集合在一个个的单元中（我们称之为类），被封装的对象通常被称为抽象数据类型
1.2 封装的意义(优点)
第一：重用
第二：不必关心具体的实现
第三：面向对象三大特征之一
第四：具有安全性
你可以只关注于使用，而不关心具体的实现。比如电视机，我们会操作就行了，我才不关心他是怎么实现的呢？内部构度造那是生产和设计人员的事情！
比如人类,有手有问脚,有眼睛(人类的属性),会跑会吃(人类的行为)我们通过封装把属性和行为(方法)组装起来,形成一个类(人类),我们可让某个人(人类的一个对象)吃饭答,跑步,(调用方法),但我们不能让某个人长三只眼睛(就是说我们不应该去直接操作属性),而跑步要用到腿版(属性),腿的长短可能决定了跑的快慢(属性影响了方法).封装也确实实现了重用,我们只要为权人类创建一个跑方法,以后我们要让张三跑那么就创建一个对象并给他个名子叫张三,然后让他跑.
封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。良好的封装能够减少耦合，可以对成员进行更精确的控制。他实现了隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体
- 保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问==>数据封装。
- 方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者==>方法封装。
- 当对象含有完整的属性和与之对应的方法时称为封装。
- 从对象外面不能直接访问对象的属性，只能通过和该属性对应的方法访问。
- 对象的方法可以接收对象外面的消息。
面向对象就是将所有事物都抽象成类，用对象来来调用类中的方法，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，而类封装了属性和行为。属性（信息）用变量表示，行为（会做什么事）用函数表示。
二、属性隐藏
为了隐藏类中的成员，python玩了一个小技巧，只要将python类的成员命名为双下划线开头的，python就会将他们隐藏起来，设置为私有属性
在python中并没有真正的隐藏机制，双下划线只是python的一个小技巧，python会“偷偷”改变以双下划线开头的方法名，会在这些方法名前添加单下划线和类名，不过不推荐这么做，类似的是程序也可以通过隐藏的实例变量添加下划线和类名的方式来访问或修改对象的实例变量
import time
class Person(object):
def __init__(self, name, age, money):
self.name = name
self.age = age
# 添加两个下划线，这种属性我们称之为私有属性
self.__money = money
def get_money(self):
print('{}查询余额了！！！！'.format(time.asctime()))
return self.__money
def set_money(self, money):
print('修改余额了！！！')
self.__money = money
def test(self):
self.__demo()
print('加密以后的代码1')
print('加密以后的代码2')
print('加密以后的代码3')
print('加密以后的代码4')
print('加密以后的代码5')
print('我是person里的test函数')
def foo(self):
self.__demo()
# 私有方法使用 __ 开始
def __demo(self):
print('加密第1步')
print('加密第2步')
print('加密第3步')
print('加密第4步')
print('加密第5步')
print('加密第6步')
print('加密第7步')
p = Person('zhangsan', 18, 2000)
p.test()
print(p.get_money())
# p.__demo() 私有方法，外部无法访问
# p._Person__demo() 可以通过对象名._类名__私有属性名强制访问
p.set_money(1500)
print(p.get_money())
# 如果想要访问私有属性，可以使用 对象名._类名__私有属性名 来强制访问
# print(p._Person__money) # 强烈不推荐使用这种方式来访问私有属性
# 私有属性 __money 在外部能直接访问
# print(p.__money)
# p.__money -= 500
# print(p.__money)
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。
2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形
三、封装与隐藏
封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，那这么做的意义何在？
3.1 封装数据
将数据隐藏起来这不是目的，隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制才是我们的目的。
class Teacher:
def __init__(self,name,age):
# self.__name=name
# self.__age=age
self.set_info(name,age)
def tell_info(self):
print('姓名:%s,年龄:%s' %(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
raise TypeError('姓名必须是字符串类型')
if not isinstance(age,int):
raise TypeError('年龄必须是整型')
self.__name=name
self.__age=age
t=Teacher('egon',18)
t.tell_info()
t.set_info('egon',19)
t.tell_info()
3.2 封装方法
封装方法：目的是隔离复杂度
封装方法举例：
- 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的……），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
- 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！
- 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体
#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性
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()
隔离复杂度的例子
python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块中的变量名_private_module以单下划线开头，那么from module import *时不能被导入该变量，但是你from module import _private_module依然是可以导入该变量的
其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys.clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点,python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr_
四、特性(property)
4.1 什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
例一：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
@property
def bmi(self):
return self.weight / (self.height**2)
p1=People('egon',75,1.85)
print(p1.bmi)
例二：圆的周长和面积
import math
class Circle:
def __init__(self,radius): #圆的半径radius
self.radius=radius
@property
def area(self):
return math.pi * self.radius**2 #计算面积
@property
def perimeter(self):
return 2*math.pi*self.radius #计算周长
c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''
4.2 为什么要用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的古老用法
class Foo:
def __init__(self,val):
self.__NAME=val #将所有的数据属性都隐藏起来
def getname(self):
return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
def setname(self,value):
if not isinstance(value,str): #在设定值之前进行类型检查
raise TypeError('%s must be str' %value)
self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
def delname(self):
raise TypeError('Can not delete')
name=property(getname,setname,delname) #不如装饰器的方式清晰
了解：一种property的古老用法
五、封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑
