数据的封装 -- 保护隐私
方法的封装 -- 隔离复杂度
封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）
第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装
注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口
第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。
封装
在python中用双下划线的方式实现隐藏属性（设置成私有的）
封装 隐藏接口
class A:
__x = 1 #
def __test(self):
print('from A')
print(A.__dict__)
结果：
{'module': 'main', '_A__x': 1, '_A__test': <function A.__test at 0x000000000231BB70>, 'dict': <attribute 'dict' of 'A' objects>, 'weakref': <attribute 'weakref' of 'A' objects>, 'doc': None}
从打印的字典中可以查看到__A被隐藏成了_A__X,前面加上的_类的名字
class A:
__x = 1
def __test(self):
print('from A')
# print(A.__dict__)
# print(A._A__x)
a = A()
A._A__test(123123) # 直接使用类的时候用函数需要传入参数
# print(a._A__x)
# a._A__test() # 实例化后不用传入参数self
__名字只有在类中定义的时候才会产生变形，当类和对象已经产生了，就不会有变形的效果，可以直接拿来用，相当于普通的变量
class B: # 已经产生了类
pass
B.__x = 1 # 在类的外面定义
print(B.__dict__)
print(B.__x)
结果：
{'module': 'main', 'dict': <attribute 'dict' of 'B' objects>, 'weakref': <attribute 'weakref' of 'B' objects>, 'doc': None, '__x': 1}
1
从字典中可以看到， '__x': 1 没有变形成_B__x
class B: # 已经产生了类
pass
b = B() # 已经实例化了
b.__x = 1
print(b.__x)
print(b.__dict__)
结果：
1
{'__x': 1}
查找的顺序
class A:
def fa(self):
print("from A")
def test(self):
self.fa()
class B(A):
def fa(self):
print("from B ")
b = B()
b.test() # b.txt --B --A --b.fa
结果：
from B
实例化后b.txt先从B中寻找，B中没有，从父类A中寻找，A中的test下面的执行的是self.fa(),实际的self还是传递的b,就是b.fa(),所以执行的还是B中的fa，所以运行的结果是 from B
把B中的注释
class A:
def fa(self):
print("from A")
def test(self):
self.fa()
class B(A):
pass
b = B()
b.test() # b.txt --B --A --
结果：
from A
实际的原理就是b.test==b.fa()
class A:
def __fa(self): # _A__fa
print("from A")
def test(self):
self.__fa() # self._A__test
class B(A):
# def __fa(self): # _B__fa
# print("from B ")
pass
b = B()
b.test() # b.txt --B --A
结果：
from A
小练习
class A:
def __fa(self): # _A__fa
print("from A")
def test(self):
self.__fa() # self._A__test
class B(A):
# def __fa(self): # _B__fa
# print("from B ")
pass
b = B()
b.test() # b.txt --B --A
原理
查找的顺序
class A:
def fa(self):
print("from A")
def test(self):
self.fa()
class B(A):
def fa(self):
print("from B ")
b = B()
b.test() # b.txt --B --A --b.fa
结果：
from B
实例化后b.txt先从B中寻找，B中没有，从父类A中寻找，A中的test下面的执行的是self.fa(),实际的self还是传递的b,就是b.fa(),所以执行的还是B中的fa，所以运行的结果是 from B
把B中的注释
class A:
def fa(self):
print("from A")
def test(self):
self.fa()
class B(A):
pass
b = B()
b.test() # b.txt --B --A --
结果：
from A
实际的原理就是b.test==b.fa()
封装的接口函数
在类的内部可以用__名字访问到变形的属性
对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了
class A:
def __init__(self):
self.__x=1
def tell(self):
print(self.__x) # 在类的内部可以直接使用__名字访问到变形的属性
a=A()
print(a.__dict__)
# print(a.__x)
a.tell() # 可以通过调用内部的函数进行访问
模拟len()，通过调用函数的接口实现
>>> a = 'hello'
>>> l =[1,2,3,4]
>>> def func(obj):
... return obj.__len__()
...
>>> func(a)
5
>>> func(l)
4
>>>