写点什么

详解增强算术赋值:“-=”操作是怎么实现的?

用户头像
Python猫
关注
发布于: 2020 年 09 月 10 日
详解增强算术赋值:“-=”操作是怎么实现的?



花下猫语: 本篇译文仍是 Brett 大佬的“Python语法糖”系列,他在演示“-=”操作的实现时,竟发现 CPython 的一个 bug,顺手就修复了,这才是大佬……



原题 | Unravelling augmented arithmetic assignment



作者 | Brett Cannon



译者 | 豌豆花下猫(“Python猫”公众号作者)



声明 | 本翻译是出于交流学习的目的,基于 CC BY-NC-SA 4.0 授权协议。为便于阅读,内容略有改动。



序言



本文是 Python语法糖 系列文章之一。最新的源代码可以在 desugar 项目中找到(https://github.com/brettcannon/desugar)。



介绍



Python 有一种叫做增强算术赋值(augmented arithmetic assignment)的东西。可能你不熟悉这个叫法,其实就是在做数学运算的同时进行赋值,例如 a -= b 就是减法的增强算术赋值。



增强赋值是在 Python 2.0 版本中 加入进来的。(译注:在 PEP-203 中引入)



剖析-=



因为 Python 不允许覆盖式赋值,所以相比其它有特殊/魔术方法的操作,它实现增强赋值的方式可能跟你想象的不完全一样。



首先,要知道a -= b在语义上与 a = a-b 相同。但也要意识到,如果你预先知道要将一个对象赋给一个变量名,相比a - b 的盲操作,就可能会更高效。



例如,最起码的好处是可以避免创建一个新对象:如果可以就地修改一个对象,那么返回 self,就比重新构造一个新对象要高效。



因此,Python 提供了一个__isub__() 方法。如果它被定义在赋值操作的左侧(通常称为 lvalue),则会调用右侧的值(通常称为 rvalue )。所以对于a -= b ,就会尝试去调用 a.__isub__(b)。



如果调用的结果是 NotImplemented,或者根本不存在结果,那么 Python 会退回到常规的二元算术运算a - b。(译注:作者关于二元运算的文章,译文在此



最终无论用了哪种方法,返回值都会被赋值给 a。



下面是简单的伪代码,a -= b 被分解成:



# 实现 a -= b 的伪代码
if hasattr(a, "__isub__"):
  _value = a.__isub__(b)
  if _value is not NotImplemented:
      a = _value
  else:
      a = a - b
  del _value
else:
    a = a - b

归纳这些方法



由于我们已经实现了二元算术运算,因此归纳增强算术运算并不太复杂。



通过传入二元算术运算函数,并做一些自省(以及处理可能发生的 TypeError),它可以被漂亮地归纳成:



def _create_binary_inplace_op(binary_op: _BinaryOp) -> Callable[[Any, Any], Any]:
  binary_operation_name = binary_op.__name__[2:-2]
  method_name = f"__i{binary_operation_name}__"
  operator = f"{binary_op._operator}="
  def binary_inplace_op(lvalue: Any, rvalue: Any, /) -> Any:
      lvalue_type = type(lvalue)
      try:
          method = debuiltins._mro_getattr(lvalue_type, method_name)
      except AttributeError:
          pass
      else:
          value = method(lvalue, rvalue)
          if value is not NotImplemented:
              return value
      try:
          return binary_op(lvalue, rvalue)
      except TypeError as exc:
          # If the TypeError is due to the binary arithmetic operator, suppress
          # it so we can raise the appropriate one for the agumented assignment.
          if exc._binary_op != binary_op._operator:
              raise
      raise TypeError(
          f"unsupported operand type(s) for {operator}: {lvalue_type!r} and {type(rvalue)!r}"
      )
  binary_inplace_op.__name__ = binary_inplace_op.__qualname__ = method_name
  binary_inplace_op.__doc__ = (
      f"""Implement the augmented arithmetic assignment `a {operator} b`."""
  )
  return binary_inplace_op

这使得定义的 -= 支持 _create_binary_inplace_op(__ sub__),且可以推断出其它内容:函数名、调用什么 __i*__ 函数,以及当二元算术运算出问题时,该调用哪个可调用对象。



我发现几乎没有人使用**=



在写本文的代码时,我碰上了 **= 的一个奇怪的测试错误。在所有确保 __pow__ 会被适当地调用的测试中,有个测试用例对于 Python 标准库中的operator 模块却是失败。



我的代码通常没问题,如果代码与 CPython 的代码之间存在差异,通常会意味着是我哪里出错了。



但是,无论我多么仔细地排查代码,我都无法定位出为什么我的测试会通过,而标准库则失败。



我决定深入地了解 CPython 内部发生了什么。从反汇编字节码开始:



>>> def test(): a **= b
...
>>> import dis
>>> dis.dis(test)
1           0 LOAD_FAST               0 (a)
            2 LOAD_GLOBAL             0 (b)
            4 INPLACE_POWER
            6 STORE_FAST               0 (a)
            8 LOAD_CONST               0 (None)
            10 RETURN_VALUE

通过它,我找到了在 eval 循环中的INPLACE_POWER



      case TARGET(INPLACE_POWER): {
          PyObject *exp = POP();
          PyObject *base = TOP();
          PyObject *res = PyNumber_InPlacePower(base, exp, Py_None);
          Py_DECREF(base);
          Py_DECREF(exp);
          SET_TOP(res);
          if (res == NULL)
              goto error;
          DISPATCH();
      }

出处:https://github.com/python/cpython/blob/v3.8.3/Python/ceval.c#L1677



然后找到PyNumber_InPlacePower()



PyObject *
PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
{
  if (v->ob_type->tp_as_number &&
      v->ob_type->tp_as_number->nb_inplace_power != NULL) {
      return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
  }
  else {
      return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
  }
}

出处:https://github.com/python/cpython/blob/v3.8.3/Objects/abstract.c#L1172



松了口气~代码显示如果定义了__ipow__,则会调用它,但是只在没有__ipow__ 时,才会调用__pow__。



然而,正确的做法应该是:如果调用__ipow__ 时出问题,返回了 NotImplemented 或者根本不存在返回,那么就应该调用 __pow__ 和__rpow__。



换句话说,当存在__ipow__ 时,以上代码会意外地跳过 a**b 的后备语义!



实际上,大约11个月前,这个问题被部分地发现,并提交了 bug。我修复了该问题,并在 python-dev 上作了说明。



截至目前,这似乎会在 Python 3.10 中修复,我们还需要在 3.8 和 3.9 的文档中添加关于 **= 有 bug 的通知(该问题可能很早就有了,但较旧的 Python 版本已处于仅安全维护模式,因此文档不会变更)。



修复的代码很可能不会被移植,因为它是语义上的变化,并且很难判断是否有人意外地依赖了有问题的语义。但是这个问题花了很长时间才被注意到,这就表明 **= 的使用并不广泛,否则问题早就被发现了。



发布于: 2020 年 09 月 10 日阅读数: 416
用户头像

Python猫

关注

Python猫作者,一个Python爱好者 2018.08.07 加入

历史文章会陆续搬运过来,欢迎大家在微信搜索“Python猫”,也可以找到我

评论

发布
暂无评论
详解增强算术赋值:“-=”操作是怎么实现的?