子类化 ndarray

简介

子类化 ndarray 相对简单，但与其它 Python 对象相比，它有一些复杂之处。本页将解释允许您子类化 ndarray 的机制，以及实现子类的含义。

ndarrays 和对象创建

子类化 ndarray 之所以复杂，是因为 ndarray 类的新实例可以通过三种不同方式产生。它们是：

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

2. 视图转换 (View casting) - 将现有 ndarray 转换为给定子类

3. 从模板新建 (New from template) - 从模板实例创建新实例。示例包括从子类化数组返回切片、从 ufuncs 创建返回类型以及复制数组。有关更多详细信息，请参阅从模板新建。

后两者是 ndarray 的特性——为了支持数组切片等操作。子类化 ndarray 的复杂性源于 NumPy 支持这两种实例创建途径的机制。

何时使用子类化

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

另一方面，与其它互操作方法相比，子类化可能很有用，因为许多功能会“直接可用”。

这意味着子类化可能是一种便捷的方法，并且在很长一段时间内，它通常也是唯一可用的方法。然而，NumPy 现在提供了“与 NumPy 的互操作性”中描述的额外互操作协议。对于许多用例，这些互操作协议现在可能更适合或补充子类化的使用。

如果满足以下条件，子类化可能是一个不错的选择：

• 您不太担心可维护性或除了您自己之外的用户：子类实现起来更快，并且可以“按需”添加额外的互操作性。并且用户较少时，可能的意外也不是问题。

• 您不认为子类信息被静默忽略或丢失有问题。一个例子是 np.memmap，其中“忘记”数据是内存映射的不会导致错误结果。有时会混淆用户的子类示例是 NumPy 的 masked arrays。当它们首次引入时，子类化是唯一的实现方法。然而，今天我们可能会尝试避免子类化，而只依赖互操作协议。

请注意，子类作者也可能希望研究与 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'>

从模板新建

当 NumPy 需要从模板实例创建新实例时，ndarray 子类的新实例也可以通过与视图转换非常相似的机制产生。最明显发生这种情况的地方是当您对子类化数组进行切片时。例如

>>> 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，它指向原始数据。

在使用 ndarray 的其它地方，我们也需要此类视图，例如复制数组 (c_arr.copy())、创建 ufunc 输出数组（另请参阅 __array_wrap__ 用于 ufuncs 和其他函数）以及归约方法（如 c_arr.mean()）。

视图转换与从模板新建的关系

这些路径都使用相同的机制。我们在此进行区分，因为它们会导致您方法接收到不同的输入。视图转换特指您从 ndarray 的任何潜在子类创建了数组类型的新实例。从模板新建则表示您从现有实例创建了类的新实例，这允许您（例如）复制子类特有的属性。

子类化的影响

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

ndarray 用于在子类中支持视图和从模板新建的机制有两个方面。

第一个方面是使用 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, ...

其中 subtype 是子类。因此，返回的视图与子类属于同一类，而不是 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, ...) 的调用，或者对现有数组进行视图转换（见下文）。

• 对于视图转换和从模板新建，等同于 ndarray.__new__(MySubClass,... 的调用是在 C 级别进行的。

__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))

现在

>>> # 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 对象有相同的构造函数，包括传递缓冲区和形状等。我们可能更希望构造函数能够从通常的 NumPy 调用 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)

所以

>>> 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'

ufuncs 的 __array_ufunc__

子类可以通过重写默认的 ndarray.__array_ufunc__ 方法来覆盖在其上执行 NumPy ufunc 时的行为。该方法会替代 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 协同工作。

ufuncs 和其他函数的 __array_wrap__

在 NumPy 1.13 之前，ufuncs 的行为只能通过 __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__ 方法，我们可以调整 ufunc 的输出。__array_wrap__ 方法需要 self，然后是一个参数（即 ufunc 或其他 NumPy 函数的结果），以及一个可选参数 context。此参数由 ufunc 作为 3 元素元组传递：（ufunc 的名称、ufunc 的参数、ufunc 的域），但其他 NumPy 函数不会传递此参数。尽管如上所示，可以有其他做法，但 __array_wrap__ 应该返回其包含类的实例。有关实现，请参阅 masked array 子类。__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 参数中。