Python——封装

发表于 | 分类于 | | 阅读数
字数统计: 801 | 阅读时长 ≈ 3

封装

什么是封装？

封指的是隐藏的意思，但是这种隐藏对外不对内

装指的是把属性装进一个容器

如何封装

只需要在想要封装的数据前加上__开头 （两个下划线），该属性就会被隐藏起来，该隐藏具备的特点：

  • 只是一种语法意义上的变形，开头的属性会在检测语法时发生变形 _类名_\属性名
  • 这种隐藏式对外不对内，因为在类内部检测语法时所有的代码统一都发生的变形
  • 这种变形只在检测语法时发生一次，在类定义之后新增的__开头的属性并不会发生变形
  • 如果父类不想让子类覆盖自己的属性，可以在属性前加__开头
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 这种隐藏式对外不对内，因为在类内部检测语法时所有的代码统一都发生的变形
        # class Foo:
        #     __x = 1111   # _Foo__x =1111
        #     def __init__(self,y):
        #         self.__y = y
        #
        #     def __f1(self):
        #         print('Foo.f1')
        #
        #     def get_y(self):
        #     print(self.__y) # _类名__属性名

        # obj = Foo(2222)
        # # print(obj.x)  # 找不到属性
        # # print(obj.__x)
        # # print(obj.y)
        # # print(obj.__y)
        #
        # print(obj._Foo__x) # 1111
        # print(obj._Foo__y)
        # obj.get_y()

# 这种变形只在检测语法时发生一次，在类定义之后新增的__开头的属性并不会发生变形

        # Foo.__aaaaaaaaaaaaaaaaaaaaaa = 1
        # print(Foo.__dict__)
        # '__aaaaaaaaaaaaaaaaaaaaaa': 1

# 如果父类不想让子类覆盖自己的方法，可以在方法名前加__开头

        # class Foo:
        #     def __f1(self):
        #         print('Foo.f1')
        #
        #     def f2(self):
        #         print('Foo.f2')
        #         self.__f1() # obj._Foo__f1()
        #
        # class Bar(Foo):
        #     def __f1(self):
        #         print('Bar.f1')
        #
        # obj = Bar()
        # obj.f2()

#

为何要封装？

封装数据属性的目的：将数据属性封装起来，类外部的使用就无法直接操作该数据属性，需要类内部开一个接口给使用者，类的设计者可以在接口智商附加任意逻辑，从而严格控制使用者对属性的操作

封装函数属性的目的：隔离复杂度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 封装不是单纯意义上的隐藏

# 封装数据属性的目的：把数据属性封装起来，然后需要开辟接口给类外部的使用者使用
# 这样我们可以在接口之上添加控制逻辑，从而严格空间访问者对属性的操作
class People:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def tell_info(self):
        u = input('user>>> ').strip()
        p = input('pwd>>> ').strip()
        if u == 'ooc' and p =='111':
            print(self.__name,self.__age)

    def modfiy_info(self,name,age):
        if type(name) is not str:
            raise TypeError('必须为str类型')
        if type(age) is not int:
            raise TypeError('必须为int类型')

        self.__name = name
        self.__age = age

p = People('david',18)
p.tell_info()

p.modfiy_info('Jack',20)
p.modfiy_info('Jack','20') # 报错
p.modfiy_info(aaaa,20) # 报错

# 封装函数属性的目的：为了隔离复杂度
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()

# 封装其实最主要的功能就是明确地区分内外，对外是隐藏的，对内是开放的