Day8 封装 静态属性property

封装：将类的属性隐藏

#先看如何隐藏

1，在定义的属性之前加入__.

class Foo:
    __N=111111 #_Foo__N
    def __init__(self,name):
        self.__Name=name #self._Foo__Name=name

    def __f1(self): #_Foo__f1
        print('f1')
    def f2(self):
        self.__f1() #self._Foo__f1()    #在类内部调用的话可以
f=Foo('egon')

#这种隐藏需要注意的问题： 
#1：这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来 
# print(Foo.__dict__) 
# print(f.__dict__) 
# print(f._Foo__Name) 
# print(f._Foo__N)

第二个问题：这种语法上的变形是在什么时候发生的

#在定义类阶段发生，并且只在这个阶段发生

比如说在上面的基础上，再定义一个Foo.__x=12121212121212121212

再去访问Foo.__x这个属性，

是可以访问的到的，不会被隐藏

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

#封装不是单纯意义上的隐藏

1，封装数据属性（内部能用，外部不能用，开一个接口给其他人使用，保证代码安全性）

　　

　　将属性隐藏起来，然后提供对外访问属性的接口，关键是我们在接口内定制一些控制逻辑从而严格控制对数据属性的使用

 class People:
     def __init__(self,name,age):
         if not isinstance(name,str):
             raise TypeError('%s must be str' %name)
         if not isinstance(age,int):
             raise TypeError('%s must be int' %age)
         self.__Name=name
         self.__Age=age
     def tell_info(self):
         print('<名字：%s 年龄：%s>' %(self.__Name,self.__Age))

     def set_info(self,x,y):
         if not isinstance(x,str):
             raise TypeError('%s must be str' %x)
         if not isinstance(y,int):
             raise TypeError('%s must be int' %y)
         self.__Name=x
         self.__Age=y

 #p=People('egon',18)
 #p.tell_info()

 # p.set_info('Egon','19')
 #p.set_info('Egon',19)
 #p.tell_info()

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

静态属性property:

在类里面加入这个参数以后，调用函数不用加括号了。（加括号会报错）

相当于把功能伪装成一个数据，eg：

 class Foo:
     @property    #这里相当于把函数直接伪装了
     def f1(self):
          print('f1')

 f=Foo()

 # f.f1()

 f.f1

写一个例子：

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

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)

# p=People('egon',75,1.80)
# p.height=1.86
# print(p.bmi())　 #这里是在没有加property这个属性的时候用的
# print(p.bmi)    #在这里就可以直接输出值了

怎么功能添加访问，设置，删除的属性。

是在函数已经设置了静态属性的前提下，在设置函数.setter,函数.deleter等属性

 class Foo:
     def __init__(self,x):
         self.__Name=x

     @property
     def name(self):
         return self.__Name

     @name.setter
     def name(self,val):
         if not isinstance(val,str):
             raise TypeError
         self.__Name=val

     @name.deleter
     def name(self):
         # print('=-====>')
         # del self.__Name
         raise PermissionError

 # f=Foo('egon')
 # print(f.name)
 #
 # # f.name='Egon'
 # f.name=123123123213
 # print(f.name)
 #
 # del f.name
 # print(f.name)