Python3:单分派类，如何分派自我类型

Question

使用python3.4。这里我想使用singledispatch来调度不同类型的__mul__方法。代码如下:

class Vector(object):
    ## some code not paste  
    @functools.singledispatch
    def __mul__(self, other):
        raise NotImplementedError("can't mul these type")
    @__mul__.register(int)
    @__mul__.register(object)                # Becasue can't use Vector , I have to use object 
    def _(self, other):
        result = Vector(len(self))           # start with vector of zeros
        for j in range(len(self)):
            result[j] = self[j]*other
        return result
    @__mul__.register(Vector)                # how can I use the self't type
    @__mul__.register(object)                # 
    def _(self, other):
        pass # need impl 

正如你所看到的代码，我想支持Vector*Vertor，这有名称错误

Traceback (most recent call last):
  File "p_algorithmsvector.py", line 6, in <module>
    class Vector(object):
  File "p_algorithmsvector.py", line 84, in Vector
    @__mul__.register(Vector)                   # how can I use the self't type
NameError: name 'Vector' is not defined

问题可能是我如何在类的方法中使用类名和类型?我知道c++有字体类语句。python如何解决我的问题?Vector可以用在方法体中，而result = Vector(len(self))却可以用在方法体中，这很奇怪。

---

看完http://lukasz.langa.pl/8/single-dispatch-generic-functions/我可以选择这样来实现:

import unittest
from functools import  singledispatch
class Vector(object):
    """Represent a vector in a multidimensional space."""
    def __init__(self, d):
        self._coords = [0 for i in range(0, d)]
        self.__init__mul__()

    def __init__mul__(self):
        __mul__registry = self.__mul__.registry
        self.__mul__ = singledispatch(__mul__registry[object])
        self.__mul__.register(int, self.mul_int)
        self.__mul__.register(Vector, self.mul_Vector)
    def __setitem__(self, key, value):
        self._coords[key] = value
    def __getitem__(self, item):
        return self._coords[item]
    def __len__(self):
        return len(self._coords)
    def __str__(self):
        return str(self._coords)
    @singledispatch
    def __mul__(self, other):
        print ("error type is ", type(other))
        print (type(other))
        raise NotImplementedError("can't mul these type")
    def mul_int(self,other):
         print ("other type is ", type(other))
         result = Vector(len(self))           # start with vector of zeros
         for j in range(len(self)):
             result[j] = self[j]*other
         return result
    def mul_Vector(self, other):
        print ("other type is ", type(other))
        #result = Vector(len(self))           # start with vector of zeros
        sum = 0
        for i in range(0,len(self)):
            sum += self._coords[i] * other._coords[i]
        return sum
class TestCase(unittest.TestCase):
    def test_singledispatch(self):
        # the following demonstrates usage of a few methods
        v = Vector(5)              # construct five-dimensional <0, 0, 0, 0, 0>
        for i in range(1,6):
            v[i-1] = i
        print(v.__mul__(3))
        print(v.__mul__(v))
        print(v*3)
if __name__ == "__main__":
    unittest.main()

答案很奇怪:

other type is  <class 'int'>
[3, 6, 9, 12, 15]
other type is  <class '__main__.Vector'>
55
error type is  <class 'int'>
Traceback (most recent call last):
  File "p_algorithmsvector.py", line 164, in <module>
    print(v*3)
  File "C:Python34libfunctools.py", line 710, in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
  File "p_algorithmsvector.py", line 111, in __mul__
    raise NotImplementedError("can't mul these type")

v.__mul__(3)可以工作，但v*3不能工作。这是奇怪的，从我的选项v*3是一样的v.__mul__(3)。

---

更新@ martinjn Pieters的评论后，我仍然想在课堂上实现v*3。所以我试试这个

import unittest
from functools import  singledispatch
class Vector(object):
    @staticmethod
    def static_mul_int(self,other):
         print ("other type is ", type(other))
         result = Vector(len(self))           # start with vector of zeros
         for j in range(len(self)):
             result[j] = self[j]*other
         return result
    @singledispatch
    @staticmethod
    def __static_mul__(cls, other):
        print ("error type is ", type(other))
        print (type(other))
        raise NotImplementedError("can't mul these type")

    __mul__registry2 = __static_mul__.registry
    __mul__ = singledispatch(__mul__registry2[object])
    __mul__.register(int, static_mul_int)
    def __init__(self, d):
        self._coords = [0 for i in range(0, d)]
        self.__init__mul__()

    def __init__mul__(self):
        __mul__registry = self.__mul__.registry
        print ("__mul__registry",__mul__registry,__mul__registry[object])
        self.__mul__ = singledispatch(__mul__registry[object])
        self.__mul__.register(int, self.mul_int)
        print ("at last __mul__registry",self.__mul__.registry)
    # @singledispatch
    # def __mul__(self, other):
    #     print ("error type is ", type(other))
    #     print (type(other))
    #     raise NotImplementedError("can't mul these type")

    def mul_int(self,other):
         print ("other type is ", type(other))
         result = Vector(len(self))           # start with vector of zeros
         for j in range(len(self)):
             result[j] = self[j]*other
         return result
    def __setitem__(self, key, value):
        self._coords[key] = value
    def __getitem__(self, item):
        return self._coords[item]
    def __len__(self):
        return len(self._coords)
    def __str__(self):
        return str(self._coords)

class TestCase(unittest.TestCase):
    def test_singledispatch(self):
        # the following demonstrates usage of a few methods
        v = Vector(5)              # construct five-dimensional <0, 0, 0, 0, 0>
        for i in range(1,6):
            v[i-1] = i
        print(v.__mul__(3))
        print("type(v).__mul__'s registry:",type(v).__mul__.registry)
        type(v).__mul__(v, 3)
        print(v*3)
if __name__ == "__main__":
    unittest.main() 

这一次。v.__mul__(3)有错误:

Traceback (most recent call last):
  File "test.py", line 73, in test_singledispatch
    type(v).__mul__(v, 3)
  File "/usr/lib/python3.4/functools.py", line 708, in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
TypeError: 'staticmethod' object is not callable

对于我来说静态方法应该像实例方法一样。

Answer 1

您根本不能在方法上使用functools.singledispatch ，至少不能作为装饰器使用。Python 3.8为方法增加了一个新选项:functools.singledispatchmethod()。

这里没有定义Vector并不重要;任何方法的第一个参数总是self，而您将对第二个参数使用单调度。

因为在类对象创建之前，装饰器应用于函数对象，所以您可以将您的'方法'注册为函数，在类主体的之外，所以您可以访问Vector名称:

class Vector(object):
    @functools.singledispatch
    def __mul__(self, other):
        return NotImplemented
@Vector.__mul__.register(int)
@Vector.__mul__.register(Vector)                
def _(self, other):
    result = Vector(len(self))           # start with vector of zeros
    for j in range(len(self)):
        result[j] = self[j]*other
    return result

对于不支持的类型，您需要返回NotImplemented 单例，而不是引发异常。这样，Python也会尝试反向操作。

然而，由于调度将在上键入错误的参数 (self)，因此您必须提出自己的单一调度机制。

如果你真的想使用@functools.singledispatch，你必须委托给一个常规的函数，用参数反转:

@functools.singledispatch
def _vector_mul(other, self):
    return NotImplemented
class Vector(object):
    def __mul__(self, other):
        return _vector_mul(other, self)

@_vector_mul.register(int)
def _vector_int_mul(other, self):
    result = Vector(len(self))
    for j in range(len(self)):
        result[j] = self[j] * other
    return result

对于您使用__init__mul__的更新:v * 3是而不是翻译为v.__mul__(3)。它被翻译为type(v).__mul__(v, 3)，参见Python数据模型参考中的特殊方法查找。这个总是绕过直接在实例上设置的任何方法。

这里type(v)是Vector;Python查找函数，它不会在这里使用绑定方法。同样，因为functools.singledispatch总是在第一个参数上调度，所以你不能直接在Vector的方法上使用单个调度，因为第一个参数总是一个Vector实例。

换句话说，Python将不使用您在__init__mul__中在self上设置的方法;特殊方法永远不会在实例中查找，请参阅数据模型文档中的特殊方法查找。

Python 3.8添加的functools.singledispatchmethod()选项使用类作为实现描述符协议的装饰器，就像方法一样。这允许它在绑定之前处理调度(因此在self将被添加到参数列表之前)，然后绑定singledispatch调度程序返回的注册函数。此实现的源代码与旧版本的Python完全兼容，因此您可以使用它:

from functools import singledispatch, update_wrapper
# Python 3.8 singledispatchmethod, backported
class singledispatchmethod:
    """Single-dispatch generic method descriptor.
    Supports wrapping existing descriptors and handles non-descriptor
    callables as instance methods.
    """
    def __init__(self, func):
        if not callable(func) and not hasattr(func, "__get__"):
            raise TypeError(f"{func!r} is not callable or a descriptor")
        self.dispatcher = singledispatch(func)
        self.func = func
    def register(self, cls, method=None):
        """generic_method.register(cls, func) -> func
        Registers a new implementation for the given *cls* on a *generic_method*.
        """
        return self.dispatcher.register(cls, func=method)
    def __get__(self, obj, cls):
        def _method(*args, **kwargs):
            method = self.dispatcher.dispatch(args[0].__class__)
            return method.__get__(obj, cls)(*args, **kwargs)
        _method.__isabstractmethod__ = self.__isabstractmethod__
        _method.register = self.register
        update_wrapper(_method, self.func)
        return _method
    @property
    def __isabstractmethod__(self):
        return getattr(self.func, '__isabstractmethod__', False)

并将其应用于Vector()类。在类创建之后，您仍然需要为单个调度注册Vector实现，因为只有这样才能为类注册调度:

class Vector(object):
    def __init__(self, d):
        self._coords = [0] * d
    def __setitem__(self, key, value):
        self._coords[key] = value
    def __getitem__(self, item):
        return self._coords[item]
    def __len__(self):
        return len(self._coords)
    def __repr__(self):
        return f"Vector({self._coords!r})"
    def __str__(self):
        return str(self._coords)
    @singledispatchmethod
    def __mul__(self, other):
        return NotImplemented
    @__mul__.register
    def _int_mul(self, other: int):
        result = Vector(len(self))
        for j in range(len(self)):
            result[j] = self[j] * other
        return result
@Vector.__mul__.register
def _vector_mul(self, other: Vector):
    return sum(sc * oc for sc, oc in zip(self._coords, other._coords))

当然，你也可以先创建一个子类，然后在此基础上进行分派，因为分派也适用于子类:

class _Vector(object):
    def __init__(self, d):
        self._coords = [0] * d
class Vector(_Vector):
    def __setitem__(self, key, value):
        self._coords[key] = value
    def __getitem__(self, item):
        return self._coords[item]
    def __len__(self):
        return len(self._coords)
    def __repr__(self):
        return f"{type(self).__name__}({self._coords!r})"
    def __str__(self):
        return str(self._coords)
    @singledispatchmethod
    def __mul__(self, other):
        return NotImplemented
    @__mul__.register
    def _int_mul(self, other: int):
        result = Vector(len(self))
        for j in range(len(self)):
            result[j] = self[j] * other
        return result
    @__mul__.register
    def _vector_mul(self, other: _Vector):
        return sum(sc * oc for sc, oc in zip(self._coords, other._coords))

Answer 2

这有点难看，因为您需要延迟绑定Vector/Vector乘法的实现，直到实际定义了Vector之后。但是这个想法是，单分派函数需要第一个参数是任意类型的，因此Vector.__mul__将以self作为第二个参数调用该函数。

import functools
class Vector:
    def __mul__(self, other):
        # Python has already dispatched Vector() * object() here, so
        # swap the arguments so that our single-dispatch works. Note
        # that in general if a*b != b*a, then the _mul_by_other
        # implementations need to compensate.
        return Vector._mul_by_other(other, self)
    @functools.singledispatch
    def _mul_by_other(x, y):
        raise NotImplementedError("Can't multiply vector by {}".format(type(x)))
    @_mul_by_other.register(int)
    def _(x, y):
        print("Multiply vector by int")
@Vector._mul_by_other.register(Vector)
def _(x, y):
    print("Multiply vector by another vector")
x = Vector()
y = Vector()
x * 3
x * y
try:
    x * "foo"
except NotImplementedError:
    print("Caught attempt to multiply by string")