标签：dict 语法 erro 区分 绑定 内部实现 方式 style 统一
一、封装
1.什么是封装？
在程序设计当中，封装是对具体对象的一种抽象，也就是说将某些部分隐藏起来，程序外部访问不到，其含义是其他程序无法调用的。
要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。
2.为什么要封装？
封装数据的主要原因是:保护隐私（把不想别人知道的东西封装起来）
封装方法的主要原因：隔离复杂度（比如：洗衣机，我们看见的就是一个黑匣子，其实里面有很多电器元件，对于用户来说，我们不清楚里面都有哪些元件，电视机把那些电器元件封装在黑匣子里，提供给用户的只是几个按钮接口，通过按钮来操作洗衣机）
3.被封装的两个特点：外界不能直接访问，内部依然可以使用。
二、封装两个层面
封装分为两层，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（这个接口我们暂时可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，而且可以在接口的实现上附加更多的逻辑，来控制使用者的访问）
第一层面的封装（什么都不用做）：创建类和和对象会分别创建二者的名称空间，我们只能用类名或者obj.的方式去访问里面的名字，这本身就是一种封装。
第二层的封装：类中把某些属性和方法隐藏起来（或者说定义成私有的），只在类的内部使用，外部无法访问，或者留下少量接口供外部访问。
在python中私有化的方法也比较简单，即在私有化的属性（包括方法，数据）名字前面加两个下划线就行。
类中所有双下划线开头的名称如_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是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是语法意义上的变形
这种自动变形的特点：
1.类中定义的__x只能在外部使用，如self.__x,引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变成了：_子类名__x，而父类中变形成了：_父类名__x，即双下划线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限值我们从外部直接访问属性，知道了类名和属性名就可拼出名字：类名_属性，然后就可以访问了，如a._A__N
2.变量的过程只在类的定义是发生一次，在定义后的赋值操作，不会变形
a = A() # 实例化对象a
print(a.__dict__) # 打印变形的内容
a._Y = 20 # 新增Y的值，此时加__不会变形
print(a.__dict__) # 打印变形的内容
========输出结果========
{‘_A__X‘:10}
{‘_A__X‘:10,‘__Y‘:20} # 发现后面的Y并没有变形
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
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
我们来看下fa被定义成私有的情况：
class A: # 把fa定义成私有的，即__fa
def __fa(self): # 在定义时就变形为_A__fa
print("from A")
def test(self):
self.__fa() # 只会与自己所在的类为准，即调用_A__fa
class B(A):
def __fa(self): # b调用的是test,跟这个没关系
print("from B")
b = B()
b.test()
====输出结果====
from A
三、特性（property）
1.什么是特性property
property是一种特殊的属性，在访问它时会执行一段功能（函数）然后返回值（就是装饰器）
注意：被property装饰的属性会优先于对象的属性被使用，而被propery装饰的属性，分成三种：property、被装饰的函数名.setter、被装饰的函数名.deleter(都是以装饰器的形式)。
class room: # 定义一个房间的类
def __init__(self,length,width,high):
self.length = length # 房间的长
self.width = width # 房间的宽
self.high = high # 房间的高
@property
def area(self): # 求房间的平方的功能
return self.length * self.width #房间的面积就是：长*宽
@property
def perimeter(self): # 求房间的周长的功能
return 2 * (self.length + self.width) # 公式为：（长+宽）*2
@property
def volume(self): # 求房间的体积的功能
return self.length * self.high #公式为：长*款*高
# 实例化一个对象r1
r1 = room(1, 2, 3)
# 可以像访问数据属性一样去访问area，会触发一个函数的执行，动态计算出一个值
print("r1,area:",r1.area)
# 同上 ，就不用想调用绑定方法一样，还得加括号才能运行
print("r1.perimeter:",r1.perimeter)
# 同上 就像是把运算过程封装到一个函数内部，我们不管过程，只要有结果就行
print("r1.volume:",r1.volume )
====输出答案====
r1,area: 2
r1.perimeter: 6
r1.volume: 3
此时的area、perimeter和volume不能被赋值。
2、为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的names是执行一个函数然后计算出来的，这种特性的使用方式遵循了统一访问原则。
class People: # 定义一个人的类
def __init__(self,name,sex):
self.name = name
self.sex = sex # p1.sex = "male",遇到property,优先使用
@property # 查看sex的值
def sex(self):
return self.__sex # 返回真正存值的地方
@sex.setter # 修改sex的值
def sex(self,value):
if not isinstance(value, str):# 在设定值之前进行类型检查
raise TypeError("性别必须是字符串类型") # 不是str类型时，主动抛出异常
self.__sex = value # 类型正确的时候，直接修改__sex的值，这是值真正存在的地方
# 这里sex前加"__",对sex变形，隐藏。
@sex.deleter # 删除sex
def sex(self):
del self.__sex
p1 = People("egon","male") # 实例化对象p1
print(p1.sex) # 查看p1的sex,此时要注意self.sex的优先级
p1.sex = "female"# 修改sex的值
print(p1.sex) # 查看修改后的p1的sex
print(p1.__dict__)# 查看p1的名称空间，此时里面有sex
del p1.sex # 删除p1的sex
print(p1.__dict__) # 查看p1的名称空间，此时发现里面已经没有sex了
=====输出结果=====
male
female
{‘name‘: ‘egon‘, ‘_People__sex‘: ‘female‘}
{‘name‘: ‘egon‘}
四、封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用者只知道一个接口（函数），只要接口（函数名）、参数不变，使用者的代码无需改变
class room: # 定义一个房间的类
def __init__(self,name,owner,length,width,high):
self.name = name
self,owner = owner
self.__length = length # 房间的长
self.__width = width # 房间的宽
self.__high = high # 房间的高
@property
def area(self): # 求房间的平方的功能
return self.__length * self.__width#对外提供的接口，隐藏了内部的实现细节，此时我们想求的是房间的面积就是：长 * 宽
实例化对象通过接口，调用相关属性得到想要的值：
r1 = room("客厅","michael","20","30","9") # 实例化一个对象r1
print(r1.area) # 通过接口 使用(area)，使用者得到了客厅的面积
====输出结果====
600 #得到了客厅的面积
扩展原有的代码，使功能增加：
class room: #定义一个房间的类
def __init__(self,name,owner,length,width,high):
self.name = name #房间名
self.owner = owner #房子的主人
self.__length = length #房间的长
self.__width = width #房间的宽
self.__high = high #房间的高
@property
def area(self): #对外提供的接口，隐藏内部实现
return self.__length * self.__width, self.__length * self.__width * self.__high #此时我们增加了求体积,
# 内部逻辑变了,只需增加这行代码就能简单实现,而且外部调用感知不到,仍然使
# 用该方法，但是功能已经增加了
对于类的使用者，仍然在调用area接口的人来说，根本无需改动自己的代码，就可以用上新功能：
r1 = room("客厅","michael",20,30,9) #实例化一个对象r1
print(r1.area) #通过接口使用（area），使用者得到了客厅的面积
--------------输出结果---------------
(600, 5400) #得到了新增的功能的值
标签：dict 语法 erro 区分 绑定 内部实现 方式 style 统一
原文地址：https://www.cnblogs.com/panshao51km-cn/p/11252754.html
