面向对象 - 封装/property - 总结

面向对象 - 封装：
    封装：在类定义阶段，以__开头的属性名发生了变形 eg:  __x --> _A__x / __foo --> _A__foo
    1.特点：
        1.在类外部无法直接访问   __x 是 _A__x
        2.在类内部可以直接使用   self.__foo() == self._A__foo()
        3.子类无法覆盖父类以__开头的属性 因为根本不是一个名字 __x  _A__x
    2.总结：
        这种变形需要注意的问题：
            1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，
              如a._A__N  eg:print(A._A__x) 但一般不这样做！
            2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形   eg: b.__age=18  {'_B__name': 'alice', '__age': 18}
            3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的  eg: def __foo(self):  #_A__foo
    3.意义：
        1.封装数据属性的目的：（封装不是单纯意义上的隐藏）
            明确的区分内外，控制外部对隐藏属性的操作行为  对接口 设定规则
        2.封装方法属性的目的：
            隔离复杂度  a=ATM() a.withdraw()  对接口 设定规则
    4.扩展性：
        def tell_area(self) 对使用者来说不用改变方式 开发者在类里面扩展
        面向对象的三大特征：继承 多态 封装
        面向对象的优点：可扩展性高

 class A:
     __x=1
     def __init__(self,name):
         self.name=name

     def __foo(self):
         print('run foo')

     def bar(self):
         self.__foo()
         print('run bar')

 a=A('alice')
 # print(a.__dict__)
 # print(a.name)
 # a.bar()
 # # a.foo()
 # a._A__foo()
 # # print(a.__x)
 # print(a._A__x)
 # print(A.__dict__)

 # a.bar()
 # a.__foo()

 # a.__x=1
 # print(a.__dict__)
 # print(a.__x)
 # print(A.__dict__)

 # A.__x=2
 # print(A.__x)
 # print(A.__dict__)

 class Foo:
     def __func(self):
         print('from foo')

 class Bar(Foo):
     def __init__(self,name):
         self.__name=name

     def __func(self):
         print('from bar')

 # b=Bar()
 # # b.func()
 # print(Foo.__dict__)
 # print(Bar.__dict__)

 b=Bar('alice')
 # print(b.__dict__)
 # print(b.name)
 # print(b._Bar__name)

 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_fooo
         print('B.foo')

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

 # print(A.__dict__)
 # print(B.__dict__)

 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):
             print('名字必须是字符串类型')
             return
         if not isinstance(age,int):
             print('年龄必须是数字类型')
             return
         self.__name=name
         self.__age=age

 p1=People('alice',12)
 # print(p1.name,p1.age)
 # print(p1.__dict__)
 # p1.tell_info()
 # p1.set_info('alex',18)
 # p1.tell_info()

 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 tell_area(self):
         return self.__weight * self.__length * self.__height

 r=Room('客厅','alice',100,100,100)
 # print(r.tell_area())

封装

面向对象 - property： 
    property:
        1.@property 将函数属性 伪装成 数据属性
        2.必须要有返回值 return ''
        3.@property     查看 必须要有返回值   print(p.name)  name 是函数属性 不是数据属性 伪装成 数据属性
          @name.setter  修改                 p.name='alex'
          @name.deleter 删除                 del p.name
    总结：通过计算得来的方法 可以通过@property 伪装成数据属性 

 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('alice',60,1.65)
 # print(p.bmi())
 # print(p.bmi)
 # p.bmi=12

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

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

     @name.setter
     def name(self,val):
         if not isinstance(val,str):
             print('名字必须是str')
             return
         self.__name=val

     @name.deleter
     def name(self):
         print('不允许删除')

 p=People('alice')
 print(p.name)
 p.name='alex'
 print(p.name)
 del p.name

property