1、引子
从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的
先看如何隐藏
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
class A: __x = 100 # 类的私有数据属性 y = 200 def __init__(self, name): self.__name = name # 对象的私有属性 def __foo(self): # 类的私有方法 print('run foo')
print(A.y) # print(A.__x) # 私有数据属性 # '_A__x': 100, # print(A.__foo) # {'_A__foo': <function A.__foo at 0x01FC17C8>, print(A.__dict__) print(A._A__x) print(A._A__foo) a = A('alex') print(a.__dict__) # print(a.__name) # {'_A__name': 'alex'} print(a._A__name)
### 运行结果
200
{'__weakref__': <attribute '__weakref__' of 'A' objects>, '__module__': '__main__', '__init__': <function A.__init__ at 0x01F21738>, '_A__x': 100, '_A__foo': <function A.__foo at 0x01F217C8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__doc__': None, 'y': 200}
100
<function A.__foo at 0x01F217C8>
{'_A__name': 'alex'}
alex
2、私有属性，方法的实质
#其实这仅仅这是一种变形操作 #类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print('from A') def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到. #A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
3、特点
class A: __x = 100 # 类的私有数据属性 y = 200 def __init__(self, name): self.__name = name # 对象的私有属性 def __foo(self): # 类的私有方法 print('run foo') def bar(self): # 内部可以调用私有属性，方法 self.__foo() # self._A__foo print(self.__name) print(A.__x) a = A('alex') a.bar()
## 运行结果 run foo alex 100
（2）子类无法覆盖父类的__开头的属性，方法
class Foo: def func(self): # _Foo_func print('run foo') class Bar(Foo): def func(self): # _Bar_func print('new from bar') b = Bar() b.func() # 子类覆盖了父类的方法
- 外部不可以调用私有属性，方法
class Foo:
def __func(self): # _Foo_func
print('run foo')
class Bar(Foo):
def __func(self): # _Bar_func
print('new from bar')
b = Bar()
b.func() # 子类覆盖了父类的方法
4、注意的问题
这种变形需要注意的问题是：
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2、变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
5、封装的意义
1）.封装数据属性，明确的区分内外
class People:
def __init__(self, name, age):
self.__name = name
self.__age = age
def tell_info(self):
print('%s - %s'%(self.__name, self.__age))
def set_info(self, name, age):
self.__name = name
self.__age = age
p = People('alex', 14)
# print(p.__name)
p.tell_info()
p.set_info('jack', 33)
p.tell_info()
将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制
class People: def __init__(self, name, age): self.__name = name self.__age = age def tell_info(self): print('%s - %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('alex', 14) # print(p.__name) p.tell_info() p.set_info(11, '33') 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()
6、封装与扩展性
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', 80, 80) print(r.tell_area())
