封装

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

# 隐藏属性
# 其实这仅仅这是一种变形操作
# 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
# A._A__a是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

class A:

    __a = 3                    # 在定义阶段就将__a变形为_A__a

    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def info(self):
        print('My name is %s,i am %s'%(self.name,self.__age))        # 在类内部可以访问隐藏属性


a = A('aa',25)

# print(a.__age)                  # 在类外部无法访问隐藏属性，会报错
a.info()

A.__sex = '女'                    # 在类外部无法定义隐藏的属性

print(A.__dict__)
print(a.__sex)

隐藏需要注意的点：
1、这种变形并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__a
2、变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

隐藏特点：
1、类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2、这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3、在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

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

class FOO:

    def __func(self):         # 定义时即改写为_Foo__func()
        print('from Foo')

    def bar(self):
        print('from bar')
        self.__func()        # 此时调用的__func()不是子类里面的，是父类的即_Foo__func()

class Bar(FOO):

    def __func(self):       # 定义时即改写为_Bar__func
        print('from Bar')

b = Bar()
b.bar()                  # 调用__func()时子类并没有将父类覆盖掉

封装的意义

1、封装数据属性：明确的区分内外,控制外部对隐藏属性的操作

class People:

    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex

    def info(self):
        print('name:<%s> age:<%s> sex:<%s>'%(self.__name,self.__age,self.__sex))

    def change_info(self,name,age,sex):
        if not isinstance(name, str):
            print('名字必须是字符串')
            return

        if not isinstance(age, int):
            print('名字必须是字符串')
            return

        if not isinstance(name, str):
            print('性别必须是字符串')
            return

        self.__name = name
        self.__age = age
        self.__sex = sex

p = People('刘三',25,'女')

p.info()
p.change_info(24,'na','meal')

2、封装方法属性：隔离复杂度，同时也可以提升安全性

# 将实现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()

a=ATM()
a.withdraw()

封装的扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

# 初始程序
class Room:

    def __init__(self,name,owner,weight,length,height):
        self.name = name
        self.owner =owner
        self.__weight = weight
        self.__length = length
        self.__height = height

    def area(self):

        s = self.__weight * self.__length
      

        return s

room = Room('刘三','别墅',20,20,15)

# 扩展功能：即永恒调用时只会调用接口的名称，只要接口名称不变，改变接口内部的代码既可以实现不同的功能

class Room:

    def __init__(self,name,owner,weight,length,height):
        self.name = name
        self.owner =owner
        self.__weight = weight
        self.__length = length
        self.__height = height

    def area(self):

     
        v = self.__weight * self.__length * self.__height  # 计算方式发生变化

        return v

room = Room('刘三','别墅',20,20,15)