Python-面向对象之封装与多态

时间 2019-12-02

标签 python 面向对象封装栏目 Python 繁體版

原文原文链接

组合

什么是组合

组合指的是一个对象中的属性是另外一个对象的引用linux

组合是对象与对象的关系，一种什么有什么的关系，一个对象拥有另外一个对象
继承是类与类的关系，一种什么是什么的关系，子类与父类是从属关系

使用组合的目的

和继承同样减小代码冗余安全

如何使用组合

上代码app

# 组合练习

# 定义相同属性的属性
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 每一个对象都都选课的权利/功能，添加课程功能，添加的课程利用组合知识点，添加课程的对象，
    # 进而对 课程对象操做
    def add_course(self,course_name):
        self.course_list.append(course_name)

    # 打印当前对象中全部课程的信息
    def tell_all_course(self):

        # 拿到当前对象的课程列表，列表中存放的是一个个课程对象
        for course_obj in self.course_list:

            # 每个课程对象能够调用它的绑定方法查看课程的信息，
            # 利用for循环遍历 进而能够查看全部课程
            course_obj.tell_info()


class Teacher(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        self.course_list = []

class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        self.course_list = []

# 定义课程类
class Course:
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

    def tell_info(self):
        print(f"""
        课程名称：{self.name}
        课程周期：{self.period}
        课程价钱：{self.price}
        """)

# 实例化老师和学生类
tea1 = Teacher("tank",18,"man")
stu1 = Student("qinyj",20,"man")

# 实例化课程类
python = Course("python","6个月","20K")
linux = Course("linux","6个月","15K")

# 使用组合将课程对象添加到老师属性里面
tea1.add_course(python)
tea1.add_course(linux)

# 对对象的属性进行调用，循环遍历出全部课程
tea1.tell_all_course()

封装

什么是封装

封装值得就是把一堆属性（特征和技能）封装到一个对象中函数

存数据不是目的，取才是目的，建立出对象后能够"."的方式获取属性code

为何要封装

封装的目的是为了方便存取，能够经过对象“.”的方式获取属性对象

如何封装

定义类：继承

特征：变量--》数据属性接口

技能：函数--》方法属性字符串

在类内部，定义一堆属性（特征和技能）

经过对象.属性获得/修改属性值

访问限制机制

什么是访问限制机制

在类内部定义，凡是以__开头的数据属性与方法属性都会被python类隐藏起来，让外部不能直接访问这些属性，好比：__name = "qinyj"

访问限制机制的目的

一堆隐私属性不能被外部轻易访问的属性能够隐藏起来，不能被外部直接访问

好处：对重要数据获取的逻辑更加严谨，保证数据的安全

接口：隐私属性能够经过封装一个接口，在接口内部作业务逻辑的处理，把数据返回给调用者。

注意：python中不会强制限制属性的访问，类内部__开头的属性，只是作了一种变形，若想直接访问，调用变形后的名字便可。即：

class Foo:
    __name = "qinyj"    --》变形为 _类名__属性名

print(Foo._Foo__name)

如何使用访问限制

上代码

class Teacher:
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex

    def get_info(self):
        # 验证用户逻辑
        user = input("请输入用户")
        pwd = input("请输入密码")
        if user == "qinyj" and pwd == "123":
            print(f"""
            姓名：{self.__name}
            年龄：{self.__age}
            性别：{self.__sex}
            """)

    def set_info(self,name,age,sex):

        # 验证输入逻辑
        if not isinstance(name,str):
            raise TypeError("名字必需要使用字符串")
        if not isinstance(age,int):
            raise TypeError("年龄必需要使用数字")
        if not isinstance(sex,str):
            raise TypeError("性别必需要使用字符串")

        self.__name = name
        self.__age = age
        self.__sex = sex

t = Teacher("qinyj",18,"man")
# t.get_info()

t.set_info("jack",18,"man")
t.get_info()

property

什么是property

property是python内部的装饰器，主要是给类内部的方法使用的。

将类内部的方法变成属性引用

为何要用property

在对象调用某个方法时，将类内部的方法当作一个普通的数据属性调用

如何使用property

@property

上代码

'''
计算人体的bim值
bim值 = 体重 / （身高 * 身高）
'''
class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height

    @property       
    def bim(self):
        return self.weight / (self.height * self.height)

    # 了解
    @property
    def get_name(self):
        return self.name

    @get_name.setter
    def set_name(self,value):
        self.name = value

    @get_name.deleter
    def del_name(self):
        del self.name

p = People("qinyj",120,1.72)
print(p.bim)        # bim方法不用加括号 自动触发执行bim方法

print(p.get_name)
p.set_name = "jack" # 自动触发set_name方法
print(p.get_name)
del p.del_name      # 自动触发del_name方法
print(p.get_name)

多态与多态性

什么是多态

多态指的是同一种事物的多种形态

多态的目的

多态也称之为多态性，在程序中继承就是多态的表现形式
父类：定义一套统一的标准
子类：遵循父类统一的标准

多态的最终目的：为了让多种不一样类型的对象，在使用相同功能状况下，调用同一名字的方法名，统一子类编写的规范，为了让使用者更方便调用相同功能的方法

如何实现多态性

继承父类
继承抽象类
鸭子类型

注意，在python中不会强制要求子类必须遵循父类的一套标准，因此出现了抽象类

上代码

# 多态性骚操做
class Cat:
    def talk(self):
        print("say miao")

# 定义一个普通函数，将对象放入函数参数调用类内部的方法
def func(animal):
    animal.talk()

cat1 = Cat()    # 实例化出一只猫的对象
func(cat1)


# 多态：同一种事物的多种形态
# 多态性：一种调用方式，不一样的执行结果

抽象类

什么是抽象类

即abc模块（abcstract_class）

使用抽象类的目的

强制子类必须遵循父类的一套标准

如何使用

import abc

上代码

import abc

class Animal(metaclass=abc.ABCMeta):

    # 使用此装饰器就意味着统一了方法，子类若继承此类，方法名必须遵循此类的规范定义
    # 同时不能少方法
    # 能够派生出本身的属性和方法
    # 使用的时候在此类()内添加 metaclass=abc.ABCMeta
    # 想让什么方法遵循就在什么方法上加 @abc.abstractmethod
    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def drink(self):
        pass


class Pig(Animal):

    def eat(self):
        print("猪在吃饭")

    def drink(self):
        print("猪在喝水")

    def run(self):
        print("猪在跑步")

p = Pig()

鸭子类型

什么是鸭子类型

在不知道当前对象时何物的时候，可是你长得像鸭子，那么你就是鸭子类型

在python中，不推荐使用抽象类强制限制子类的定义，可是推荐类都遵循燕子类型

使用继承：耦合性过高，程序可扩展性差

鸭子类型：耦合性低，程序可扩展性高

即不使用继承，又按照某一种规范编写程序

小结

1.组合:
        - 什么是组合
                组合指的是一个对象中的属性,是另外一个对象.
        - 为何要使用组合
            组合目的和继承同样, 为了减小代码冗余.
2.封装:
        - 什么是封装?
                封装指的是把一堆属性(特征与技能)封装到一个对象中.
                存数据的目的是为了取, 对象能够"."的方式获取属性.
                
        - 为何要封装?
        封装的目的为了方便存取,能够经过对象.属性的方式获取属性.

3.访问限制机制:
    - 什么是访问限制机制?
         在类内部定义, 凡是以__开头的数据属性与方法属性,都会被python内部隐藏起来,让外部不能"直接"访问类内部的__开头的属性.

    - 访问限制机制的目的?
        一堆隐私的属性与不能被外部轻易访问的属性, 能够隐藏起来,不被外部直接调用.   
   
4.property:
    - 什么是property
        python内置的装饰器, 主要是给类内部的方法使用.

    - 为何要用property
        在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)
        obj.bmi() == obj.bmi

    - 如何使用property
        @property
        def 类内部的方法(self):

5.多态:
    - 什么是多态?
        多态指的是同一种事物的多种形态.

    - 多态的目的:
        多态的目的是为了, 让多种不一样类型的对象, 在使用相同功能的状况下,调用同一个名字的方法名.
        父类: 定义一套统一的标准.
        子类: 遵循父类统一的标准.
        
    - 如何实现:
        - 继承父类
        - 继承抽象类
        - 鸭子类型

6.抽象类的目的:
        强制子类必须遵循父类的一套标准.

7.鸭子类型:
    - 什么是鸭子类型?
        在不知道当前对象是何物的状况下,可是你长得像鸭子,那么你就是鸭子类型.
    - 继承:
        耦合性过高,程序的可扩展性差

    - 鸭子类型:
        耦合度低,程序的可扩展性强