面向对象

面向对象 - 封装：
    封装：在类定义阶段，以__开头的属性名发生了变形 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