面向对象 - 1.封装之如何实现属性的隐藏/2.封装的意义/3.封装与扩展性/4.property的使用

1.封装之如何实现属性的隐藏
封装： __x=1  # 把数据属性隐藏 (如何实现隐藏)  类定义阶段  __开头发生了变形  __x --> _A__x
特点：
   1.在类外部无法直接：obj.__AttrName
   2.在类内部是可以直接使用：obj.__AttrName   # 为什么会这样？python 如何实现的 ！类定义阶段已经变形  #__x --> _A__x   #self._A_foo()
   3.子类无法覆盖父类__开头的属性 它两根本不是一个名字   #_Foo__func  #_Bar__func
总结:
 这种变形需要注意的问题：
    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

 # class A:
 #     __x=1  # 把数据属性隐藏    _A__x
 #
 #     def __init__(self,name):
 #         self.__name=name    # _A__name
 #
 #     def __foo(self):  # 把函数属性隐藏   def _A__foo(self)
 #         print('run foo')
 #
 #     def bar(self):
 #         self.__foo()  #self._A_foo()  定义阶段已经变了
 #         print('from bar')
 
 # print(A.__dict__)
 # {'__module__': '__main__', '_A__x': 1, '__init__': <function A.__init__ at 0x0000017AC92B0B70>, '_A__foo': <function A.__foo at 0x0000017AC92B0BF8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
 # 类定义阶段  __开头发生了变形  __x --> _A__x
 
 # print(A.__x)
 # print(A._A__x)
 # print(A.__foo)
 # print(A._A__foo)
 # a=A('alice')
 # print(a.__dict__)
 # {'_A__name': 'alice'}
 # print(a.__name)
 # print(a._A__name)
 # a.bar()
 
 # ---------------------------------------------
 # class Foo:
 #     def __func(self):  #_Foo__func
 #         print('from foo')
 #
 # class Bar(Foo):
 #     def __func(self):  #_Bar__func
 #         print('from bar')
 
 # b=Bar()
 # b.func()  # 子类把父类 重名的给覆盖掉了
 
 # ---------------------------------------------
 # class B:
 #     __x=1
 #
 #     def __init__(self,name):
 #         self.__name=name
 
 # # print(B._B__x)   # 一般不要这么做！py不让你这么干了
 # B.__y=2   # 类定义完之后不会发生变形
 # # print(B.__dict__)
 # # {'__module__': '__main__', '_B__x': 1, '__init__': <function B.__init__ at 0x00000180405A0B70>, '__dict__': <attribute '__dict__' of 'B' objects>, '__weakref__': <attribute '__weakref__' of 'B' objects>, '__doc__': None, '__y': 2}
 #
 # b=B('alice')
 # print(b.__dict__)  # {'_B__name': 'alice'}
 #
 # b.__age=18
 # print(b.__dict__) #{'_B__name': 'alice', '__age': 18}
 
 # ---------------------------------------------
 # class A:
 #     def foo(self):
 #         print('A.foo')
 #
 #     def bar(self):
 #         print('A.bar')
 #         self.foo() #b.foo
 #
 # class B(A):
 #     def foo(self):
 #         print('B.foo')
 #
 # b=B()
 # b.bar()
 
 # ---------------------------------------------
 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()

2.封装的意义
  封装数据属性目的：  (封装不是单纯意义上的隐藏)
     明确的区分内外,控制外部对隐藏的属性的操作行为
 
  封装方法属性目的：
     隔离复杂度   #  a=ATM()  a.withdraw()

 # 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
 #
 # p=People('alice','18')
 # p.tell_info()
 
 # p.set_info('alex',38)
 # p.tell_info()
 
 # p.set_info('alex','38')
 # p.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()

3.封装与扩展性
面向对象：可扩展性高
面向对象三大特性：继承 多态 封装
封装的扩展性：
     def tell_area(self):  # 对使用者来说 不用改变 方式   开发者在类里面修改

 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('卫生间','alex',10,10,10)
 print(r.tell_area())

4.property的使用
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
-------------------------------
property :
   @property
   def bmi(self): 必须有个返回值
   print(p.bmi)   可以使 函数属性 伪装成 数据属性  bmi 是名词
 
   p.bmi=23  # 不能赋值 can't set attribute  bmi 实质是个方法
 
总结：通过计算得来的方法 可以通过@property 伪装成数据属性
      @property      查看  必须有返回值
      @name.setter   修改
      @name.deleter  删除

 # 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.81)
 # p.bmi=p.weight / (p.height ** 2)
 # print(p.bmi)
 
 # print(p.bmi())  # 函数 是 去做什么！ 是动词  对于使用者 产生误解 调了一个动词
 
 # print(p.bmi)      # 使用者可以像 访问数据属性 那样 访问 函数属性
 # p.height=1.82
 # print(p.bmi)
 # p.bmi=23  # 不能赋值 can't set attribute  bmi 实质是个方法
 
 # ------------------------------------------------------------
 class People:
     def __init__(self,name):
         self.__name=name
 
     @property     # 查看
     def name(self):
         # print('getter')
         return self.__name
 
     @name.setter  # 修改  # 前提是 一定被装饰过 property
     def name(self,val):
         # print('setter',val)
         if not isinstance(val,str):
             print('名字必须是字符串')
             return
         self.__name=val
 
     @name.deleter  # 删除
     def name(self):
         # print('deleter')
         print('不允许删除')
 
 p=People('alice')
 # print(p.name)
 
 # p.name='alex'
 # print(p.name)
 
 del p.name