面向对象编程(封装、封装的意义、封装与扩展性、@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的使用
Python内置的@property装饰器就是负责把一个方法变成属性调用的：
@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：
注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。
还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：
小结
@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。
property :
@property
def bmi(self): 必须有个返回值
print(p.bmi) 可以使 函数属性 伪装成 数据属性 bmi 是名词
p.bmi=23 # 不能赋值 can't set attribute bmi 实质是个方法
总结：通过计算得来的方法 可以通过@property 伪装成数据属性
@property 查看 必须有返回值
@name.setter 修改
@name.deleter 删除
练习
请利用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution：
class Screen(object): @property def resolution(self): return self.width * self.height # 测试: s = Screen() s.width = 1024 s.height = 768 print('resolution =', s.resolution) if s.resolution == 786432: print('测试通过!') else: print('测试失败!') #输出 resolution = 786432 测试通过!
