详解加强算术赋值：“-=”操做是怎么实现的？

花下猫语： 本篇译文还是 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 版本已处于仅安全维护模式，所以文档不会变动）。

修复的代码极可能不会被移植，由于它是语义上的变化，而且很难判断是否有人意外地依赖了有问题的语义。可是这个问题花了很长时间才被注意到，这就代表 **= 的使用并不普遍，不然问题早就被发现了。