封装

0 引入

面向对象编程有三大特性：封装、继承、多态，其中最重要的一个特性就是封装。封装指的就是把数据与功能都整合到一起，听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口

一、隐藏类属性和方法

如何隐藏

• 在变量前加__

# 如何隐藏呢？ 类属性和 方法前面加__。对外不对内

class Foo:
    __x =1

    def __f1(self):
        print("__f1内部可以访问")

    def f2(self):
        self.__f1()
        print(self.__x)

f = Foo()
#f.x 不能访问__x
print(Foo.__dict__)

"""{'__module__': '__main__', '_Foo__x': 1, 
'_Foo__f1': <function Foo.__f1 at 0x0000000002784310>, 
'__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__weakref__': <attribute '__weakref__' of 'Foo' objects>,
'__doc__': None}
"""
# 从上面可以看出外部访问可以通过_Foo__x

print(Foo._Foo__x)  # 1
print(Foo._Foo__f1)  # <function Foo.__f1 at 0x0000000002784310>
# __对外不对内，内部可以直接访问__,如下：
Foo().f2()
"""
__f1内部可以访问
1
"""

隐藏属性

设计者： 阿登

class People:

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

    def get_name(self):
        # 通过接口就可以间接地访问到名字属性
        print(self.__name)
    
    def change_name(self, name):
        if not isinstance(name, str):
            print("必须传字符串")
            raise TypeError("必须传字符串")
        self.__name = name
        print(f"修改后名字为：{self.__name}")
        

 使用者：向佳

p = People("咸维维")

那么不能直接访问__name,我可以开放一个接口访问

p.get_name() # 这样就能访问到name了

再比如我想要修改__name的属性，作为设计者我给你开放一个接口让你修改
作为设计者__name的设计我并不想让使用者直接修改 删除等操作。那么
作为设计者我给你开放一个接口供你访问和修改属性。
p.change_name("阿登")

隐藏函数属性

目的的是为了隔离复杂度,当使用调用的时候点方法的时候只需要使用想调的方法即可，无需在多个方法中选择，例如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装饰器

装饰器是在不修改被装饰器对象源码代码以及调用方式的前提下为被装饰对象添加新功能的可调用对象

例一：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

身高或体重是不断变化的，因而每次想查看BMI值都需要通过计算才能得到，但很明显BMI听起来更像是一个特征而非功能，
为此Python专门提供了一个装饰器property，可以将类中的函数“伪装成”对象的数据属性，
对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果，例如

property是一个装饰器，是用来绑定给对象的方法伪装成一个数据属性，就可以不用加括号调用

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

    # bmi听起来更像是1个数据属性，而非功能

    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('adneg',75,1.80)
print(p1.bmi) # 23.148148148148145

p1.weight = 70
print(p1.bmi)  # 21.604938271604937

使用property有效地保证了属性访问的一致性。另外property还提供设置和删除属性的功能，如下

class People1:

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


    def get_name(self):
        # 通过接口就可以间接地访问到名字属性
        return self.__name

    def change_name(self, name):
        if not isinstance(name, str):
            print("必须传字符串")
            raise TypeError("必须传字符串")
        self.__name = name
        print(f"修改后名字为：{self.__name}")

    def del_name(self):
        print("不让删")
        # del self.__name

    name = property(get_name, change_name, del_name)

obj1 = People1("阿登")
"""
1.  属性隐藏起来
2. 开放接口
3.  name = property(get_name, change_name, del_name)
"""
# obj1.get_name()
# obj1.change_name("向佳")
# obj1.del_name()

print(obj1.name)
del obj1.name
obj1.name = "王润"

name = property(get_name, change_name, del_name)

上面那种方式是老版本的使用方式下面用另外一种更直观的方式实现：

如果有个关键属性你想让外部使用者的操作严格控制起来，步骤：
1. 隐藏起来
2. 开放三个接口 查看 修改 删除 三个接口，三个接口的命名一直，同需要操作的名字一样

3.三个接口操作伪装成一个数据属性 查找@property 修改 @name.setter 删除 @name.deleter name就是你想操作的属性name，如果编程name123那么你三个接口的方法名也需要编程name123 查找@property 修改 @name123.setter 删除 @name123.deleter

class People2:

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

    @property    # name = property(name)
    def name(self):  # p2.name
        # 通过接口就可以间接地访问到名字属性
        return self.__name

    @name.setter
    def name(self, name): # p2.name = "老胡"
        if not isinstance(name, str):
            print("必须传字符串")
            raise TypeError("必须传字符串")
        self.__name = name
        print(f"修改后名字为：{self.__name}")

    @name.deleter
    def name(self): # del p2.name
        print("不让删")
        # del self.__name


p2 = People2("毛主席")
print(p2.name)  # 毛主席
p2.name = "老胡" # 修改后名字为：老胡
del p2.name  # 不让删