接着上面的一篇继续往下：
如何隐藏
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
class A:
__x = 1 # _A__x = 1
def __init__(self, name):
self.__name = name # self._A__name = name
def __fun1(self):
print("run fun1.......")
def fun2(self):
self.__fun1() # self._A__fun1()
print("run fun2.......")
a = A("Astro")
# print(a.x) # 报错 无法访问到 x AttributeError: 'A' object has no attribute 'x'
print(A.__dict__)
# {'__module__': '__main__', '_A__x': 1, ........}
# _A__x
print(a._A__x) # 1
a.fun2()
# run fun1.......
# run fun2.......
其实这仅仅这是一种变形操作
类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
这种变形的特点：
- 在类外部无法直接obj.__AttrName
- 在类内部是可以直接使用：obj.__AttrName
- 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2、变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形
a.__g = "gd"
print(a.__dict__)
# {'_A__name': 'Astro', '__g': 'gd'}
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
# 正常情况
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() 只会与自己所在的类为准,即调用_A__fa
class B(A):
def __foo(self): #_B__foo
print('B.foo')
b=B()
b.bar()
# A.bar
# A.foo
封装的意义
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): # 判断 传进来的 name 是不是 str 类型
print("name must be str type")
return
if not isinstance(age, int):
print("age must be int type")
return
self.__name = name
self.__age = age
p = People("Astro", 15)
p.tell_info() # name:Astro age:15
# 通过调用 tell_info 这个接口，来间接访问 name 和 age
p.set_info("茶水博士", 60)
p.tell_info() # name:茶水博士 age:60
p.set_info(1111,222) # name must be str type
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.特性(Property)
什么是特性 property
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("astro", 55, 1.73)
# print(p.bmi()) # 18.376825152861773
# 我们想得到 bmi 这个值，需要调用 p.bmi() ,如果在 def bmi(self) 上面加 @property ,即可直接调用了
print(p.bmi) # 18.376825152861773
p.height = 1.8
print(p.bmi) # 16.975308641975307
p.bmi = 20 # 报错 AttributeError: can't set attribute
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类公开
【private】
这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class People:
def __init__(self, name):
self.__name = name
@property
def name(self):
return self.__name # obj.name访问的是self.__NAME(这也是真实值的存放位置)
@name.setter
def name(self, val):
if not isinstance(val, str): # 在设定值之前进行类型检查
print("姓名必须为字符串")
return
self.__name = val
@name.deleter
def name(self):
print("deleter....")
print("不允许删除....")
p = People('astro')
print(p.name) # astro 此时可以直接访问 name 属性了
p.name = 'Astro'
print(p.name) # Astro name 别改变了，执行了 @name.setter 下的方法
p.name = 111 # 姓名必须为字符串
del p.name # deleter.... 不允许删除....