• 类的继承


    面向对象阶段最重要的知识点:

    面向对象的三大特性:

      1.继承 (组合)

      2.封装

      3.多态

    继承

     1.什么是继承?

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

    继承的特征:
      子类可以继承父类的属性(特征与技能), 并且可以派生出自己的属性(特征与技能).

    注意: 在python中,一个子类可以继承多个父类,其他语言只能一个子类继承一个父类.

    2.为什么要继承?

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

    3.如何实现继承?

      1.首先要确定好谁是子类,谁是父类.

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

      3.查看继承的父类: __bases__,是类的属性,用来查找当前类的父类.(多个的话,用元组的形式打印出来)

    # 父类
    class ParentClass1:
        pass
    
    class ParentClass2:
        pass
    
    # 子类
    class SubClass1(ParentClass1):
        pass
    
    # 继承多个父类
    class SubClass2(ParentClass1, ParentClass2):
        pass

    # 查看继承的父类: __bases__,是类的属性,用来查找当前类的父类.
    print(SubClass1.__bases__) # (<class '__main__.ParentClass1'>,)
    print(SubClass2.__bases__) # (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
     
    class OldboyPeople:
        school = 'oldboy'
    
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
    
    # 老师类: 名字,年龄,性别
    class OldboyTeacher(OldboyPeople):
        # 老师修改分数技能
        def change_score(self):
            print(f'老师[{self.name} 修改分数...]')
    
    # 学生类:  名字,年龄,性别
    class OldboyStudent(OldboyPeople):
    
        # 学生可以选择课程
        def choose_course(self, course):
            print(f'学生[{self.name}]选择课程[{course}]')
    
    stu1 = OldboyStudent('小丁丁', 95, 'female')
    tea1 = OldboyTeacher('tank', 17, 'male')
    
    print(stu1.name, stu1.age, stu1.sex)
    print(tea1.name, tea1.age, tea1.sex)

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

    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
    '''

    派生

    派生指的是子类继承父类的属性,并且派生出新的属性.(*****)

    子类派生出新的属性,若与父类的属性相同,则以子类的为准.
    继承是谁与谁的关系, 指的是类与类的关系,子类与父类是从属关系.
    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.f1()  # Soo.f1

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

    解决方式有两种:
    方式一:
    直接通过 父类.(调用)__init__,把__init__当做普通函数使用,传入对象与继承的属性.

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

    注意: 两种方式不要混合使用.
    方式一:
    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)
            self.level = level
            self.sal = sal
    
    
    class OldboyStudent(OldboyPeople):
        # 课程
        def __init__(self, name, age, sex, course):
            OldboyPeople.__init__(self, name, age, sex)
            self.course = course
    
        def choose_course(self):
            print(f'学生{self.name}选择课程{self.course}')
    方式二:
    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中,才会有新式类与经典类之分.
    python3中,所有的类都是新式类.

    新式类:
    继承object的类都称之为新式类.
    python3中,子类不继承自定义的类,默认继承object.

    经典类:
    在python2中,凡是没有继承object的类都是经典类.
    mro(): 属于object--> type的函数, 用来查看当前类的继承顺序, 在多继承的情况下
    class A:
        # x = 2
        pass
    class B:
        # x = 3
        pass
    # 多继承情况下:
    class C(A, B):
        # print('C...')
        # x = 1
        pass
    
    
    # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
    print(object)
    print(C.mro())

    <class 'object'>
    [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

    钻石继承也可以称之为菱形继承

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

    - 经典类:
    深度优先:

    - 新式类:
    广度优先:
    class A:
        # def test(self):
        #     print('from A')
        pass
    
    class B(A):
        # def test(self):
        #     print('from B')
        pass
    
    class C(A):
        def test(self):
            print('from C')
        pass
    
    class D(B):
        # def test(self):
        #     print('from D')
        pass
    
    class E(C):
        # def test(self):
        #     print('from E')
        pass
    
    class F(D,E):
        # def test(self):
        #     print('from F')
        pass
    
    
    # 新式类: F-D-B-E-C-A-object
    f1 = F()
    f1.test()
    
    # 经典类: F-D-B-A-E-C

     

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

    json无法把date,datetime序列化

    可以添加数据类型

    方法一:开发者角度,直接转成str

    import json
    from datetime import date, datetime
    
    
    #开发者的角度: 直接转成str
    dict1 = {
        'name': 'tank',
        'today': str(datetime.today()),
        'today2': str(date.today())
    }
    
    res = json.dumps(dict1)
    print(res)
    方法二:开源者的角度: 修改json源码
    isinstance:
    python内置的函数,可以传两个参数,判断参数一是否是参数二的一个实例.
    
    
    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)
     

     

     

     

  • 相关阅读:
    利用Powerdesigner16.5(64位)连接64位oracle 配置系统odbc驱动
    Commons BeanUtils 中对Map的操作
    java内存模型与线程
    类加载器详解
    虚拟机性能监控与故障处理工具
    ENode框架Conference案例分析系列之
    ENode框架Conference案例分析系列之
    225.优化路径选择
    224.CAD相关操作
    223.概率统计
  • 原文地址:https://www.cnblogs.com/fjn839199790/p/11647921.html
Copyright © 2020-2023  润新知