Python的继承、派生、多态与鸭子类型

台州吃柴小男孩

于 2023-10-09 19:36:13 发布

阅读量81

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_71292438/article/details/133703571

版权

继承(面向对象中得核心)

面向对象的三大特征：封装、继承、多态

什么是继承?

继承就是一种新建类的方式, 新建出来的类我们称为是'子类或者叫派生类'，被继承的类我们称为是'父类或者是基类'
当然出来的类子类可以遗传父类的所有属性

为什么要用继承?

类解决了什么问题: 对象与对象之间的代码冗余问题
继承解决了什么问题：类与类之间的代码冗余问题

怎么使用继承?

经典类：没有继承object类的子子孙孙类都是经典类
新式类：继承了object类的子子孙孙类都是新式类

注意：再有在Python2中才区分经典类和新式类，如果是Python3的版本，所有的类都是新式类，也就是说在Python3中默认的类都是继承了object类，在Python3中没有了经典类和新式类的说法了.

 class Parent1:
    pass


class Parent2(object):
    pass


"""Sub1类继承了Parent1的类，Sub1就称为是子类，Parent1类就称为是父类或者叫基类"""
# 单继承：一个类只继承了一个类，一个类继承了两个或者两个以上的类就是多继承了
class Sub1(Parent1):
    pass


# 多继承的类: Sub2就是子类，Parent1和Parent2都是父类
class Sub2(Parent1, Parent2):
    pass

print(Sub1.__bases__) # (<class '__main__.Parent1'>,)
print(Sub2.__bases__) # (<class '__main__.Parent1'>, <class '__main__.Parent2'>)

"""继承的实际案例"""


class People():
    school = 'SH'
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class Student(People):
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        """子类里面一定再次调用父类的__init__方法"""
        People.__init__(self, name, age, gender) # 指名道姓的调用方法
        self.course = course

    def choose_course(self):
        print('%s 选课成功， %s' % (self.name, self.course))


stu = Student('ly', 20, 'male')
print(stu.school)  # SH 属性的查找
print(stu.name)
print(stu.age)
print(stu.gender)


class Teacher(People):
    def __init__(self, name, age, gender, level):
        People.__init__(self, name, age, gender)
        self.level = level

    def score(self, stu_name):
        print('%s 得了%s分' % (stu_name, 10))

tea = Teacher('kevin', 19, 'female')
print(tea.name)
print(tea.age)
print(tea.gender)

抽象

继承

单继承下的属性查找

class A():
    def f2(self):
        pass

class Foo(A):
    def __f1(self):  # _Foo__f1
        print('from Foo.f1')

    # def f2(self):
    #     print('from Foo.f2')
    #     self.__f1() # _Foo__f1


class Bar(Foo):
    def __f1(self): # _Bar__f1
        print('from Bar.f1') # from Bar.f1
"""单继承下的属性查找：先从对象自己名称空间中查找，然后去产生这个对象的类中查找，最后去继承的父类中查找."""
obj = Bar()
obj.f2()  #

多继承下的属性查找

多继承下分菱形查找和非菱形查找

菱形查找分经典类和新式类
经典类：按照深度优先的查找顺序
新式类：按照广度优先查找

多继承结构为非菱形结构

深度优先和广度优先

class G: # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->G->C->F->D->object
# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试

class G(object):
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

"""python3中都是新式类，都是广度优先查询"""

super和mro的使用


class A:
    def test(self):
        super().test()


class B:
    def test(self):
        print('from B')


class C(A, B):
    pass

"""mro列表是通过一个C3算法得出来的，我们无需明白底层原理，只需要知道每个类的mro列表到底是什么，然后按照这个列表去查找就行"""
# 在打印mro列表的时候，一定是从起始类开始
# c = C()
# c.test()
# print(C.mro()) # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
# print(C.__mro__)

"""mro列表，每个类都有自己的mro列表，怎么查看类的mro列表"""
a = A()
# a.test()
print(A.mro()) # (<class '__main__.A'>, <class 'object'>)
print(A.__mro__)

多态与鸭子类型

多态它是面向对象的三大特征

什么是多态?

同一种事物的多种形态

举例：
水：气态水、液态水、固态水
动物：人、狗、猪、等都是动物的一种形态

之所以说人、狗、猪是动物，是因为他们都具备动物的特征，speak功能

import abc # abstract class 抽象类   具体的Specific

class Animal(metaclass=abc.ABCMeta): # 把animal类变成了抽象类
    """父类中得方法不是为了实现逻辑的，实现功能的，而是单纯的为了限制子类的行为"""
    @abc.abstractmethod # 把抽象类中得方法变成抽象方法， 它不实现具体的功能，就是单纯的为了限制子类中的方法
    def speak(self):
        pass
    @abc.abstractmethod
    def jiao(self):
        pass


"""抽象类和普通类有什么区别? 抽象类只能够被继承、不能够被实例化"""

# Animal() # Can't instantiate abstract class Animal with abstract methods speak

"""怎么限制子类People类必须有speak功能? 我们可以在父类中来限制子类的行为，其实就是限制子类中必须有某些方法"""

"""Python崇尚的是鸭子类型"""

"""鸭子类型就是更多的关注的是对象的行为，而不是对象的类型"""

class People(Animal):
    def speak(self):pass
        # print('from People.speak')
    def jiao(self):
        pass

class Dog(Animal):
    def speak(self):
        pass


class Pig(Animal):
    def speak(self):
        pass

"""多态带来的特性：在不考虑对象类型的情况下，直接调用对象的方法或者属性"""
def animal(obj):
    return obj.speak()

animal(obj)
animal(obj1)
animal(obj2)

"""面试题：请举出Python中使用多态的例子：len"""

len('hello')
len([1,2,3,4])
len((1,2,3,4))


def len(obj):
    return obj.__len__
len('helloworld')
len([1,2,3,4])
len((1,2,3,4))