类的三大特征之封装

最新推荐文章于 2022-01-08 17:21:49 发布

原创最新推荐文章于 2022-01-08 17:21:49 发布 · 945 阅读

0 ·

CC 4.0 BY-SA版权

python 专栏收录该内容

28 篇文章

订阅专栏

1024被渲染的有点夸张了，如果真的在乎这个节日，还不如给程序员放一天假。希望今天各位程序员可以不加班！接下来开始今天的正题

在说封装之前呢，要补充一个昨天遗漏的知识点：组合

开始我们今天的人生三问：

1. 什么是组合

组合组合，就是组装合并呗。在python的类中就是通过某种关系将两个类的两个对象连接在一起就叫组合。（不是同一个类的两个对象！！每个类取出一个对象来，和另一个类的对象以某种形式连接，就形成了组合）

2. 为什么要用组合

减少代码冗余的另一种方式。不要说什么我会继承，不需要学这个东西了，你记住一句话，存在即为合理。python最注重的就是简单，如果组合没什么用处的话，龟叔也不会创造出组合这么个东西了。组合能干一些继承做不到的事情。

3. 怎么用组合

前面我们说过，两个对象建立联系就可以完成组合，那么如何建立这种联系呢？

例：

class Foo:
    aaa = 1111

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def func1(self):
        print('Foo内的功能')


class Bar:
    bbb = 2222

    def __init__(self, m, n):
        self.m = m
        self.n = n

    def func2(self):
        print('Bar内的功能')


obj1 = Foo(10, 20)
obj2 = Bar(30, 40)

obj1.xxx = obj2    # 这里的obj.xxx这个名字只是为了辅助你理解：xxx只是一个名字，你可以取任意的名字
# 但是一定要记得让名字有一定的意义。

我们通过在对象obj1中增加一个属性（特征属性）来和obj2建立一种联系，这样我们就可以通过obj1.xxx来访问到obj2内的属性以及obj2所属的类内的属性！这样我们相同的属性就不需要再写第二份，可以通过组合直接调用。

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同：

1.继承的方式

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

2.组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

例：

# 首先，学生应该有课程信息，直接在父类中定义出来课程信息的话，其他的子类也必须继承课程信息
# 不太符合我们的要求，把课程信息放到每个学生对象中，同样的数据储存了太多份，浪费内存空间资源
# 在这里使用组合就可以满足我们的需求
class OldboyPeople:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class OldboyStudent(OldboyPeople):
    pass

class OldboyTeacher(OldboyPeople):
    def __init__(self,name, age, gender, level, salary):
        OldboyPeople.__init__(self, name, age, gender)
        self.level = level
        self.salary = salary

class Course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period

    def tell_info(self):
        print((' info of %s' % self.name).center(50, '-'))
        print('''
        课程名称: %s
        课程周期: %s
        课程价格: %s
        ''' % (self.name, self.period, self.price))


class Grade:
    def __init__(self, name, student_amount):
        self.name = name
        self.student_amount = student_amount
    @property
    def tell_info(self):
        print((' info of %s ' % self.name).center(50, '-'))
        print('''
        班级名称: %s
        班级人数: %s
        ''' % (self.name, self.student_amount))

stu1 = OldboyStudent('Catalog Spir', 18, 'male')
tea1 = OldboyTeacher('egon', 18, 'male', 10, 3.1)
python_lesson = Course('python全栈开发', 5000, '5mons')
python_grade = Grade('python脱产4期', 53)
linux_lesson = Course('Linux运维', 3000, '4mons')
linux_grade = Grade('Linux运维3期', 48)
stu1.course = python_lesson      # 对象stu1与python课程对象建立联系
stu1.grade = python_grade        # 对象stu1与python班级对象建立联系
stu2.course = linux_lesson       # 对象stu2与linux课程对象建立联系
stu2.grade = linux_grade         # 对象stu2与linux课程对象建立联系

可以看出，当我们的父类中‘放不下’一些数据时，我们可以通过组合的方式对这些数据进行重用，减少代码冗余，减少内存空间浪费。

总结：当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

封装

再来个人生三问：

1. 什么是封装

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

封指的是隐藏的意思

从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八一起装进麻袋，然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’（外部看不到里面的东西，相当于把里面的东西藏了起来，但是这种隐藏式对外不对内的）

2. 为什么要有封装

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

封装函数属性的目的:隔离复杂度（我们将处理过的数据直接返回给使用者，他们使用数据变得极其简单，这就叫隔离复杂度）

3. 怎么用封装

只需要在属性前加上__开头，该属性就会被隐藏起来，该隐藏具备的特点:

1. 只是一种语法意义上的变形,即__开头的属性会在检测语法时发生变形_类名__属性名

2. 这种隐藏式对外不对内的,因为在类内部检测语法时所有的代码统一都发生的变形

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

4. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

class Foo:           
    __x=111           #这一步其实在检测语法时，把__x这个名字加了个前缀，改成了_Foo__x      
    def __init__(self,m,n):
        self.__m=m            # 与上面一样self._Foo__m=m
        self.n=n

    def __func(self):               #_Foo__func     
        print('Foo.func') 

    def func1(self):
        print(self.__m)           #self._Foo__m
        print(self.__x)           #self._Foo__x

这个例子印证了前三个特点，下面这个例子可以印证第四个特点：

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

虽然子类和父类中定义的函数都叫__f1，但是他们本质上的名字是不一样的，所以就可以实现上面所说的第四个特点。

封装的真实目的：

封装分为两种：一种是对变量属性的封装，另一种是对函数属性的封装。

对变量属性的封装：

class People:
    def __init__(self,name,age):
        self.__name=name        # 对name属性和age属性进行封装，外界无法直接对该属性进行修改或删除
        self.__age=age

    def tell_info(self):
        print('<name:%s age:%s>' %(self.__name,self.__age))

    def set_info(self,new_name,new_age):
        if type(new_name) is not str:     # 必须满足条件才可以进行修改
            print('名字必须是str类型')     # 限制了使用者对属性的操作
            return
        if type(new_age) is not int:
            print('年龄必须是int类型')
            return
        self.__name=new_name
        self.__age=new_age

    def clear_info(self):
        del self.__name         # 这个就是隔离复杂度的应用
        del self.__age         # 不需要用户记那么多操作，只需要调用一个clear_info就可以完成清除信息的操作

对类的特征属性的封装一来可以限制用户对属性做任意更改，二来可以将复杂的操作变成简单的接口（函数）给用户直接使用，隔离复杂度。

对函数属性的封装：

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

对函数属性的封装可以使复杂的操作简单化，用户提款不再需要一步步的调用各种函数，只需要调用一个withdraw函数就可以完成操作。

@property装饰器

我们来回顾一下装饰器的作用：

在不修改函数的调用方式及源代码的情况下给函数增加新功能

property装饰器与普通的装饰器不太相同，具体是怎样不同我们来一步步的看

（请将例子看完再回头来看这一句话，可以更好的理解）将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

栗子：

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

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    def bmi(self):
        print(self.weight / (self.height ** 2))

obj=People('egon',70,1.82)

obj.bmi()

我们来看上面这个例子用户每次去查看bmi这个属性，都要调用一个函数，这就相当于你每次要查看名字都要obj.name()，总觉得怪怪的，这一类的数值应该是以特征属性的形式存在才更合理。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('egon',70,1.82)

print(obj.bmi)

这样子给他来个装饰器一修饰，它就变得像一个普通的特征属性一样了，可以直接obj.bmi去调用。这样看起来就合情合理了。

作为了解：

当我们把一个函数伪装成一个特征属性以后，如果用户要对其进行修改应该怎样操作：

class People:
    def __init__(self,name):
        self.__name=name

    @property
    def name(self):
        return '<name:%s>' %self.__name

    @name.setter
    def name(self,new_name):
        if type(new_name) is not str:
            print('名字必须是str类型')
            return
        self.__name=new_name

    @name.deleter
    def name(self):
        del self.__name

这样我们就可以实现对一个看起来像普通特征属性name的查看，修改，删除等操作。

讲个笑话：

Python崇尚鸭子类型，即”如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子“，python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法