【2.0】Python面向对象之封装
【一】面向对象的三大特性
- 面向对象编程有三大特性：
- 封装、继承、多态
- 其中最重要的一个特性就是封装。
- 封装指的就是把数据与功能都整合到一起
- 听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。
- 除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口
【1】什么是封装
- 在程序设计中，封装（Encapsulation）是对具体对象的一种抽象
- 即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。
- 要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。
【2】为什么要封装
- 封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）
【3】封装的方法
-
你的身体没有一处不体现着封装的概念：
-
你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，）
-
你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
-
-
电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
-
快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
【二】隐藏属性
【1】隐藏属性方法
- Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的）
- 但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成
_类名__属性名的形式：
class Person:
# 变形为_Person__NAME
__NAME = "Dream"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Foo__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
# 变形为self._Person__run()
self.__run()
print(Person.__N)
# 报错AttributeError:类Person没有属性__N
obj = Person()
print(obj.__x)
# 报错AttributeError:对象obj没有属性__x
【2】问题
（1）隐藏属性访问
-
在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：
__类名__属性，然后就可以访问了， -
如
Person._Person__NAME，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。
class Person:
# 变形为_Person__NAME
__NAME = "Dream"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Foo__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
# 变形为self._Person__run()
self.__run()
# 查看当前类的名称空间
print(Person.__dict__)
# {'__module__': '__main__', '_Person__NAME': 'Dream', '__init__': <function Person.__init__ at 0x000001C4059513F0>, '_Person__run': <function Person.__run at 0x000001C405951B40>, 'walk': <function Person.walk at 0x000001C405951BD0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__NAME
print(Person._Person__NAME)
# 实例化得到类对象
person = Person()
# Dream
# 查看对象的名称空间
print(person.__dict__)
# {'_Person__age': 18}
# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__age
print(person._Person__age)
# 18
（2）隐藏方法变形
- 在类内部是可以直接访问双下滑线开头的属性的，比如
self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。
class Person:
# 变形为_Person__NAME
__NAME = "Dream"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Foo__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
# 变形为self._Person__run()
self.__run() # 等同于 self._Person__run()
print(self.__NAME) # 等同于 print(self._Person__age)
（3）变形操作只会发生一次
- 变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。
class Person:
# 变形为_Person__NAME
__NAME = "Dream"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Foo__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
# 变形为self._Person__run()
self.__run() # 等同于 self._Person__run()
print(self.__NAME) # 等同于 print(self._Person__age)
# 修改类的变量
Person.__NAME = "Hope"
# 查看内存空间 --- 发现并没有被修改
print(Person.__dict__)
# {'__module__': '__main__', '_Person__NAME': 'Dream', '__init__': <function Person.__init__ at 0x00000260E28E13F0>, '_Person__run': <function Person.__run at 0x00000260E28E1B40>, 'walk': <function Person.walk at 0x00000260E28E1BD0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, '__NAME': 'Hope'}
# 实例化得到类对象
person = Person()
# Dream
# 修改对象变量
person.__sex = "男"
person.__age = 22
# 查看对象的名称空间 --- 新增了相应的键值
print(person.__dict__)
# {'_Person__age': 18, '__sex': '男', '__age': 22}
# 可以直接根据键取值
print(person.__sex)
# 男
【三】开放接口
- 定义属性就是为了使用，所以隐藏并不是目的
【1】隐藏数据属性
- 将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
（1）不符合要求会抛出异常
class Teacher:
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):
raise TypeError('姓名必须是字符串类型')
if not isinstance(age, int):
raise TypeError('年龄必须是整型')
self.__name = name
self.__age = age
# 实例化类得到对象
teacher = Teacher("dream", 18)
# 代用对象中的方法，修改对象的信息
# age 必须是数字类型，但是给了字符串，所以一定会报错
teacher.set_info('hope', '22')
r'''
Traceback (most recent call last):
File "E:\PythonProjects\10面向对象\02封装.py", line 140, in <module>
teacher.set_info('hope', '22')
File "E:\PythonProjects\10面向对象\02封装.py", line 131, in set_info
raise TypeError('年龄必须是整型')
TypeError: 年龄必须是整型
'''
（2）符合要求修改完成
class Teacher:
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):
raise TypeError('姓名必须是字符串类型')
if not isinstance(age, int):
raise TypeError('年龄必须是整型')
self.__name = name
self.__age = age
# 实例化类得到对象
teacher = Teacher("dream", 18)
# 查看对象的信息
teacher.tell_info()
# 姓名:dream,年龄:18
# 调用对象的方法修改对象的信息 , 符合要求就能修改成功
teacher.set_info('Hope', 22)
# 查看对象的信息
teacher.tell_info()
# 姓名:Hope,年龄:22
【2】隐藏函数属性
- 目的的是为了隔离复杂度
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
- 比如插卡、身份认证、输入金额、打印小票、取钱等
- 而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
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()
obj = ATM()
obj.withdraw()
# 插卡
# 用户认证
# 输入取款金额
# 打印账单
# 取款
【3】小结
- 总结隐藏属性与开放接口，本质就是为了明确地区分内外，类内部可以修改封装内的东西而不影响外部调用者的代码；
- 而类外部只需拿到一个接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变代码。
- 这就提供一个良好的合作基础，只要接口这个基础约定不变，则代码的修改不足为虑。
【四】装饰器property
【1】什么是property
- property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
【2】BMI例子
-
BMI指数是用来衡量一个人的体重与身高对健康影响的一个指标
-
成人的BMI数值：
- 过轻：低于18.5
- 正常：18.5-23.9
- 过重：24-27
- 肥胖：28-32
- 非常肥胖, 高于32
-
计算公式
体质指数（BMI）=体重（kg）÷身高^2（m）EX：70kg÷（1.75×1.75）=22.86
-
身高或体重是不断变化的
- 因而每次想查看BMI值都需要通过计算才能得到，但很明显BMI听起来更像是一个特征而非功能，为此Python专门提供了一个装饰器property
- 可以将类中的函数“伪装成”对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果
class People:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
@property
def bmi(self):
return self.weight / (self.height ** 2)
obj = People('dream', 62, 1.70)
# 触发方法bmi的执行，将obj自动传给self，执行后返回值作为本次引用的结果
# 正常我们调用对象的方法应该是 obj.bmi() 但是这里我们没有 加 () 就调用成功了
print(obj.bmi)
# 21.453287197231838
【3】为什么要用property
-
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
-
面向对象的封装有三种方式:
- 【public】
- 这种其实就是不封装,是对外公开的
- 【protected】
- 这种封装方式对外不公开
- 但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
- 【private】
- 这种封装对谁都不公开
- 【public】
-
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class Foo:
def __init__(self, val):
# 将属性隐藏起来
self.__NAME = val
@property
def name(self):
return self.__NAME
@name.setter
def name(self, value):
# 在设定值之前进行类型检查
if not isinstance(value, str):
raise TypeError('%s must be str' % value)
# 通过类型检查后,将值value存放到真实的位置self.__NAME
self.__NAME = value
@name.deleter
def name(self):
raise PermissionError('Can not delete')
f = Foo('dream')
print(f.name)
# 触发name.setter装饰器对应的函数name(f,'Hope')
f.name = 'Hope'
# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
f.name = 123
# 触发name.deleter对应的函数name(f),抛出异常PermissionError
del f.name
class Foo:
def __init__(self, val):
# 将属性隐藏起来
self.__NAME = val
def get_name(self):
return self.__NAME
def set_name(self, value):
# 在设定值之前进行类型检查
if not isinstance(value, str):
raise TypeError('%s must be str' % value)
# 通过类型检查后,将值value存放到真实的位置self.__NAME
self.__NAME = value
def del_name(self):
raise PermissionError('Can not delete')
# 不使用装饰器，而是使用 包装的 形式
name = property(get_name, set_name, del_name)
f = Foo('dream')
print(f.name)
# 触发name.setter装饰器对应的函数name(f,'Hope')
f.name = 'Hope'
# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
f.name = 123
# 触发name.deleter对应的函数name(f),抛出异常PermissionError
del f.name
【五】封装和扩展性
- 封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；
- 而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。
- 这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
【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
【2】使用者
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
# 使用者
room = Room('卧室', 'dream', 20, 20, 20)
# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 400
【3】更好的扩展性
# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
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
# 对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
room = Room('卧室', 'dream', 20, 20, 20)
# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 8000
本文来自博客园，作者：Chimengmeng，转载请注明原文链接：https://www.cnblogs.com/dream-ze/p/17867246.html
