【一】面向对象的三大特性#

面向对象编程有三大特性：
- 封装、继承、多态
其中最重要的一个特性就是封装。
- 封装指的就是把数据与功能都整合到一起
听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。
除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口

【1】什么是封装#

在程序设计中，封装（Encapsulation）是对具体对象的一种抽象
- 即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。
- 要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。

【2】为什么要封装#

封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）

【3】封装的方法#

你的身体没有一处不体现着封装的概念：
- 你的身体把膀胱尿道等等这些尿的功能隐藏了起来，然后为你提供一个尿的接口就可以了（接口就是你的。。。，）
- 你总不能把膀胱挂在身体外面，上厕所的时候就跟别人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

【二】隐藏属性#

【1】隐藏属性方法#

Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的）
但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成_类名__属性名的形式：

1
class Person:
2
    # 变形为_Person__NAME
3
    __NAME = "Dream"
4

5
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
6
    def __init__(self):
7
        # 变形为self._Person__age
8
        self.__age = 18
9

10
    # 变形为_Foo__run
11
    def __run(self):
12
        print('__f1 run')
13

14
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
15
    def walk(self):
16
        # 变形为self._Person__run()
17
        self.__run()
18

19

20
print(Person.__N)
21
# 报错AttributeError:类Person没有属性__N
22

23
obj = Person()
24
print(obj.__x)
25
# 报错AttributeError:对象obj没有属性__x

【2】问题#

（1）隐藏属性访问#

在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：__类名__属性，然后就可以访问了，
如Person._Person__NAME，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。

1
class Person:
2
    # 变形为_Person__NAME
3
    __NAME = "Dream"
4

5
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
6
    def __init__(self):
7
        # 变形为self._Person__age
8
        self.__age = 18
9

10
    # 变形为_Foo__run
11
    def __run(self):
12
        print('__f1 run')
13

14
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
15
    def walk(self):
16
        # 变形为self._Person__run()
17
        self.__run()
18

19

20
# 查看当前类的名称空间
21
print(Person.__dict__)
22
# {'__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}
23

24
# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__NAME
25
print(Person._Person__NAME)
26

27
# 实例化得到类对象
28
person = Person()
29
# Dream
30

31
# 查看对象的名称空间
32
print(person.__dict__)
33
# {'_Person__age': 18}
34

35
# 发现可以通过 特定的方法，仍然可以访问到相应的属性 _Person__age
36
print(person._Person__age)
37
# 18

（2）隐藏方法变形#

在类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。

1
class Person:
2
    # 变形为_Person__NAME
3
    __NAME = "Dream"
4

5
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
6
    def __init__(self):
7
        # 变形为self._Person__age
8
        self.__age = 18
9

10
    # 变形为_Foo__run
11
    def __run(self):
12
        print('__f1 run')
13

14
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
15
    def walk(self):
16
        # 变形为self._Person__run()
17
        self.__run()  # 等同于 self._Person__run()
18
        print(self.__NAME)  # 等同于 print(self._Person__age)

（3）变形操作只会发生一次#

变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。

1
class Person:
2
    # 变形为_Person__NAME
3
    __NAME = "Dream"
4

5
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
6
    def __init__(self):
7
        # 变形为self._Person__age
8
        self.__age = 18
9

10
    # 变形为_Foo__run
11
    def __run(self):
12
        print('__f1 run')
13

14
    # 定义函数时，会检测函数语法，所以__开头的属性也会变形
15
    def walk(self):
16
        # 变形为self._Person__run()
17
        self.__run()  # 等同于 self._Person__run()
18
        print(self.__NAME)  # 等同于 print(self._Person__age)
19

20

21
# 修改类的变量
22
Person.__NAME = "Hope"
23

24
# 查看内存空间 --- 发现并没有被修改
25
print(Person.__dict__)
26
# {'__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'}
27

28
# 实例化得到类对象
29
person = Person()
30
# Dream
31

32
# 修改对象变量
33
person.__sex = "男"
34
person.__age = 22
35

36
# 查看对象的名称空间 --- 新增了相应的键值
37
print(person.__dict__)
38
# {'_Person__age': 18, '__sex': '男', '__age': 22}
39

40
# 可以直接根据键取值
41
print(person.__sex)
42
# 男

【三】开放接口#

定义属性就是为了使用，所以隐藏并不是目的

【1】隐藏数据属性#

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制

（1）不符合要求会抛出异常#

1
class Teacher:
2
    def __init__(self, name, age):
3
        # 将名字和年纪都隐藏起来
4
        self.__name = name
5
        self.__age = age
6

7
    # 对外提供访问老师信息的接口
8
    def tell_info(self):
9
        print('姓名:%s,年龄:%s' % (self.__name, self.__age))
10

11
    # 对外提供设置老师信息的接口，并附加类型检查的逻辑
12
    def set_info(self, name, age):
13
        if not isinstance(name, str):
14
            raise TypeError('姓名必须是字符串类型')
15
        if not isinstance(age, int):
16
            raise TypeError('年龄必须是整型')
17
        self.__name = name
18
        self.__age = age
19

20

21
# 实例化类得到对象
22
teacher = Teacher("dream", 18)
23
# 代用对象中的方法，修改对象的信息
24
# age 必须是数字类型，但是给了字符串，所以一定会报错
25
teacher.set_info('hope', '22')
26
r'''
27
Traceback (most recent call last):
28
  File "E:\PythonProjects\10面向对象\02封装.py", line 140, in <module>
29
    teacher.set_info('hope', '22')
30
  File "E:\PythonProjects\10面向对象\02封装.py", line 131, in set_info
31
    raise TypeError('年龄必须是整型')
32
TypeError: 年龄必须是整型
33
'''

（2）符合要求修改完成#

1
class Teacher:
2
    def __init__(self, name, age):
3
        # 将名字和年纪都隐藏起来
4
        self.__name = name
5
        self.__age = age
6

7
    # 对外提供访问老师信息的接口
8
    def tell_info(self):
9
        print('姓名:%s,年龄:%s' % (self.__name, self.__age))
10

11
    # 对外提供设置老师信息的接口，并附加类型检查的逻辑
12
    def set_info(self, name, age):
13
        if not isinstance(name, str):
14
            raise TypeError('姓名必须是字符串类型')
15
        if not isinstance(age, int):
16
            raise TypeError('年龄必须是整型')
17
        self.__name = name
18
        self.__age = age
19

20

21
# 实例化类得到对象
22
teacher = Teacher("dream", 18)
23
# 查看对象的信息
24
teacher.tell_info()
25
# 姓名:dream,年龄:18
26

27
# 调用对象的方法修改对象的信息 , 符合要求就能修改成功
28
teacher.set_info('Hope', 22)
29

30
# 查看对象的信息
31
teacher.tell_info()
32
# 姓名:Hope,年龄:22

【2】隐藏函数属性#

目的的是为了隔离复杂度
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
  - 比如插卡、身份认证、输入金额、打印小票、取钱等
- 而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来

1
class ATM:
2
    # 插卡
3
    def __card(self):
4
        print('插卡')
5

6
    # 身份认证
7
    def __auth(self):
8
        print('用户认证')
9

10
    # 输入金额
11
    def __input(self):
12
        print('输入取款金额')
13

14
    # 打印小票
15
    def __print_bill(self):
16
        print('打印账单')
17

18
    # 取钱
19
    def __take_money(self):
20
        print('取款')
21

22
    # 取款功能
23
    def withdraw(self):
24
        self.__card()
25
        self.__auth()
26
        self.__input()
27
        self.__print_bill()
28
        self.__take_money()
29

30

31
obj = ATM()
32
obj.withdraw()
33
# 插卡
34
# 用户认证
35
# 输入取款金额
36
# 打印账单
37
# 取款

【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
- 可以将类中的函数“伪装成”对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果

1
class People:
2
    def __init__(self, name, weight, height):
3
        self.name = name
4
        self.weight = weight
5
        self.height = height
6

7
    @property
8
    def bmi(self):
9
        return self.weight / (self.height ** 2)
10

11

12
obj = People('dream', 62, 1.70)
13

14
# 触发方法bmi的执行，将obj自动传给self，执行后返回值作为本次引用的结果
15
# 正常我们调用对象的方法应该是 obj.bmi() 但是这里我们没有 加 () 就调用成功了
16
print(obj.bmi)
17
# 21.453287197231838

【3】为什么要用property#

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
面向对象的封装有三种方式:
- 【public】
  - 这种其实就是不封装,是对外公开的
- 【protected】
  - 这种封装方式对外不公开
  - 但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
- 【private】
  - 这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

1
class Foo:
2
    def __init__(self, val):
3
        # 将属性隐藏起来
4
        self.__NAME = val
5

6
    @property
7
    def name(self):
8
        return self.__NAME
9

10
    @name.setter
11
    def name(self, value):
12
        # 在设定值之前进行类型检查
13
        if not isinstance(value, str):
14
            raise TypeError('%s must be str' % value)
15
        # 通过类型检查后,将值value存放到真实的位置self.__NAME
16
        self.__NAME = value
17

18
    @name.deleter
19
    def name(self):
20
        raise PermissionError('Can not delete')
21

22

23
f = Foo('dream')
24
print(f.name)
25

26
# 触发name.setter装饰器对应的函数name(f,'Hope')
27
f.name = 'Hope'
28

29
# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
30
f.name = 123
31

32
# 触发name.deleter对应的函数name(f),抛出异常PermissionError
33
del f.name

1
class Foo:
2
    def __init__(self, val):
3
        # 将属性隐藏起来
4
        self.__NAME = val
5

6
    def get_name(self):
7
        return self.__NAME
8

9
    def set_name(self, value):
10
        # 在设定值之前进行类型检查
11
        if not isinstance(value, str):
12
            raise TypeError('%s must be str' % value)
13
        # 通过类型检查后,将值value存放到真实的位置self.__NAME
14
        self.__NAME = value
15

16
    def del_name(self):
17
        raise PermissionError('Can not delete')
18

19
    # 不使用装饰器，而是使用 包装的 形式
20
    name = property(get_name, set_name, del_name)
21

22

23
f = Foo('dream')
24
print(f.name)
25

26
# 触发name.setter装饰器对应的函数name(f,'Hope')
27
f.name = 'Hope'
28

29
# 触发name.setter对应的的函数name(f,123),抛出异常TypeError
30
f.name = 123
31

32
# 触发name.deleter对应的函数name(f),抛出异常PermissionError
33
del f.name

【五】封装和扩展性#

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；
而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。
这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

【1】设计者#

1
class Room:
2
    def __init__(self, name, owner, width, length, high):
3
        self.name = name
4
        self.owner = owner
5
        self.__width = width
6
        self.__length = length
7
        self.__high = high
8

9
    # 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
10
    def tell_area(self):
11
        return self.__width * self.__length

【2】使用者#

1
class Room:
2
    def __init__(self, name, owner, width, length, high):
3
        self.name = name
4
        self.owner = owner
5
        self.__width = width
6
        self.__length = length
7
        self.__high = high
8

9
    # 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
10
    def tell_area(self):
11
        return self.__width * self.__length
12

13

14
# 使用者
15
room = Room('卧室', 'dream', 20, 20, 20)
16
# 使用者调用接口tell_area
17
result = room.tell_area()
18
print(result)
19
# 400

【3】更好的扩展性#

1
# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
2
class Room:
3
    def __init__(self, name, owner, width, length, high):
4
        self.name = name
5
        self.owner = owner
6
        self.__width = width
7
        self.__length = length
8
        self.__high = high
9

10
    # 对外提供的接口，隐藏内部实现，
11
    # 此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,
12
    # 而且外部调用感知不到,仍然使用该方法，但是功能已经变了
13
    def tell_area(self):
14
        return self.__width * self.__length * self.__high
15

16

17
# 对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
18
room = Room('卧室', 'dream', 20, 20, 20)
19

20
# 使用者调用接口tell_area
21
result = room.tell_area()
22
print(result)
23
# 8000

音乐

音乐

【一】面向对象的三大特性#

【1】什么是封装#

【2】为什么要封装#

【3】封装的方法#

【二】隐藏属性#

【1】隐藏属性方法#

【2】问题#

（1）隐藏属性访问#

（2）隐藏方法变形#

（3）变形操作只会发生一次#

【三】开放接口#

【1】隐藏数据属性#

（1）不符合要求会抛出异常#

（2）符合要求修改完成#

【2】隐藏函数属性#

【3】小结#

【四】装饰器property#

【1】什么是property#

【2】BMI例子#

【3】为什么要用property#

【五】封装和扩展性#

【1】设计者#

【2】使用者#

【3】更好的扩展性#

支持与分享

音乐

Python面向对象之封装

【一】面向对象的三大特性#

【1】什么是封装#

【2】为什么要封装#

【3】封装的方法#

【二】隐藏属性#

【1】隐藏属性方法#

【2】问题#

（1）隐藏属性访问#

（2）隐藏方法变形#

（3）变形操作只会发生一次#

【三】开放接口#

【1】隐藏数据属性#

（1）不符合要求会抛出异常#

（2）符合要求修改完成#

【2】隐藏函数属性#

【3】小结#

【四】装饰器property#

【1】什么是property#

【2】BMI例子#

【3】为什么要用property#

【五】封装和扩展性#

【1】设计者#

【2】使用者#

【3】更好的扩展性#

支持与分享