• 面向对象 --- 类的继承


    继承

    1.什么是继承?

    继承指的是新建类的方法,新建的类称之为子类或者派生类,字类继承的类叫做父类,也称之为基类或超类。

    继承的特征:子类以继承父类的属性(特征与技能,一个特征的属性就是变量与函数),子类并且可以派生出自己的属性(特征与技能)。

    (面试的时候会问)注意:在python中一个父类可以继承多个父类,其他语言只能一个字类继承一个父类

    2.为什么要继承

    继承的目的是为了减少代码的冗余(减少重复代码)

    3.如何实现继承

    1.首先要确定好谁是子类,谁是父类。(子类继承父类)

    2.在定义类时,字类 + (),()内写父类,实现继承

    class 父:
        a = 111
        pass
    
    class 子(夫):
        pass
    

    4.继承初体验

    # 父类
    class ParentClass1:
        pass
    
    class ParentClass2:
        pass
    
    # 继承一个父类
    class SubClass1(ParentClass1):
        pass
    
    # 继承多个父类
    class SubClass2(ParentClass1,ParentClass2):
        pass
    
    
    # 查看继承的父类:__bases__,是类的属性,用来查找当前的父类
    print(SubClass1.__bases__)
    print(SubClass2.__bases__)
    
    

    5.寻找继承关系

    如何寻找继承关系:要想寻找继承关系,首先要”先抽象,再继承“,

    什么是抽象:

    抽取相似的部分,称之为抽象

    --先抽象(抽象思想):

    -再继承(在程序中):先定义一个类,在调用类

    继承的关系:

    对象是特征与技能的结合体

    类是一系列对象相同的特征与技能的结合

    继承是一系列类相同的特征与技能的结合体

    # 父类
    class Crea:
        school = 'oldboy'
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
    
    # 老师类
    class A(Crea):
        # 老师修改分数技能
        def change_score(self):
            print(f'{self.name}修改了分数')
    
    
    # 学生类
    class B(Crea):
        # 学生选课技能
        def choice_course(self, course):
            print(f'{self.name}选择了{course}课程')
    
    
    stu1 = A('wang', 18, 'male')
    stu2 = B('zhang', 20, 'famale')
    
    print(stu1.name, stu1.age, stu1.sex)     #输出结果  wang 18 male
    print(stu2.name, stu2.age, stu2.sex)     #输出结果  zhang 20 famale
    
    

    6.继承背景下对象属性的查找顺序

    在继承背景下,对象属性的查找顺序:

    1.对象查找属性会先从对象的名称空间中查找。

    2.若对象没有,则会去类里面查找。

    3.若当前类是子类,并且没有对象找的属性,则会去父类里边查找。

    注意:对象查找属性,若子有,不管父有没有,以字类的为准。

    验证对象属性的查找顺序

    class Foo:
        def f1(self):
            print('Foo.f1')
            
        def f2(self):
            print('Foo,f2')
            self.f1()
            
    class Soo(Foo):
        def f1(self):
            print('Soo.f1')
            
    soo_obj = Soo()
    soo_obj.f2()
    
    # 输出结果  
    Foo,f2
    Soo.f1
    

    派生

    1.什么是派生?

    派生指的是子类继承父类的属性,并且派生出新的属性。

    子类派生出新的属性,若与父类的属性相同,则以子类的为准。

    继承是谁与谁的关系,指的是类与类的关系,子类与父类是

    2.子类派生出新的属性,并重用父类的属性

    问题:子类继承父类的__init__毫无意义

    解决方法有两种:

    方式一:直接通过父类._init__,把__init__当作普通函数使用,传入对象与继承的属性

    class OldboyPeople:
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
    
    # 方式一:
    class OldboyTeacher(OldboyPeople):
        # 等级, 薪资
        def __init__(self, name, age, sex, level, sal):  
            OldboyPeople.__init__(self, name, age, sex)   # 通过继承,使用__init__直接调用
            self.level = level
            self.sal = sal
    
    
    class OldboyStudent(OldboyPeople):
        # 课程
        def __init__(self, name, age, sex, course):
            OldboyPeople.__init__(self, name, age, sex)     # 通过继承,使用__init__直接调用
            self.course = course
    
        def choose_course(self):
            print(f'学生{self.name}选择课程{self.course}')
    

    方法二:super是一个特殊的类,在子类中调用super()会的到一个特殊的对象,通过” . “指向的父类的名称空间

    # 方式二:
    class OldboyTeacher(OldboyPeople):
        # 等级, 薪资
        def __init__(self, name, age, sex, level, sal):
            super().__init__(name, age, sex)
            self.level = level
            self.sal = sal
    
    
    class OldboyStudent(OldboyPeople):
        # 课程
        def __init__(self, name, age, sex, course):
            super().__init__(name, age, sex)
            self.course = course
    
        def choose_course(self):
            print(f'学生{self.name}选择课程{self.course}')
    

    注意点:两种方式不要混着使用的。

    新式类与经典类

    (面试的时候想知道你是否接触过python2)

    在python2中才会有新式类与经典类之分,在python3中,所有的类都是新式类。

    新式类:继承object的类都称之为新式类,python3中所有的类默认继承object

    经典类:在python2中,凡是没有继承object的累都是经典类

    mro():属于object --》type的 内置的函数,用来查看当前类的继承顺序,在多继承的情况下

    print(C.mro())
    

    钻石继承

    (面试会问)

    钻石继承也可以称之为菱形继承。在python2 中才会有区别

    在多继承的情况下形成的钻石继承(继承顺序)

    1.经典类:深度优先(按顺序在继承的父类中寻找,如果在第一个继承的父类中找到了需要的,就不会在去别的父类寻找)

    2.新式类:广度优先(按顺序在继承的父类中寻找需要的object,在第一个继承的父类中找到之后,如果之后的父类中也能找到,会继承最后一个继承父类中的object)

    通过继承实现修改json模块数据类型

    import json
    from datetime import date, datetime
    
    # isinstance:
    # python内置的函数,可以传两个参数,判断参数一是否式参数二的一个实例.
    
    # 开源者的角度: 修改json源码
    class MyJson(json.JSONEncoder):
        def default(self, o):
    
            # 子类派生的功能
            # 判断o是否式datetime的一个实例
            if isinstance(o, datetime):
                return o.strftime('%Y-%m-%d %X')
            elif isinstance(o, date):
                return o.strftime('%Y-%m-%d')
            else:
                # 继承父类的default方法的功能
                return super().default(self, o)
    
    
    dict1 = {
        'name': 'tank',
        'today': datetime.today(),
        'today2': date.today()
    }
    
    res = json.dumps(dict1, cls=MyJson)  # cls=None,默认指向的是原json的JSONEncoder
    print(res)
    
  • 相关阅读:
    Docker学习笔记
    Docker学习笔记
    Docker学习笔记
    Docker学习笔记
    Docker学习笔记
    第二类斯特灵数学习笔记
    浅谈"n个球"和"m个盒子"之间的乱伦关系
    cf932E. Team Work(第二类斯特灵数 组合数)
    [vijos]lxhgww的奇思妙想(长链剖分)
    BZOJ2054: 疯狂的馒头(并查集)
  • 原文地址:https://www.cnblogs.com/whkzm/p/11648374.html
Copyright © 2020-2023  润新知