学习Python的第24天

最新推荐文章于 2024-08-13 17:31:17 发布

m0_65470895

最新推荐文章于 2024-08-13 17:31:17 发布

阅读量27

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/m0_65470895/article/details/133715463

版权

本文介绍了Python中的继承机制，包括单继承和多继承的概念，以及如何使用继承解决代码冗余问题。讨论了Python中经典类和新式类的区别，以及在单继承和多继承下属性查找的规则。此外，文中还涉及了super关键字、方法重写与mro列表，以及多态和鸭子类型的概念。

摘要由CSDN通过智能技术生成

1.继承

1.1定义

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

1.2为什么要用继承

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

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

1.3怎么使用继承

 经典类：没有继承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'>)

2.单继承下的属性查找

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

3.多继承的属性查找

3.1定义

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

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

3.2查找方式详细

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中都是新式类，都是广度优先查询"""

4.super和orm的使用

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

5.多态和鸭子类型

5.1定义

多态指的是对象的三大特征，多态就是同一种事物的多样性。

5.2抽象类和普通类的区别

抽象类只能够被继承、不能够被实例化

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)