Python之封装

1、为什么要封装

封装不是单纯意义的隐藏

1：封装数据：主要原因是：保护私隐，明确区分内外。将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

class Teacher:
    def __init__(self,name,age):
        self.__name=name
        self.__age=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()

2：封装方法：目的是隔离复杂度

封装方法举例：

1. 你的身体没有一处不体现着封装的概念：你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，），你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。

2. 电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！

3. 快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

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

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()

2、封装例子

__名字，这种语法，只在定义的时候才会有变形的效果，如果类或者对象已经产生了，就不会有变形效果

classA:
    __x=1 #在属性前面加两个下划线，表示对该属性进行隐藏，设置成私有，在内部都会变成成：_类名.__x
    def__test(self): #这里在内部会变形：_A__test，调用的时候a._A__test()
        print('fromA')
    def__init__(self):
        self.__x=10 #变形为self._A__x

    def__foo(self): #变形为_A.__foo
        print('fromA')

    def bar(self):
        self.__foo()  #只有在类内部才可以通过__foo的形式访问

#这就是封装，简单的隐藏
#a=A()
#print(a._A__x)
#a._A__test()#不建议在外部直接通过这种方式调用隐藏方法

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

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

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

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

class A:
    def fa(self):
        print('from A_fa')

    def test(self):
        self.fa()  # b.fa

class B(A):
    def fa(self):
        print('from B_fa')
    pass

b=B()
b.test() # b.test --- >B---->A----> b.fa()----> b 是 B 的对象，在 B 里找 fa

class A:
    def __init__(self):
        self.__x=1  # 对象调用的时候 self._A__x 或者定义一个接口

    def tell(self):   # 定义统一接口，对象去调用这个 tell() 接口查看 __x
        print(self.__x)  # 在类的内部，可以直接这样调用 __x，外部是 _A__x

# 法1：不推荐
a=A()
print(a._A__x)

# 法2: 可以用
a.tell()

# 知识点：在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
# __名字，在定义节点就已经变形了，变成  _类名__属性
class A:
    def __fa(self):  # 变形：_A__fa，fa 变成私有
        print('from A_fa')

    def test(self):
        self.__fa()  # 在定义的时候就变形了，self.__fa() 变成：self._A__fa()

class B(A):
    def __fa(self):  # 变形：_B__fa
        print('from B_fa')
    pass

b=B()
b.test() # b.test --- >B没有---->找A的test----> b.fa()----> b._A__fa  找的A的 __fa

3、封装特性

什么是特性property

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

import math
class Circle:  # 圆周率
    def __init__(self,radius):  # 圆的半径
        self.radius=radius

    @property   # area=property(area)
    def area(self):
        return math.pi * self.radius**2  #  计算圆的面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius # 计算周长

c=Circle(7)
print(c.area)  # 伪装成数据属性，如果不加 property 的话，调用的时候变成  c.area()，一个函数属性

property 简单来说就把类里的函数属性伪装成一个数据属性，使用者用起来感觉不到自己用的其实一个函数



#注意：此时的特性arear和perimeter不能被赋值，因为实质上是一个函数属性
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

ps：面向对象的封装有三种方式:

【public】

这种其实就是不封装,是对外公开的

【protected】

这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开

【private】

这种封装对谁都不公开

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


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

p1=people('alex',18,1.76,74)
print(p1.bodyindex)

class people:
    def __init__(self,name,SEX):
        self.name=name
        # self.__sex=SEX  # 性别隐藏起来不让人知道
        self.sex=SEX  # # p2.sex=male 一初始化或赋值操作就找 sex.setter
    @property   # 负责查询
    def sex(self):   # 通过接口可以查看隐藏的性别
        return self.__sex  # p2.__sex= male

    @sex.setter  # 定义修改性别的接口
    def sex(self,value):
        # sexes=['male','female']
        if not isinstance(value,str):  # 在设定值之前进行类型检查，增加限制的扩展性
            raise TypeError('性别必须是字符串类型')
        # if value not in sexes:
        #     raise TypeError('性别只能是 male 或者 female')
        self.__sex=value  # p2.__sex= male

    @sex.deleter
    def sex(self):   # 删除属性接口
        del self.__sex  # del p2.__sex

p2=people('alex','male')  # 触发 init 执行，这里有个赋值操作 p2.sex='male'
print(p2.sex)
# p2.sex='female3'
# print(p2.sex)
del p2.sex  # 删掉 __sex 数据属性
print(p2.sex)  # 再去 property 找的话找不到了

被 property 装饰的属性会优先于对象的属性被使用，被找到

而被 property装饰的属性，如 sex ，分成三种

property 查询

sex.setter 赋值，修改

sex.deleter 删除

如果对象要修改数据属性的时候，在没有 property 的情况下，可以随便改，但是加了之后，就可以有一个扩展性，限制对象只能改什么