一、封装介绍
面向对象编程有三大特性：封装、继承、多态。
封装是面向对象三大特性最核心的一个特性，封装的意思其实就是“整合”。
二、将封装的属性进行隐藏操作
（一）如何隐藏：在属性名前加_ _前缀，就会实现一个对外隐藏属性效果
class Foo:
__x = 1
def __f1(self):
print('from test')
print(Foo.__x) # 报错
print(Foo.__f1) # 报错
该隐藏需要注意的问题：
-
在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：
_类名_ _属性，然后就可以访问了，如Foo._Foo__x。所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。
class Foo: __x = 1 # _Foo__x def __f1(self): # _Foo__f1 print('from test') print(Foo._Foo__x) # 1 print(Foo._Foo__f1) # <function Foo.__f1 at 0x000002061A686160> -
这种隐藏对外不对内，因为
__开头的属性会在检测类体代码语法时统一发生不可见变形，变为_类名_ _属性格式。class Foo: __x = 1 # _Foo__x = 1 def __f1(self): # _Foo__f1 print('from test') def f2(self): # f2没有做隐藏处理 print(self.__x) # print(self._Foo__x) print(self.__f1) # print(self._Foo__f1) obj = Foo() obj.f2() # 运行结果： # 1 # <bound method Foo.__f1 of <__main__.Foo object at 0x000002A8AF435640>> -
这种变形操作只在检测类体语法的时候发生一次，之后定义的
__开头的属性都不会变形class Foo: __x = 1 # _Foo__x = 1 def __f1(self): # _Foo__f1 print('from test') def f2(self): print(self.__x) # print(self._Foo__x) print(self.__f1) # print(self._Foo__f1) Foo.__y = 3 print(Foo.__y) # 3 -
通过给对象的属性加上
__前缀，也可以实现对对象属性的隐藏效果。class Foo: __x = 1 def __init__(self, name, age): self.__name = name self.__age = age def func(self): print(self.__name, end='//') print(self.__age) obj = Foo('山炮', 18) # print(obj.name, obj.age) # 报错 print(obj.__dict__) # {'_Foo__name': '山炮', '_Foo__age': 18} obj.func() # 山炮//18 # 因为隐藏是对外不对内的
（二）为何要隐藏
-
隐藏数据属性
将数据隐藏起来就
限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制：class People: def __init__(self, name): self.__name = name def get_name(self): # 通过该接口就可以间接地访问到名字属性 print(self.__name) def set_name(self, val): if type(val) is not str: print('小垃圾，必须传字符串类型') return self.__name = val obj = People('山炮') # print(obj.name) # 无法直接用名字属性 obj.get_name() # 但通过get_name接口可以看名字属性 # obj.set_name(123123123) # 通过接口改名字属性 -
隐藏函数属性
目的的是为了隔离复杂度，例如ATM的取款功能，该功能由很多其他功能组成，比如插卡、身份认证、输入金额、打印小票、取钱等。而对使用者来说，只需要开发取款这个功能接口即可，其余功能我们都可以隐藏起来，逻辑更加清晰。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() obj = ATM() obj.withdraw()本质就是为了明确地区分内外，类内部可以修改封装之内的东西而不影响外部调用者的代码。类外部只需拿到一个
调用接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变调用代码。这就提供一个良好的合作基础，只要接口这个基础约定不变，则代码的修改对使用的影响就不足为虑。
三、property装饰器
装饰器是在不修改被装饰对象源代码以及调用方式的前提下为被装饰对象添加新功能的可调用对象
我们通过一个例子来引入property。
先写一个计算BMI指数的程序：
class People:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
def BMI(self):
return self.weight / (self.height ** 2)
obj = People('山炮', 70, 1.77)
res = obj.BMI()
print(res) # 22.34351559258195
从BMI的公式上看，BMI应该是触发功能计算得到的。并且是随着身高、体重的变化而动态变化的，不是一个固定的值。如果我想知道BMI指数大小，就需要每次进行临时计算得到。
在类中，BMI现在是一个计算函数，是一个函数属性。但是BMI指数听起来更像是一个数据属性，如果我想把它变成一个数据属性，并通过obj.bmi就可以查看该数值的大小，该怎么做呢？
property是一个装饰器，用来将绑定给对象的方法伪装成一个数据属性。
使用property，可以将类中的函数“伪装成”对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果。如下：
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)
obj = People('山炮', 70, 1.77)
print(obj.BMI) # 22.34351559258195
property还有另外一种使用方法。
我们通过property可以把类中的函数伪装成一个数据属性，但此数据属性不支持修改，因为它和返回值息息相关。
如果想要实现我们通过@property伪装成数据属性的函数，具有像正常数据属性一样的可改可查操作，就可以通过写一改一查两个函数，再将两个函数一起property，绑定给一个变量名。
然后我们就可以直接在实例化出的对象中利用这个变量名来实现可改可查操作。如下：
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)
def see_name(self):
return self.__name
def change_name(self, name):
self.__name = name
name = property(see_name, change_name) # 括号里的顺序必须对应的是“查 改 删”函数(方法)名
obj = People('山炮', 70, 1.77)
print(obj.name) # 山炮
obj.name = '韩梅梅'
print(obj.name) # 韩梅梅
分析：在类中，我们将self.name这个属性做了隐藏处理，但开放了一改一查两个调用接口。property可以把类中的函数伪装成一个数据属性，我们就可以将这个函数直接当做一个变量去看待，变量值则是函数返回值。
在经过类中的最后一行代码name = property(see_name, change_name)处理后，我们把两个调用接口做了统一的数据属性伪装处理，这样子我们就可以直接把obj.name作为变量看待，将它输出时，调用的是see_name接口，对它进行赋值操作时，则调用的是change_name接口。
还可以通过将相关所有函数名改为同一个名字(这里是name)，在主要的函数(主要的函数就指的是想伪装成数据属性的那个函数)上加@property，对应的访问形式是obj.name；加@name.setter的函数，对应的则是obj.name = xxx更改操作功能；加@name.deleter的函数，对应的则是del obj.name删除功能。
这样也可以实现直接把obj.name当成普通数据属性进行查改删操作，说白了就是上一个方法的另一种形式。
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)
@property
def name(self):
return self.__name
@name.setter
def name(self, name):
self.__name = name
@name.deleter
def name(self):
print('不支持删除')
obj = People('山炮', 70, 1.77)
print(obj.name) # 山炮
obj.name = '李雷'
print(obj.name) # 李雷
del obj.name # 不支持删除
上面程序做的事情：首先将对隐藏属性self.__name的三个操作函数都定义成同一个名字，这个名字就是想让外部访问者访问到的属性名。
如果某函数对应的是这个属性名的访问操作(查看操作)，就在上面加上@property装饰器；如果某函数对应的是修改操作，就在上面加@名.setter装饰器；删除操作则是@名.deleter装饰器。
对property的个人理解
@property让我们可以把类中的函数(设为x)直接当做类中的普通数据属性去看待，当我们实例化出一个对象obj，并且obj.x这么去做时，它的值就是x的返回值，并且可能是x中对已隐藏的属性进行了某些计算和处理之后才给我们返回的一个值。
我们把这个值可以当做普通数据属性去查看(print(obj.x))，但一个数据属性最基本的要素是可查看，可更改，可删除。既然我们已经可以将它当做数据属性去对待，就不能让它只具有一个可查看的操作。
现在已有的这个可查看的值是x函数的返回值，变量名则是x。x在根本上是函数名，只不过是我们将它伪装成了变量名，所以这种伪装不支持直接对它进行赋值(更改)操作，即直接obj.x = 123。若想要对它进行值上的更改，就必须再定义一个函数(设为y)，且这个函数(y)的内部就具有着对x返回值进行修改的语句。（值得注意的是，x的返回值必定与类中的某一个属性有关，通常就只是返回类中的某一个数据属性。所以y内部其实是根据这个属性做的修改，如果没有这个与共同都有关的属性，就联系不到一起。）
但y这个函数，和x这个函数，怎么能联系起来呢？它们毫无联系，是相互独立的两个函数，如何才能让x知道，y里面的修改语句就是它的命中注定的变数呢？于是就有了接下来的这个玄幻操作：两个函数起一样的名字(设为z)，原x函数头上顶着@property，原y函数头上顶着@z.setter。
这个迷离操作，其实就是让两个函数的命运交缠了起来，共同构成了一个伪装变量的两种形态：一个负责初始值，一个负责修改值。并且负责修改值的函数，在参数上要给外部留一个传进来修改后的值的参数位置，而且这个参数的传入形式不是通过加括号传入，而是直接像修改变量值一样就可以实现修改效果。
删除操作同理，只不过内部一般是提示性语句。
class test:
def __init__(self, start):
self.start = start
@property # 负责查
def Z(self):
return self.start
@Z.setter # 负责改
def Z(self, finish):
self.start = finish
obj = test(10)
print(obj.Z) # 10
obj.Z = 20
print(obj.Z) # 20