笨方法学Python习题 45: 对象、类、以及从属关系

最新推荐文章于 2024-09-25 08:30:00 发布

pony_kinght

最新推荐文章于 2024-09-25 08:30:00 发布

阅读量853

点赞数 1

CC 4.0 BY-SA版权

分类专栏：笔记文章标签： python class

本文链接：https://blog.youkuaiyun.com/pony_kinght/article/details/78508770

笔记专栏收录该内容

6 篇文章

订阅专栏

本文探讨了Python中的object类的作用，如何将Class作为Object使用，以及Animal、Dog等类之间的函数区别。重点讲解了多重继承可能导致的问题及解决方案，通过MRO（Method Resolution Order）理解super()函数的工作原理，强调super()并不直接调用父类方法，而是遵循特定的类继承顺序。文章还引用了外部资源深入解析MRO的排列规则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码1:

## Animal is-a object (yes, sort of confusing) look at the extra credit
class Animal(object):
    pass

## Dog is-a class
class Dog(Animal):
    def __init__(self, name):

    ## Animal has-a object
    self.name = name

## Cat is-a class
class Cat(Animal):
    def __init__(self, name):
    ## Cat has-a object
    self.name = name

## Person is-a class
class Person(object):
    def __init__(self, name):

    ## Person has-a object
    self.name = name

    ## Person has-a pet of some kind
    self.pet = None

## Employee is-a class
class Employee(Person):
    def __init__(self, name, salary):

    ## ?? hmm what is this strange magic?
    super(Employee, self).__init__(name)

    ## Employee has-a object
    self.salary = salary

## Fish is-a object
class Fish(object):
    pass

## Salmon is-a class
class Salmon(Fish):
    pass

## Halibut is-a class
class Halibut(Fish):
    Pass

## rover is-a Dog
rover = Dog("Rover")

## satan is-a Cat
satan = Cat("Satan")

## mary is-a Person
mary = Person("Mary")

## mary has-a pet
mary.pet = satan

## frank is-a Employee
frank = Employee("Frank", 120000)

## frank has-a pet
frank.pet = rover

## flipper is-a Fish
flipper = Fish()

## crouse is-a Salmon
crouse = Salmon()

## harry is-a Halibut
harry = Halibut()

加分习题
1. 研究一下为什么 Python 添加了这个奇怪的叫做 object 的 class，它究竟有什么
含义呢？

有没有办法把 Class 当作 Object 使用呢？
把已经定义的基类就可以作为新定义class的object
类似于：
class A(object):
pass
class B(A):
pass
在习题中为 animals、 fish、还有 people 添加一些函数，让它们做一些事情。看看
当函数在 Animal 这样的“基类(base class)”里和在 Dog 里有什么区别。
找些别人的代码，理清里边的“是啥”和“有啥”的关系。
使用列表和字典创建一些新的一对应多的“has-many”的关系。
你认为会有一种“has-many”的关系吗？阅读一下关于“多重继承(multiple
inheritance)”的资料，然后尽量避免这种用法。

多重继承里面容易出现重复调用的情况。比如说图的右边代码明显会调用A和D两次。为了避免这种情况，可以使用左边的代码，参考注释中标明change和new的部分。
他们的运行结果如下：
这里写图片描述

MRO（类继承的顺序）我查了资料以后的发现super.init()函数并不是一定调用父类函数，它其实是一个继承的顺序标记。
搬运某个大神的理解“
super 其实干的是这事
def super(cls, inst):
mro = inst.class.mro()
return mro[mro.index(cls) + 1]
参数 cls 和 inst 分别做了两件事：
1. inst 负责生成 MRO 的 list
2. 通过 cls 定位当前 MRO 中的 index, 并返回 mro[index + 1]
这两件事才是 super 的实质，一定要记住！
MRO 全称 Method Resolution Order，它代表了类继承的顺序。
举个例子

class Root(object):
    def __init__(self):
        print("this is Root")

class B(Root):
    def __init__(self):
        print("enter B")
        # print(self)  # this will print <__main__.D object at 0x...>
        super(B, self).__init__()
        print("leave B")

class C(Root):
    def __init__(self):
        print("enter C")
        super(C, self).__init__()
        print("leave C")

class D(B, C):
    pass

d = D()
print(d.__class__.__mro__)

输出

enter B
enter C
this is Root
leave C
leave B
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.Root'>, <type 'object'>)

知道了 super 和父类其实没有实质关联之后，我们就不难理解为什么 enter B 下一句是 enter C 而不是 this is Root（如果认为 super 代表“调用父类的方法”，会想当然的认为下一句应该是this is Root）。流程如下，在 B 的 init 函数中：

super(B, self).init()
首先，我们获取 self.class.mro，注意这里的 self 是 D 的 instance 而不是 B 的

然后，通过 B 来定位 MRO 中的 index，并找到下一个。显然 B 的下一个是 C。于是，我们调用 C 的 init，打出 enter C。

顺便说一句为什么 B 的 init 会被调用：因为 D 没有定义 init，所以会在 MRO 中找下一个类，去查看它有没有定义 init，也就是去调用 B 的 init。”
其实这一切逻辑还是很清晰的，关键是理解 super 到底做了什么。

于是，MRO 中类的顺序到底是怎么排的呢？Python’s super() considered super!中已经有很好的解释，我翻译一下：
在 MRO 中，基类永远出现在派生类后面，如果有多个基类，基类的相对顺序保持不变。
大神的文章地址：https://laike9m.com/blog/li-jie-python-super,70/