欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

类的封装

程序员文章站 2022-04-10 20:34:16
[TOC] 什么是封装 封:类的属性对外是隐藏的,但对内是开放的,类似于一个封闭的容器 装:定义类时会申请一个名称空间,往里装入一系列名字/属性 如何封装 如何隐藏:在属性前加上__开头,即可隐藏某个属性,该属性只可在类内部使用,无法在类外部使用,隐藏有以下四点需要注意: 1. 这种隐藏仅仅只是一种 ......

目录

什么是封装

  • 封:类的属性对外是隐藏的,但对内是开放的,类似于一个封闭的容器

  • 装:定义类时会申请一个名称空间,往里装入一系列名字/属性

如何封装

class people:
    __country = 'china'  # _people__country = 'china'
    __n = 100  # _people__n = 100

    def __init__(self, name, age, sex):
        self.__name = name  # self._people__name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('eat.....')


peo1 = people('egon', 18, 'male')

类的封装

  • 如何隐藏:在属性前加上__开头,即可隐藏某个属性,该属性只可在类内部使用,无法在类外部使用,隐藏有以下四点需要注意:

    1. 这种隐藏仅仅只是一种语法上的变形操作

    2. 这种语法上的变形只在类定义阶段发生一次,因为类体代码仅仅只在类定义阶段检测一次

    3. 这种隐藏是对外不对内的,即在类的内部可以直接访问,而在类的外则无法直接访问,原因是在类定义阶段,类体内代码统一发生了一次变形

    4. 如果不想让子类的方法覆盖父类的,可以将该方法名前加一个__开头

print(people.__dict__)
{'__module__': '__main__', '_people__country': 'china', '_people__n': 100, '__init__': <function people.__init__ at 0x10953af28>, 'eat': <function people.eat at 0x10953aea0>, '__dict__': <attribute '__dict__' of 'people' objects>, '__weakref__': <attribute '__weakref__' of 'people' objects>, '__doc__': none}
try:
    print(peo1.__name)
except exception as e:
    print(e)
'people' object has no attribute '__name'
try:
    print(peo1.__country)
except exception as e:
    print(e)
'people' object has no attribute '__country'

1.虽然类隐藏的属性外部无法直接访问,但是可以通过_类名__属性名访问,但是这样做明天你就可以走人了……,即这种隐藏仅仅只是一种语法上的变形操作

print(people._people__country)
china

2.类的封装这种语法上的变形只在类定义阶段发生一次,因为类体代码仅仅只在类定义阶段检测一次

people.__x = 11
print(people.__dict__)
{'__module__': '__main__', '_people__country': 'china', '_people__n': 100, '__init__': <function people.__init__ at 0x10953af28>, 'eat': <function people.eat at 0x10953aea0>, '__dict__': <attribute '__dict__' of 'people' objects>, '__weakref__': <attribute '__weakref__' of 'people' objects>, '__doc__': none, '__x': 11}

3.类的封装是对外不对内的,即在类的内部可以直接访问,而在类的外则无法直接访问,原因是在类定义阶段,类体内代码统一发生了一次变形

peo1 = people('egon', 18, 'male')
print(peo1.__dict__)
{'_people__name': 'egon', 'age': 18, 'sex': 'male'}
peo1.__x = 111
print(peo1.__dict__)
{'_people__name': 'egon', 'age': 18, 'sex': 'male', '__x': 111}

4.如果不想让子类的方法覆盖父类的,可以将该方法名前加一个__开头

class foo:
    def __f1(self):  # _foo__f1
        print('foo.f1')

    def f2(self):
        print('foo.f2')
        self.__f1()  # self._foo__f1


class bar(foo):
    def __f1(self):  # _bar__f1
        print('bar.f1')


obj = bar()
obj.f2()  # f2()中的__f1()是self._foo_f1,是父类的__f1,而不是子类的__f1
foo.f2
foo.f1

为什么要封装

类的封装

封装数据属性的目的

  • 首先定义属性的目的就是为了给类外部的使用使用的;隐藏之后是为了不让外部使用直接使用,需要类内部开辟一个接口;然后让类外部的使用通过接口来间接地操作隐藏的属性。

  • 精髓在于:我们可以在接口之上附加任意逻辑,从而严格控制使用者对属性的操作

封装函数属性

  • 首先定义属性的目的就是为了给类外部的使用使用的;隐藏函数属性是为了不让外不直接使用,需要类内部开辟一个接口;然后在接口内去调用隐藏的功能

  • 精髓在于:隔离了复杂度

封装的应用

  • 如果我们需要规定一个类的名字和年龄的数据类型,我们可以使用封装的思想严格控制使用者对属性的操作
class people:
    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 type(name) is not str:
            # print('用户名必须为str类型')
            # return
            raise typeerror('用户名必须为str类型')

        if type(age) is not int:
            # print('年龄必须为int类型')
            # return
            raise typeerror('年龄必须为int类型')
        self.__name = name
        self.__age = age
        print('%s:%s创建成功' % (self.__name, self.__age))


peo1 = people('egon', 18)
  • 类的属性隐藏之后,我们可以间接的使用类的属性,此例通过tell_info()方法调用类的属性
peo1.tell_info()
egon:18
  • 使用set_info()方法控制属性的类型
peo1.set_info('egon', 19)
egon:19创建成功
  • 封装还可以理解成接口的概念,也就是说封装对象内部相当于一个黑盒,你无法得知这个黑盒内部发生了什么事情,你只需要你启动一个按钮,你就可以完成某一件非常牛逼的事,例如我们可以封装atm取款的功能

    1. 取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
    2. 对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做,隔离了复杂度,同时也提升了安全性

类的封装

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()


a = atm()
a.withdraw()
插卡成功
用户认证成功
输入取款金额成功
打印账单成功
取款成功

模块的封装(了解)

类的封装

python并不会真的阻止你访问私有的属性,模块也遵循这种约定,如果模块名以单下划线开头,那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的,原则上是供内部调用的,作为外部的你,一意孤行也是可以用的,只不过显得稍微傻逼一点点