封装

封装之如何实现隐藏

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

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __x = 1  # 这种隐藏是一种变形操作，在类定义阶段改成 _A__x

    def __init__(self,name):  # 在类定义阶段不会执行它的代码，但会检测它的语法
        self.__name = name  # 所以这一行代码在类定义阶段已经被翻译成self._A__name = name

    def __foo(self):  # 类定义阶段会加载这个，立马把函数名改成_A__foo(self)
        print("run foo")

    def bar(self):  # 类定义阶段不会执行bar的代码，但会检测它的语法
        self.__foo()  # 一检测它的语法这行就已经变成_A__foo()    # 在类内部可以直接使用obj.__AttrName
        print("from bar")

a = A("egon")
#a.__foo() # 在类外部直接调用明显不可以
#a.__x
a.bar()

这种自动变形的特点：

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

这种变形需要注意的问题是：

1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2、变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

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

class A:
    def __foo(self): # _A__foo
        print("A.foo")

    def bar(self):
        print("A.bar")
        self.__foo()  # self._A__foo()

class B(A):
    def __foo(self):  # _B__foo
        print("B.foo")

b = B()
b.bar()  # A.bar  A.foo   

封装的意义

第一点、封装数据，封装数据属性到底是干什么的：明确的区分内外，控制外部对隐藏属性的操作行为

将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

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

    def tell_info(self):
        print("Name:%s Age:%s" % (self.__name,self.__age))

    def set_info(self,name,age):
        if not isinstance(name,str):  # isinstance谁是谁的对象的意思,用户传的name是不是str
            print("名字必须是字符串类型")
            return
        if not isinstance(age,int):
            print("年龄必须是整数类型")
        self.__name = name
        self.__age = age

第二点、封装方法的目的：隔离复杂度

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

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,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


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
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


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()