【Python高级编程】封装
授课进程
1、封装
封装(encapsulation)又叫隐藏实现(Hiding the implementation)。就是只公开代码单元的对外接口，而隐藏其具体实现。
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
(a) 将内容封装到某处
(b) 从某处调用被封装的内容
第一步：将内容封装到某处
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Foo('wupeiqi', 18) # 将wupeiqi和18分装到object1的name和age属性中
obj2 = Foo('alex', 73) # 将alex和73分装到object2的name和age属性中
self 是一个形式参数，当执行 obj1 = Foo(‘wupeiqi’, 18 ) 时，self 等于 obj1；当执行 obj2 = Foo(‘alex’, 78 ) 时，self 等于 obj2。所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
-
通过对象直接调用
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Foo('wupeiqi', 18)
print(obj1.name) # 直接调用obj1对象的name属性
print(obj1.age) # 直接调用obj1对象的age属性
obj2 = Foo('alex', 73)
print(obj2.name) # 直接调用obj2对象的name属性
print(obj2.age) # 直接调用obj2对象的age属性
-
通过self间接调用
执行类中的方法时，需要通过self间接调用被封装的内容
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self):
print (self.name)
print (self.age)
obj1 = Foo('wupeiqi', 18)
obj1.detail()
# Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail()
# Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。
函数与面向对象比较
# 函数
def kanchai(name, age, gender):
print （"%s,%s岁,%s,上山去砍柴" %(name, age, gender)）
def qudongbei(name, age, gender):
print （"%s,%s岁,%s,开车去东北" %(name, age, gender)）
def dabaojian(name, age, gender):
print （"%s,%s岁,%s,最爱大保健" %(name, age, gender)）
kanchai('小明', 10, '男')
qudongbei('小明', 10, '男')
dabaojian('小明', 10, '男')
kanchai('老李', 90, '男')
qudongbei('老李', 90, '男')
dabaojian('老李', 90, '男')
# 面向对象
class Foo:
def __init__(self, name, age ,gender):
self.name = name
self.age = age
self.gender = gender
def kanchai(self):
print （"%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)）
def qudongbei(self):
print （"%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)）
def dabaojian(self):
print （"%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)）
xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()
laoli = Foo('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()
上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了… ；而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。
2、私有化
类的私有属性。在属性前加两个下划线开头，声明该属性为私有，在类的内部使用，不能在类地外部被使用或直接访问。
类的私有方法。在方法前加两个下划线开头，声明该方法为私有方法，在类的内部调用，不能在类地外部调用。
class students:
def __init__(self):
self.name = '小明'
#私有属性
self.__age = 22
self.__red() #私有方法可以在类内部调用
#私有方法
def __red(self):
print('%s在读书'%self.name)
def ages(self):
print('%s今年%d岁了'%(self.name,self.__age))#私有属性在类内部调用
s = students()
print(s.name)
s.ages()
'''
运行结果如下：
小明在读书
小明
小明今年22岁了
'''
从上面例子可以看出，属性和方法私有化后可以在类内部调用，但在类的外面是无法直接调用的。
还是上面的例子，我们看下在实例化类后调用一下dict方法，分析下结果：
class students:
def __init__(self):
self.name = '小明'
#私有属性
self.__age = 22
self.__red() #私有方法可以在类内部调用
#私有方法
def __red(self):
print('%s在读书'%self.name)
def ages(self):
print('%s今年%d岁了'%(self.name,self.__age))#私有属性在类内部调用
s = students()
print(s.__dict__)
'''
运行结果如下：
小明在读书
{'name': '小明', '_students__age': 22}
'''
dict方法是以字典的方式返回了构造方法里初始化的属性，从结果可以看出私有化属性名 _age在程序运行时对原属性名做了改变，在前面加上了一个带下划线的类名。我们可以试验一下，在类外面调用私有属性、方法时在前面加上students。
class students:
def __init__(self):
self.name = '小明'
#私有属性
self.__age = 22
# self.__red() #私有方法可以在类内部调用
#私有方法
def __red(self):
print('%s在读书'%self.name)
def ages(self):
print('%s今年%d岁了'%(self.name,self.__age))#私有属性在类内部调用
s = students()
print(s._students__age)
s._students__red()
'''
运行结果如下：
22
小明在读书
'''
从结果可以看出，私有化属性、和方法在类外面还有可以调用的。其实python中属性、方法的私有化并不是真正意义上的私有化，这只是python耍了一个小聪明，在属性、方法前面加上两个下划线后，在程序解释运行时会在前面自动加一个带下划线的类名。
