21.1、封装介绍：
1、从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八等一起装进麻袋，
然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的
2、封装的用法：
（1）在 python 中用双下划线开头的方式将属性隐藏起来（设置成私有的），其实这仅仅是一种变形
操作，且仅仅只在类定义阶段发生变形，类中所有双下划线开头的名称如__x都会在类定义时自动变
形成：_类名__x的形式。
（2）这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名
字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，
仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。
通过 __<属性名> 形式在类内部定义的属性，在类外部是无法通过 __<属性名> 的形式访问，在类的内部
可以通过 __<属性名> 的形式访问，但在类的外部可以通过 _<类名>__<属性名> 的形式进行访问。
（3）变形的过程只在类的定义时发生一次，在定义后的赋值操作，不会变形。
3、封装的意义：
（1）封装不是单纯意义的隐藏，封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不
能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们对外提供操作该
数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。
封装使得类实现者可以修改封装内的东西而不影响外部调用者的代码，而外部使用者只知道一个接口(函数)，
只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，
只要接口这个基础约定不变，则代码改变不足为虑。
（2）封装方法举例：
1）电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概
念，所以说，封装并不是单纯意义的隐藏！！！
2）快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了；
3）提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与
接口的概念还不一样，接口代表一组接口函数的集合体。
4、了解：
python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入，
但是你from module import _private_module依然是可以导入的，其实很多时候你去调用一个模块的功能时会遇到单下划线开头的
(socket._socket,sys._home,sys._clear_type_cache)，这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只
不过显得稍微傻逼一点点，python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__。
21.2、示例：
1、基础：
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
# 公有对象数据属性
self.__width=width
self.__length=length
self.__high=high
# 私有对象数据属性
def tell_area(self):
return self.__width * self.__length *self.__high
# 公有函数属性
def tell_width(self):
return self.__width
# 开放私有对象属性接口
def tell_length(self):
return self.__length
# 开放私有对象属性接口
r1=Room('beyond','lc',20,20,10)
print(r1.name)
print(r1._Room__width)
# beyond
# 20
r1.__lc=100
r1.__lc2=200
print(r1.__lc * r1.__lc2)
print(r1.__dict__)
# 变形的过程只在类的定义时发生一次，在定义后的赋值操作，不会变形。
# 20000
# {'name': 'beyond', 'owner': 'lc', '_Room__width': 20, '_Room__length': 20, '_Room__high': 10, '__lc': 100, '__lc2': 200}
print(r1.tell_area())
print(r1.tell_width() * r1.tell_width())
# 4000
# 400
2、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的：
（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()
# from B
（2）把fa定义成私有的，即__fa：
class A:
def __fa(self):
print('from A')
# 在定义时就变形为_A__fa
def test(self):
self.__fa()
# 只会与自己所在的类为准,即调用_A__fa
class B(A):
def fa(self):
print('from B')
b = B()
b.test()
# from A