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
测试通过!
来源：oschina
链接：https://my.oschina.net/u/4403899/blog/3991213