别院牧志知识库 别院牧志知识库
首页
  • 基础

    • 全栈之路
    • 😎Awesome资源
  • 进阶

    • Python 工匠系列
    • 高阶知识点
  • 指南教程

    • Socket 编程
    • 异步编程
    • PEP 系列
  • 面试

    • Python 面试题
    • 2022 面试记录
    • 2021 面试记录
    • 2020 面试记录
    • 2019 面试记录
    • 数据库索引原理
  • 基金

    • 基金知识
    • 基金经理
  • 细读经典

    • 德隆-三个知道
    • 孔曼子-摊大饼理论
    • 配置者说-躺赢之路
    • 资水-建立自己的投资体系
    • 反脆弱
  • Git 参考手册
  • 提问的智慧
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
首页
  • 基础

    • 全栈之路
    • 😎Awesome资源
  • 进阶

    • Python 工匠系列
    • 高阶知识点
  • 指南教程

    • Socket 编程
    • 异步编程
    • PEP 系列
  • 面试

    • Python 面试题
    • 2022 面试记录
    • 2021 面试记录
    • 2020 面试记录
    • 2019 面试记录
    • 数据库索引原理
  • 基金

    • 基金知识
    • 基金经理
  • 细读经典

    • 德隆-三个知道
    • 孔曼子-摊大饼理论
    • 配置者说-躺赢之路
    • 资水-建立自己的投资体系
    • 反脆弱
  • Git 参考手册
  • 提问的智慧
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
  • 辨析

  • Sockets编程

  • Django

  • stackoverflow

  • Flask

  • 全栈之路

  • 面试

  • 代码片段

  • 异步编程

  • 😎Awesome资源

  • PEP

  • Python工匠系列

  • 高阶知识点

    • Python 中的 GIL
    • 关于 Python 闭包理解
    • Python 中的元类
    • Python 装饰器✨
    • Python 缓存机制与 functools.lru_cache
    • Python 受推崇的 super
      • 推荐阅读
    • Python 中的 MRO 与多继承
    • (译)Python 魔法方法指南
    • Python 的内存管理与垃圾回收机制
  • Python 学习资源待整理
  • 设计模式

  • 如何使用 Python 操作 RabbitMQ
  • 好“艹蛋”的 Python 呀!
  • FIFO | 待学清单📝
  • pip 安装及使用
  • 数据分析

  • 源码阅读计划

  • OOP

  • 关于 python 中的 setup.py
  • 并行分布式框架 Celery
  • 七种武器,让你的代码提高可维护性
  • 使用 pdb 调试 Python 代码
  • 每周一个 Python 标准库
  • 🐍Python
  • 高阶知识点
佚名
2020-08-06
目录

Python 受推崇的 super

如果你没有被 Python 内置的 super() 惊艳到,那很有可能是你并没有真正了解它能够做什么,以及如何高效地使用它。
关于 super() 的文章已经有很多了,其中很多文章以失败告终。这篇文章尝试通过以下几种方式来改变这种情形:

  • 提供实际使用的例子
  • 对于工作原理给出清晰的模型
  • 每次都展示出使它工作的要点
  • 对于使用 super() 来创建类给出具体建议
  • 给出有帮助的真实示例而不是抽象的 ABCD 钻石图表 (opens new window)

这篇文章中的示例兼容 Python 2 语法 (opens new window) 及 Python 3 语法 (opens new window) 两种版本。

我们使用 Python 3 语法,从一个基础的扩展了 Python 内置类型方法的子类示例开始。

class LoggingDict(dict):
    def __setitem__(self, key, value):
        logging.info('Settingto %r' % (key, value))
        super().__setitem__(key, value)
1
2
3
4

这个类拥有与它父类(字典)相同的所有功能,不过它扩展了 __setitem__ 方法,无论哪一个键被更新,该条目都会被记录下来。记录完更新的条目之后,该方法使用 super() 将更新键值对的实际工作委托给它的父类。

在介绍 super() 之前,我们可能会使用具体的类名来调用 dict.__setitem__(self, key, value) 。但是, super() 会更好一些,因为它是通过计算得到的而非直接引用。

非直接引用的好处之一是我们不必通过具体的类名来指定执行操作的对象。如果你修改源代码,将原来的基类变成别的类,那么 super() 引用会自动变成对应的基类。下面这个实例可以说明这一点:

 # new base class
 class LoggingDict(SomeOtherMapping):
     def __setitem__(self, key, value):
         logging.info('Settingto %r' % (key, value))
         # no change needed
         super().__setitem__(key, value)
1
2
3
4
5
6

除了隔离更改之外,计算间接性还有另一个主要好处,即来自静态语言的人可能不熟悉的间接性。由于间接计算是在运行时计算的,因此我们可以自由地改变计算过程,以便间接指向其他类。

这个计算由调用 super 的类和它的祖先树共同决定。第一个要素,也就是调用 super 的类,是由实现这个类的源代码所决定。在我们的示例中, super() 是在 LoggingDict.__setitem__ 方法中被调用。这个要素是固定的。第二个要素,也是更有趣的要素,就是变量(我们可以创建新的子类,让这个子类具有丰富的祖先树))。

我们使用这个对我们有利的方法,来构建一个日志记录排序字典(logging ordered dictionary),而不用修改已经存在的代码。

    class LoggingOD(LoggingDict, collections.OrderedDict):
        pass
1
2

我们构建的新类的祖先树是: LoggingOD, LoggingDict, OrderedDict, dict, object。对于我们的目标来说,重要的结果是 OrderedDict 被插入到 LoggingDict 之后,并且在 dict 之前。这意味着现在 LoggingDict.__setitem__ 中的 super() 调用把更新键值对的工作交给了 OrderedDict 而不是 dict 。

稍微思考一下这个结果。我们之前并没有替换掉 LoggingDict 的源代码。相反,我们创建了一个子类,它的唯一逻辑就是将两个已有的类结合起来,并控制它们的搜索顺序。

# 搜索顺序

我所说的搜索顺序或者祖先树,正式的名称是 方法解析顺序(Method Resolution Order),简称 MRO。通过打印 __mro__ 属性,我们很容易就能获取 MRO。

 >>> pprint(LoggingOD.__mro__)
 (<class '__main__.LoggingOD'>,
  <class '__main__.LoggingDict'>,
  <class 'collections.OrderedDict'>,
  <class 'dict'>,
  <class 'object'>)
1
2
3
4
5
6

如果我们的目标是创建一个具有我们想要的 MRO 的子类,我们需要知道它是如何被计算出来的。基础部分很简单。这个序列包含了类本身,它的基类,以及基类的基类,一直到所有类的祖先类 object 。这个序列经过了排序,因此一个类总是出现在它的父类之前,如果有多个父类,它们保持与基类元组相同的顺序。

上面展示的 MRO 遵循以下的限制:

  • LoggingOD 在它的父类 LoggingDict 和 OrderedDict 之前
  • LoggingDict 在 OrderedDict 之前,因为 LoggingOD.__base__ 的值为 (LoggingDict, OrderedDict)
  • LoggingDict 在它的父类 dict 之前
  • OrderedDict 在它的父类 dict 之前
  • dict 在它的父类 object 之前

解决这些限制的过程被称为线性化, 关于这个话题有许多优秀的论文,但要创建具有我们想要的 MRO 的一个子类,我们只需要知道两条限制:子类在父类之前、出现的顺序遵从 __base__ 中的顺序。

# 实用的建议

super() 的工作就是将方法调用委托给祖先树中的某个类。要让可重排列的方法调用正常工作,我们需要对这个类进行联合的设计。这就提出了三个易于解决的实际问题:

  • 被 super() 调用的方法必须存在
  • 调用者和被调用者需要具有相同的参数签名
  • 该方法的每次调用都需要使用 super()

1)我们先来看看使调用者与被调用者的参数签名相匹配的处理策略。比起传统的方法调用(提前知道被调用者是谁),这会有一点点挑战性。使用 super()编写一个类时,我们并不知道被调用者是谁(因为之后编写的子类可能会在 MRO 中引入新的类)。

一种方式是使用固定的签名,也就是位置参数。像 __setitem__ 这样的方法拥有两个参数的固定签名,一个键和一个值,这种情况下能够很好地工作。这个技术在 LoggingDict 的示例中展示过,其中 __setitem__ 在 LoggingDict 和 dict 中拥有同样的参数签名。

一种更加灵活的方式是将每一个祖先类中对应的方法都共同设计成接收关键字参数和一个关键字参数字典,将它需要的参数移除,并将剩余的参数通过 **kwds 继续传递,最终会在最后的调用中剩下一个空字典。

每一层都剥离它所需要的关键字参数,最后的空字典可以被传递给一个不需要任何参数的方法(例如: object.__init__ 不需要任何参数)

 class Shape:
     def __init__(self, shapename, **kwds):
         self.shapename = shapename
         super().__init__(**kwds)        

 class ColoredShape(Shape):
     def __init__(self, color, **kwds):
         self.color = color
         super().__init__(**kwds)

 cs = ColoredShape(color='red', shapename='circle')
1
2
3
4
5
6
7
8
9
10
11
  1. 看完了使调用者和被调用者的参数模式相匹配的策略,我们现在来看看如何保证目标方法存在。

上面的示例展示了最简单的情况。我们知道 object 有一个 __init__ 方法,并且 object 永远是 MRO 链中的最后一个类,所以任何调用 super().__init__ 的序列都会以调用 object.__init__ 方法作为结尾。换句话说,我们能确保 super() 调用的目标肯定存在,一定不会发生 AttributeError 的错误。

对于我们想要的方法在 object 中并不存在的情况(假设就叫 draw() 方法),我们需要编写一个一定会在 object 之前被调用的根类(root class)。这个根类的作用是在 object 之前将该方法的调用吞噬掉,避免 super() 的继续调用。

Root.draw 还能够利用防御式编程 (opens new window),通过使用 assertion 语句来确保它没有屏蔽掉 MRO 链中的其它 draw() 调用。当一个子类错误地整合某个拥有 draw() 方法的类,但却没有继承 Root 类时就可能发生这种情况:

 class Root:
     def draw(self):
         # the delegation chain stops here
         assert not hasattr(super(), 'draw')

 class Shape(Root):
     def __init__(self, shapename, **kwds):
         self.shapename = shapename
         super().__init__(**kwds)
     def draw(self):
         print('Drawing.  Setting shape to:', self.shapename)
         super().draw()

 class ColoredShape(Shape):
     def __init__(self, color, **kwds):
         self.color = color
         super().__init__(**kwds)
     def draw(self):
         print('Drawing.  Setting color to:', self.color)
         super().draw()

 cs = ColoredShape(color='blue', shapename='square')
 cs.draw()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

如果子类想要将其它类注入到 MRO 链中,那么那些被插入的类也需要继承 Root ,以确保任何途径下调用 draw() 方法都不会到达 object 类,而是会被 Root.draw 所拦截而终止。这一点应该清楚地写到文档中,这样一来如果有人编写与之相关的类,就知道应该继承 Root 类。这一限制,与 Python 要求所有异常类都要继承 BaseException 没有多大区别。

  1. 上面展示的技术可确保 super() 调用的是一个已知存在、并且参数签名正确的方法。然而,我们仍依赖于 super() 在每一步中都被调用,以便委托链继续不被破坏。我们如果联合设计这些类,那么这一点很容易实现——只需要在调用链中的每一个方法中都添加一个 super() 调用。

上面列出的三种技术提供了设计可以由子类组成或重新排序的协作类(cooperative classes)的方法。

# 如何合并一个非联合(Non-cooperative)类

偶然情况下,一个子类可能想要对一个并非给它设计的第三方类使用联合多继承技术(可能该第三方类的有关方法并没有使用 super() 或可能它并没有继承 Root 类)。这种情况可以通过创建一个符合规则的适配器类(adapter class (opens new window))来轻松解决。

例如,下面的 Moveable 类没有调用 super() ,并且它的 __init__() 与 object.__init__() 的签名不兼容,此外它还没有继承 Root :

 class Moveable:
     def __init__(self, x, y):
         self.x = x
         self.y = y
     def draw(self):
         print('Drawing at position:', self.x, self.y)
1
2
3
4
5
6

如果我们想要将该类与我们联合设计的 ColoredShape 分层结构(hierarchy)一起使用,我们需要创建一个包含必要的 super() 调用的适配器:

 class MoveableAdapter(Root):
     def __init__(self, x, y, **kwds):
         self.movable = Moveable(x, y)
         super().__init__(**kwds)
     def draw(self):
         self.movable.draw()
         super().draw()

 class MovableColoredShape(ColoredShape, MoveableAdapter):
     pass

 MovableColoredShape(color='red', shapename='triangle',
                     x=10, y=20).draw()
1
2
3
4
5
6
7
8
9
10
11
12
13

# 完整示例(只是为了有趣)

在 Python 2.7 和 3.2 中,collections 模块有 Counter 和 OrderedDict 两个类。这两个类可以容易地组合成一个 OrderedCounter 类:

 from collections import Counter, OrderedDict

 class OrderedCounter(Counter, OrderedDict):
      'Counter that remembers the order elements are first seen'
      def __repr__(self):
          return '%s(%r)' % (self.__class__.__name__,
                             OrderedDict(self))
      def __reduce__(self):
          return self.__class__, (OrderedDict(self),)

 oc = OrderedCounter('abracadabra')
1
2
3
4
5
6
7
8
9
10
11

# 说明和引用

  • 当继承内置的数据类型如 dict() 来创建子类的时候,通常有必要同时重载或扩展多个方法。在上面的示例中,__setitem__ 的扩展没有被其它方法如 dict.update 所使用,因此也可能有必要对那些方法进行扩展。这一要求并非是 super() 所特有的,相反,任何通过继承内置类型创建子类的情况都需要满足这个要求。

  • 如果一个类依赖于一个父类,而这个父类又依赖于另一个类(例如,LoggingOD 依赖于 LoggingDict,而后者出现在 OrderedDict 之前,最后才是 dict),那么很容易通过添加断言(assertions)来验证并记录预计的方法解析顺序(MRO):

 position = LoggingOD.__mro__.index
 assert position(LoggingDict) < position(OrderedDict)
 assert position(OrderedDict) < position(dict)
1
2
3
  • 关于线性化算法的优秀文章可以参考 Python MRO documentation (opens new window) 和 Wikipedia entry for C3 Linearization (opens new window)

  • Dylan 编程语言 (opens new window)有一个 next-method 构造函数,类似于 Python 的 super() 。有关它工作原理的简短文章,请参考 Dylan's class docs (opens new window)

  • 这篇文章使用的是 Python 3 版本的 super()。全部的源码可以在此处获取:Recipe 577720 (opens new window) 。Python 2 语法的不同之处在于传递给 super() 方法的参数在类型和对象上是明确的。另外,Python 2 版本的 super() 只对新式的(new-style)类有效(即那些明确从某个对象或其它内置类型继承的类)。使用 Python 2 语法的全部源码可以在此处获取: Recipe 577721 (opens new window) 。

# 致谢

数位 Python 开发者做了此文章发表前的审阅。他们的意见很大程度上提高了这篇文章的质量。

他们是:Laura Creighton, Alex Gaynor, Philip Jenvey, Brian Curtin, David Beazley, Chris Angelico, Jim Baker, Ethan Furman, and Michael Foord. 撒花.

# 译者补充

花了一些时间,终于翻译完了这篇文章。原文中有一些地方本身写得易于理解,但翻译成中文会有点绕。由于水平有限,翻译得不准确的地方还请大家指出,如果有什么想法欢迎留言一起探讨。

英文原文:Python's super() considered super! (opens new window)

# 版权信息

译者:Wray Zheng (opens new window)
译文来源: [译]Python 受推崇的 super! - 掘金 (opens new window)

# 推荐阅读

  • Things to Know About Python Super [1 of 3] (opens new window)
  • 关于 Python 的 Mixin 模式 | 思诚之道 (opens new window)
  • Python: super 没那么简单 - Huang Huang 的博客 (opens new window)
  • Multiple inheritance and mixin classes in Python - The Digital Cat (opens new window)
  • 8.18 利用 Mixins 扩展类功能 — python3-cookbook 3.0.0 文档 (opens new window)
  • 彻底搞懂 python super 函数的作用_技术成就梦想,梦想成就未来。-CSDN 博客 (opens new window)
  • Supercharge Your Classes With Python super() – Real Python (opens new window)
编辑 (opens new window)
#Python#Mixin#super#类继承
上次更新: 2023-03-17, 02:52:41
Python 缓存机制与 functools.lru_cache
Python 中的 MRO 与多继承

← Python 缓存机制与 functools.lru_cache Python 中的 MRO 与多继承→

最近更新
01
延米
03-23
02
装修名词
03-23
03
它山之石,可以攻玉,装修知识从哪学?
03-22
更多文章>
Theme by Vdoing | Copyright © 2019-2023 IMOYAO | 别院牧志
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式