子类化 ndarray

介绍

子类化 ndarray 相对简单,但与其他 Python 对象相比有一些复杂性.在本页中,我们将解释允许你子类化 ndarray 的机制,以及实现子类化的含义.

ndarrays 和对象创建

子类化 ndarray 由于 ndarray 类的新实例可以通过三种不同的方式出现而变得复杂.这些方式是:

1. 显式构造函数调用 - 如 MySubClass(params).这是Python实例创建的常用方法.

2. 视图转换 - 将现有的 ndarray 转换为给定的子类

3. 从模板新建 - 从模板实例创建新实例.示例包括从子类化数组返回切片,从ufuncs创建返回类型,以及复制数组.更多详情请参见 从模板创建新文件

最后两个是 ndarray 的特性 - 为了支持诸如数组切片之类的事情.子类化 ndarray 的复杂性是由于 numpy 为了支持这两种实例创建路径而采用的机制.

何时使用子类化

除了子类化 NumPy 数组的额外复杂性之外,子类可能会遇到意外行为,因为某些函数可能会将子类转换为基类并”忘记”与子类相关的任何附加信息.如果你使用 NumPy 方法或未明确测试的函数,这可能会导致令人惊讶的行为.

另一方面,与其他互操作性方法相比,子类化可能是有用的,因为许多事情会”自动工作”.

这意味着子类化可以是一种方便的方法,而且长期以来它也经常是唯一可用的方法.然而,NumPy现在提供了额外的互操作性协议,描述在”与NumPy的互操作性”.对于许多用例,这些互操作性协议现在可能是更好的选择或补充子类化的使用.

如果以下情况,子类化可能是一个好的选择:

• 你不太担心可维护性或除你自己以外的用户:子类将更快实现,并且可以在需要时添加额外的互操作性.而且由于用户很少,可能的意外不成问题.

• 如果你不认为忽略或静默丢失子类信息是有问题的.一个例子是 np.memmap,其中”忘记”数据被内存映射不会导致错误结果.一个有时会让用户感到困惑的子类例子是 NumPy 的掩码数组.当它们被引入时,子类化是唯一的实现方法.然而,今天我们可能会尝试避免子类化,只依赖于互操作性协议.

请注意,子类作者也可能希望研究 与 NumPy 的互操作性 以支持更复杂的用例或解决令人惊讶的行为.

astropy.units.Quantity 和 xarray 是与 NumPy 良好互操作的类数组对象的例子.Astropy 的 Quantity 是一个同时使用子类化和互操作协议双重方法的例子.

视图转换

视图转换 是将任何子类的ndarray转换为另一个（指定）子类视图的标准ndarray机制:

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)
<class '__main__.C'>

从模板创建新文件

ndarray 子类的新实例也可以通过与 视图转换 非常相似的机制产生,当 numpy 需要从模板实例创建新实例时.最明显的地方是当你对子类数组进行切片时.例如:

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'
<class '__main__.C'>
>>> v is c_arr # but it's a new instance
False

切片是原始 c_arr 数据的*视图*.因此,当我们从 ndarray 中获取视图时,我们返回一个指向原始数据的新 ndarray,具有相同的类.

在 ndarrays 的使用中还有其他需要这种视图的地方,例如复制数组 (c_arr.copy()),创建 ufunc 输出数组（另见 __array_wrap__ 用于 ufuncs 和其他函数）,以及减少方法（如 c_arr.mean()）.

视图转换和新模板的关系

这些路径都使用相同的机制.我们在这里做出区分,因为它们会导致对你的方法的不同输入.具体来说,:ref:view-casting 意味着你已经从 ndarray 的任何潜在子类创建了你的数组类型的新实例.:ref:new-from-template 意味着你已经从一个预先存在的实例创建了你的类的新实例,允许你——例如——复制特定于你的子类的属性.

子类化的影响

如果我们子类化 ndarray,我们不仅需要处理我们数组类型的显式构造,还需要处理 视图转换 或 模板新构建 .NumPy 有实现这一点的机制,正是这种机制使得子类化稍微有些不标准.

在子类中支持视图和新模板创建的机制有两个方面.

第一个是使用 ndarray.__new__ 方法进行对象初始化的主要工作,而不是更常用的 __init__ 方法.第二个是使用 __array_finalize__ 方法允许子类在从模板创建视图和新实例后进行清理.

关于 __new__ 和 __init__ 的简要 Python 入门

__new__ 是一个标准的 Python 方法,如果在创建类实例时存在,它会在 __init__ 之前被调用.更多详情请参见 python __new__ 文档.

例如,考虑以下 Python 代码:

>>> class C:
...     def __new__(cls, *args):
...         print('Cls in __new__:', cls)
...         print('Args in __new__:', args)
...         # The `object` type __new__ method takes a single argument.
...         return object.__new__(cls)
...     def __init__(self, *args):
...         print('type(self) in __init__:', type(self))
...         print('Args in __init__:', args)

这意味着我们得到:

>>> c = C('hello')
Cls in __new__: <class '__main__.C'>
Args in __new__: ('hello',)
type(self) in __init__: <class '__main__.C'>
Args in __init__: ('hello',)

当我们调用 C('hello') 时,``__new__`` 方法会将其自己的类作为第一个参数,并将传递的参数（即字符串 'hello'）作为第二个参数.在 Python 调用 __new__ 之后,它通常（见下文）会调用我们的 __init__ 方法,将 __new__ 的输出作为第一个参数（现在是一个类实例）,并跟随传递的参数.

如你所见,对象可以在 __new__ 方法或 __init__ 方法中初始化,或者两者都用,实际上 ndarray 没有 __init__ 方法,因为所有的初始化都在 __new__ 方法中完成.

为什么使用 __new__ 而不是通常的 __init__?因为在某些情况下,比如对于 ndarray,我们希望能够返回某个其他类的对象.考虑以下情况:

class D(C):
    def __new__(cls, *args):
        print('D cls is:', cls)
        print('D args in __new__:', args)
        return C.__new__(C, *args)

    def __init__(self, *args):
        # we never get here
        print('In D __init__')

意思是:

>>> obj = D('hello')
D cls is: <class 'D'>
D args in __new__: ('hello',)
Cls in __new__: <class 'C'>
Args in __new__: ('hello',)
>>> type(obj)
<class 'C'>

C 的定义与之前相同,但对于 D,``__new__`` 方法返回的是 C 类的实例而不是 D 类的实例.注意,``D`` 的 __init__ 方法不会被调用.通常,当 __new__ 方法返回的类对象不是定义它的类时,该类的 __init__ 方法不会被调用.

这是 ndarray 类的子类如何能够返回保留类类型的视图的方式.当获取视图时,标准的 ndarray 机制使用类似以下的方式创建新的 ndarray 对象:

obj = ndarray.__new__(subtype, shape, ...

其中 subdtype 是子类.因此,返回的视图与子类是同一类,而不是 ndarray 类.

这解决了返回相同类型视图的问题,但现在我们有了一个新的问题.ndarray 的机制可以在其获取视图的标准方法中这样设置类,但 ndarray 的 __new__ 方法对我们自己在 __new__ 方法中所做的设置属性等操作一无所知.（顺便说一句 - 为什么不调用 obj = subdtype.__new__(... 呢?因为我们可能没有一个具有相同调用签名的 __new__ 方法）.

__array_finalize__ 的角色

__array_finalize__ 是 numpy 提供的一种机制,允许子类处理创建新实例的各种方式.

记住,子类实例可以通过以下三种方式产生:

1. 显式构造函数调用 (obj = MySubClass(params)).这将调用通常的 MySubClass.__new__ 序列,然后（如果存在）调用 MySubClass.__init__.

2. 视图转换

3. 从模板新建

我们的 MySubClass.__new__ 方法只有在显式构造函数调用的情况下才会被调用,因此我们不能依赖 MySubClass.__new__ 或 MySubClass.__init__ 来处理视图转换和新模板创建.事实证明,``MySubClass.__array_finalize__`` 确实 会在所有三种对象创建方法中被调用,所以这是我们通常进行对象创建管理的地方.

• 对于显式构造函数调用,我们的子类需要创建一个属于其自身类的新 ndarray 实例.实际上,这意味着我们,代码的作者,需要调用 ndarray.__new__(MySubClass,...),一个准备好的类层次结构调用 super().__new__(cls, ...),或者对现有数组进行视图转换（见下文）

• 对于视图转换和新模板创建,在 C 层级上调用等效于 ndarray.__new__(MySubClass,... 的方法.

__array_finalize__ 接收的参数在上述三种实例创建方法中有所不同.

以下代码允许我们查看调用序列和参数:

import numpy as np

class C(np.ndarray):
    def __new__(cls, *args, **kwargs):
        print('In __new__ with class %s' % cls)
        return super().__new__(cls, *args, **kwargs)

    def __init__(self, *args, **kwargs):
        # in practice you probably will not need or want an __init__
        # method for your subclass
        print('In __init__ with class %s' % self.__class__)

    def __array_finalize__(self, obj):
        print('In array_finalize:')
        print('   self type is %s' % type(self))
        print('   obj type is %s' % type(obj))

Now:

>>> # Explicit constructor
>>> c = C((10,))
In __new__ with class <class 'C'>
In array_finalize:
   self type is <class 'C'>
   obj type is <type 'NoneType'>
In __init__ with class <class 'C'>
>>> # View casting
>>> a = np.arange(10)
>>> cast_a = a.view(C)
In array_finalize:
   self type is <class 'C'>
   obj type is <type 'numpy.ndarray'>
>>> # Slicing (example of new-from-template)
>>> cv = c[:1]
In array_finalize:
   self type is <class 'C'>
   obj type is <class 'C'>

__array_finalize__ 的签名是:

def __array_finalize__(self, obj):

可以看到,``super`` 调用,即调用 ndarray.__new__,将 __array_finalize__ 传递给我们自己类的新对象（self）以及从中获取视图的对象（obj）.如上所述,``self`` 始终是我们子类的新创建实例,而 obj 的类型对于三种实例创建方法有所不同:

• 当从显式构造函数调用时,``obj`` 是 None

• 当从视图转换调用时,``obj`` 可以是 ndarray 的任何子类的实例,包括我们自己的.

• 当在新模板中调用时,``obj`` 是我们的子类的另一个实例,我们可能使用它来更新新的 self 实例.

因为 __array_finalize__ 是唯一一个总能看到新实例被创建的方法,所以它是为新对象属性填充实例默认值以及其他任务的合理位置.

这可能通过一个例子更清楚.

简单示例 - 向 ndarray 添加额外属性

import numpy as np

class InfoArray(np.ndarray):

    def __new__(subtype, shape, dtype=float, buffer=None, offset=0,
                strides=None, order=None, info=None):
        # Create the ndarray instance of our type, given the usual
        # ndarray input arguments.  This will call the standard
        # ndarray constructor, but return an object of our type.
        # It also triggers a call to InfoArray.__array_finalize__
        obj = super().__new__(subtype, shape, dtype,
                              buffer, offset, strides, order)
        # set the new 'info' attribute to the value passed
        obj.info = info
        # Finally, we must return the newly created object:
        return obj

    def __array_finalize__(self, obj):
        # ``self`` is a new object resulting from
        # ndarray.__new__(InfoArray, ...), therefore it only has
        # attributes that the ndarray.__new__ constructor gave it -
        # i.e. those of a standard ndarray.
        #
        # We could have got to the ndarray.__new__ call in 3 ways:
        # From an explicit constructor - e.g. InfoArray():
        #    obj is None
        #    (we're in the middle of the InfoArray.__new__
        #    constructor, and self.info will be set when we return to
        #    InfoArray.__new__)
        if obj is None: return
        # From view casting - e.g arr.view(InfoArray):
        #    obj is arr
        #    (type(obj) can be InfoArray)
        # From new-from-template - e.g infoarr[:3]
        #    type(obj) is InfoArray
        #
        # Note that it is here, rather than in the __new__ method,
        # that we set the default value for 'info', because this
        # method sees all creation of default objects - with the
        # InfoArray.__new__ constructor, but also with
        # arr.view(InfoArray).
        self.info = getattr(obj, 'info', None)
        # We do not need to return anything

使用对象看起来像这样:

>>> obj = InfoArray(shape=(3,)) # explicit constructor
>>> type(obj)
<class 'InfoArray'>
>>> obj.info is None
True
>>> obj = InfoArray(shape=(3,), info='information')
>>> obj.info
'information'
>>> v = obj[1:] # new-from-template - here - slicing
>>> type(v)
<class 'InfoArray'>
>>> v.info
'information'
>>> arr = np.arange(10)
>>> cast_arr = arr.view(InfoArray) # view casting
>>> type(cast_arr)
<class 'InfoArray'>
>>> cast_arr.info is None
True

这个类不是很有用,因为它具有与裸 ndarray 对象相同的构造函数,包括传入缓冲区和形状等.我们可能更希望构造函数能够接受通常从 np.array 调用中已经形成的 ndarray 并返回一个对象.

稍微更现实的例子 - 添加到现有数组的属性

这是一个接受已经存在的标准 ndarray,将其转换为我们的类型,并添加一个额外属性的类.

import numpy as np

class RealisticInfoArray(np.ndarray):

    def __new__(cls, input_array, info=None):
        # Input array is an already formed ndarray instance
        # We first cast to be our class type
        obj = np.asarray(input_array).view(cls)
        # add the new attribute to the created instance
        obj.info = info
        # Finally, we must return the newly created object:
        return obj

    def __array_finalize__(self, obj):
        # see InfoArray.__array_finalize__ for comments
        if obj is None: return
        self.info = getattr(obj, 'info', None)

So:

>>> arr = np.arange(5)
>>> obj = RealisticInfoArray(arr, info='information')
>>> type(obj)
<class 'RealisticInfoArray'>
>>> obj.info
'information'
>>> v = obj[1:]
>>> type(v)
<class 'RealisticInfoArray'>
>>> v.info
'information'

__array_ufunc__ 用于 ufuncs

在 1.13 版本加入.

子类可以通过重写默认的 ndarray.__array_ufunc__ 方法来覆盖在它上面执行 numpy ufuncs 时的行为.该方法会在执行 ufunc 时被调用,并且应该返回操作的结果,或者如果请求的操作未实现则返回 NotImplemented.

__array_ufunc__ 的签名是:

def __array_ufunc__(ufunc, method, *inputs, **kwargs):

• ufunc 是被调用的 ufunc 对象.

• method 是一个字符串,指示 Ufunc 是如何被调用的,可以是 "__call__" 表示它被直接调用,或者是它的 方法 之一:"reduce"、"accumulate"、"reduceat"、"outer" 或 "at".

• inputs 是 ufunc 输入参数的元组

• kwargs 包含传递给函数的任何可选或关键字参数.这包括任何 out 参数,它们总是包含在一个元组中.

一个典型的实现会转换任何属于自己类的输入或输出实例,使用 super() 将所有内容传递给超类,最后在可能的反向转换后返回结果.例如,取自 _core/tests/test_umath.py 中的测试用例 test_ufunc_override_with_super,如下所示.

input numpy as np

class A(np.ndarray):
    def __array_ufunc__(self, ufunc, method, *inputs, out=None, **kwargs):
        args = []
        in_no = []
        for i, input_ in enumerate(inputs):
            if isinstance(input_, A):
                in_no.append(i)
                args.append(input_.view(np.ndarray))
            else:
                args.append(input_)

        outputs = out
        out_no = []
        if outputs:
            out_args = []
            for j, output in enumerate(outputs):
                if isinstance(output, A):
                    out_no.append(j)
                    out_args.append(output.view(np.ndarray))
                else:
                    out_args.append(output)
            kwargs['out'] = tuple(out_args)
        else:
            outputs = (None,) * ufunc.nout

        info = {}
        if in_no:
            info['inputs'] = in_no
        if out_no:
            info['outputs'] = out_no

        results = super().__array_ufunc__(ufunc, method, *args, **kwargs)
        if results is NotImplemented:
            return NotImplemented

        if method == 'at':
            if isinstance(inputs[0], A):
                inputs[0].info = info
            return

        if ufunc.nout == 1:
            results = (results,)

        results = tuple((np.asarray(result).view(A)
                         if output is None else output)
                        for result, output in zip(results, outputs))
        if results and isinstance(results[0], A):
            results[0].info = info

        return results[0] if len(results) == 1 else results

所以,这个类实际上并没有做任何有趣的事情:它只是将其自身的任何实例转换为常规的 ndarray（否则,我们会陷入无限递归!）,并添加了一个 info 字典,用于说明它转换了哪些输入和输出.因此,例如,

>>> a = np.arange(5.).view(A)
>>> b = np.sin(a)
>>> b.info
{'inputs': [0]}
>>> b = np.sin(np.arange(5.), out=(a,))
>>> b.info
{'outputs': [0]}
>>> a = np.arange(5.).view(A)
>>> b = np.ones(1).view(A)
>>> c = a + b
>>> c.info
{'inputs': [0, 1]}
>>> a += b
>>> a.info
{'inputs': [0, 1], 'outputs': [0]}

请注意,另一种方法是使用 getattr(ufunc, methods)(*inputs, **kwargs) 而不是 super 调用.对于这个例子,结果将是相同的,但如果另一个操作数也定义了 __array_ufunc__,则会有所不同.例如,假设我们评估 np.add(a, b),其中 b 是另一个类 B 的实例,该类有重写.如果你像示例中那样使用 super,``ndarray.__array_ufunc__`` 会注意到 b 有重写,这意味着它不能自己评估结果.因此,它会返回 NotImplemented,我们的类 A 也会返回.然后,控制权将传递给 b,它要么知道如何处理我们并产生结果,要么不知道并返回 NotImplemented,引发 TypeError.

如果我们用 getattr(ufunc, method) 替换 super 调用,我们实际上是在执行 np.add(a.view(np.ndarray), b).同样, B.__array_ufunc__ 将被调用,但现在它看到的是一个 ndarray 作为另一个参数.可能,它会知道如何处理这个,并返回一个新的 B 类实例给我们.我们的示例类没有设置来处理这个,但如果例如有人使用 __array_ufunc__ 重新实现 MaskedArray,这可能是一个很好的方法.

最后一点:如果 super 路由适用于某个类,使用它的一个优点是它有助于构建类层次结构.例如,假设我们的另一个类 B 也在其 __array_ufunc__ 实现中使用了 super ,并且我们创建了一个依赖于两者的类 C ,即 class C(A, B) （为简单起见,没有另一个 __array_ufunc__ 重写）.那么 C 实例上的任何 ufunc 都会传递给 A.__array_ufunc__ , A 中的 super 调用会转到 B.__array_ufunc__ ,而 B 中的 super 调用会转到 ndarray.__array_ufunc__ ,从而允许 A 和 B 协作.

__array_wrap__ 用于 ufuncs 和其他函数

在 numpy 1.13 之前,ufunc 的行为只能通过 __array_wrap__ 和 __array_prepare__ （后者现在已被移除）进行调整.这两个方法允许改变 ufunc 的输出类型,但与 __array_ufunc__ 不同,不允许对输入进行任何更改.希望最终弃用这些方法,但 __array_wrap__ 也被其他 numpy 函数和方法使用,例如 squeeze,因此目前仍需要它以实现完整功能.

从概念上讲,``__array_wrap__`` “包装了操作”,意思是允许子类设置返回值的类型并更新属性和元数据.让我们通过一个例子来说明这是如何工作的.首先我们回到更简单的子类示例,但使用不同的名称和一些打印语句:

import numpy as np

class MySubClass(np.ndarray):

    def __new__(cls, input_array, info=None):
        obj = np.asarray(input_array).view(cls)
        obj.info = info
        return obj

    def __array_finalize__(self, obj):
        print('In __array_finalize__:')
        print('   self is %s' % repr(self))
        print('   obj is %s' % repr(obj))
        if obj is None: return
        self.info = getattr(obj, 'info', None)

    def __array_wrap__(self, out_arr, context=None, return_scalar=False):
        print('In __array_wrap__:')
        print('   self is %s' % repr(self))
        print('   arr is %s' % repr(out_arr))
        # then just call the parent
        return super().__array_wrap__(self, out_arr, context, return_scalar)

我们在我们新数组的实例上运行一个 ufunc:

>>> obj = MySubClass(np.arange(5), info='spam')
In __array_finalize__:
   self is MySubClass([0, 1, 2, 3, 4])
   obj is array([0, 1, 2, 3, 4])
>>> arr2 = np.arange(5)+1
>>> ret = np.add(arr2, obj)
In __array_wrap__:
   self is MySubClass([0, 1, 2, 3, 4])
   arr is array([1, 3, 5, 7, 9])
In __array_finalize__:
   self is MySubClass([1, 3, 5, 7, 9])
   obj is MySubClass([0, 1, 2, 3, 4])
>>> ret
MySubClass([1, 3, 5, 7, 9])
>>> ret.info
'spam'

注意,ufunc (np.add) 调用了 __array_wrap__ 方法,参数 self 为 obj,``out_arr`` 为加法的（ndarray）结果.接着,默认的 __array_wrap__``（``ndarray.__array_wrap__）将结果转换为 MySubClass 类,并调用了 __array_finalize__ - 因此复制了 info 属性.这一切都发生在 C 层级.

但是,我们可以做任何我们想做的事情:

class SillySubClass(np.ndarray):

    def __array_wrap__(self, arr, context=None, return_scalar=False):
        return 'I lost your data'

>>> arr1 = np.arange(5)
>>> obj = arr1.view(SillySubClass)
>>> arr2 = np.arange(5)
>>> ret = np.multiply(obj, arr2)
>>> ret
'I lost your data'

因此,通过为我们的子类定义一个特定的 __array_wrap__ 方法,我们可以调整来自 ufuncs 的输出.``__array_wrap__`` 方法需要 self,然后是一个参数 - 这是 ufunc 或其他 NumPy 函数的结果 - 和一个可选参数 context.这个参数由 ufuncs 作为 3-元素元组传递:（ufunc 的名称,ufunc 的参数,ufunc 的域）,但不会被其他 numpy 函数传递.尽管如上所述,可以有其他方式,``__array_wrap__`` 应该返回其包含类的实例.请参见掩码数组子类的实现.``__array_wrap__`` 总是传递一个 NumPy 数组,该数组可能是也可能不是子类（通常是调用者的子类）.

额外注意事项 - 自定义 __del__ 方法和 ndarray.base

ndarray 解决的问题之一是跟踪 ndarray 及其视图的内存所有权.考虑我们创建了一个 ndarray arr 并用 v = arr[1:] 进行了切片的情况.这两个对象查看的是同一块内存.NumPy 通过 base 属性跟踪特定数组或视图的数据来源:

>>> # A normal ndarray, that owns its own data
>>> arr = np.zeros((4,))
>>> # In this case, base is None
>>> arr.base is None
True
>>> # We take a view
>>> v1 = arr[1:]
>>> # base now points to the array that it derived from
>>> v1.base is arr
True
>>> # Take a view of a view
>>> v2 = v1[1:]
>>> # base points to the original array that it was derived from
>>> v2.base is arr
True

一般来说,如果数组拥有自己的内存,就像在这种情况下 arr 一样,那么 arr.base 将是 None - 这有一些例外 - 更多细节请参见 numpy 书籍.

base 属性在能够判断我们是否有一个视图或原始数组方面非常有用.这反过来在我们需要知道是否在子类化数组被删除时进行一些特定的清理时非常有用.例如,我们可能只想在原始数组被删除时进行清理,而不是视图.有关这如何工作的示例,请查看 numpy._core 中的 memmap 类.

子类化和下游兼容性

当子类化 ndarray 或创建模仿 ndarray 接口的鸭子类型时,决定你的 API 与 numpy 的 API 的匹配程度是你的责任.为了方便起见,许多有相应 ndarray 方法的 numpy 函数（例如,``sum``、mean、take、reshape）通过检查函数的首个参数是否有一个同名方法来工作.如果存在,则调用该方法,而不是将参数强制转换为 numpy 数组.

例如,如果你想让你的子类或鸭子类型与 numpy 的 sum 函数兼容,这个对象的 sum 方法的签名应该是以下内容:

def sum(self, axis=None, dtype=None, out=None, keepdims=False):
...

这是 np.sum 的确切相同的方法签名,所以现在如果用户在这个对象上调用 np.sum ,numpy 将调用对象自己的 sum 方法并传入上述签名中列举的这些参数,并且不会引发错误,因为签名是完全相互兼容的.

然而,如果你决定偏离这个签名并这样做:

def sum(self, axis=None, dtype=None):
...

这个对象不再兼容 np.sum ,因为如果你调用 np.sum ,它会传入意外的参数 out 和 keepdims ,导致引发 TypeError .

如果你希望保持与numpy及其后续版本的兼容性（可能会添加新的关键字参数）,但不希望公开所有numpy的参数,你的函数的签名应接受 **kwargs.例如:

def sum(self, axis=None, dtype=None, **unused_kwargs):
...

这个对象现在再次兼容 np.sum ,因为任何多余的参数（即不是 axis 或 dtype 的关键字）将被隐藏在 **unused_kwargs 参数中.