第五章---面向对象---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 = 1
#
#     def __init__(self,name):
#         self.__name = name # self._A__name = 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__)
16 # {'__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}
#
#
# print(A.__x)
# print(A.__foo)

# a = A('egon')
#print(a.__name)

# print(A.__dict__)
# print(a.__dict__)

# a.bar()
# run foo
# from bar

---------------------------------------------------------

# class Foo:
#     def func(self):
#         print('from foo')
#
# class Bar(Foo):
#     def func(self):
#         print('from bar')
#
# b = Bar()
# b.func()
# # from bar

# class Foo:
#     def __func(self): #_Foo__func
#         print('from foo')
#
# class Bar(Foo):
#     def __func(self):  # _Bar__func
#         print('from bar')

-------------------------------------------------------

# class B:
#     __x = 1
#
#     def __init__(self,name):
#         self.__name = name

# 验证问题一：
# print(B._B__x)

# 验证问题二：
# B.__y = 2
# print(B.__dict__)
# {'_B__x': 1, '__y': 2, '__weakref__': <attribute '__weakref__' of 'B' objects>,
#  '__module__': '__main__', '__doc__': None, '__init__': <function B.__init__ at 0x023B02B8>,
#  '__dict__': <attribute '__dict__' of 'B' objects>}
# b = B('egon')
# print(b.__dict__)
# # {'_B__name': 'egon'}
#
# b.__age = 18
# print(b.__dict__)
# # {'_B__name': 'egon', '__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()

# A.bar
# B.foo

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

2.封装的意义

封装数据属性目的：  (封装不是单纯意义上的隐藏)
     明确的区分内外,控制外部对隐藏的属性的操作行为

  封装方法属性目的：
     隔离复杂度   #  a=ATM()  a.withdraw()

# 1.封装数据属性：明确的区分内外,控制外部对隐藏的属性的操作行为
# 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('egon',18)
# p.tell_info()
# # p.set_info('EGON',38)
# p.set_info('EGON','18')
# p.tell_info()

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

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):
        self.name = name
        self.owner = owner

        self.__weight = weight
        self.__length = length

    def tell_area(self): # 对使用者来说 不用改变方式
        return self.__weight * self.__length

r = Room('卫生间','alex',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=33  # 不能赋值 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