数组API

一个一流的智力测试是两个人的能力

在思想上反对思想的同时，仍保留着

工作能力。

--- F.斯科特·菲茨杰拉德

对于一项成功的技术，现实必须优先于公众。

关系，因为自然不能被愚弄。

--- 理查德·费曼

数组结构和数据访问

这些宏访问 PyArrayObject 结构成员和 ndarraytypes.h . 输入参数， arr ，可以是任何 PyObject* 直接解释为 PyArrayObject* （任何 PyArray_Type 及其子类型）。

int PyArray_NDIM(PyArrayObject *arr)

数组中的维度数。

int PyArray_FLAGS(PyArrayObject *arr)

返回一个表示 array-flags .

int PyArray_TYPE(PyArrayObject *arr)

返回此数组元素的（内置）类型号。

int PyArray_SETITEM(PyArrayObject *arr, void *itemptr, PyObject *obj)

转换obj并将其放入ndarray中， arr ，在itemptr指向的位置。如果发生错误，返回-1；如果成功，返回0。

void PyArray_ENABLEFLAGS(PyArrayObject *arr, int flags)

1.7 新版功能.

启用指定的数组标志。此函数不进行验证，并假定您知道自己在做什么。

void PyArray_CLEARFLAGS(PyArrayObject *arr, int flags)

1.7 新版功能.

清除指定的数组标志。此函数不进行验证，并假定您知道自己在做什么。

void *PyArray_DATA(PyArrayObject *arr)

char *PyArray_BYTES(PyArrayObject *arr)

这两个宏类似，并获得指向数组数据缓冲区的指针。第一个宏可以（并且应该）分配给一个特定的指针，而第二个宏用于常规处理。如果您没有保证一个连续的和/或对齐的数组，那么请确保您了解如何访问数组中的数据，以避免内存和/或对齐问题。

npy_intp *PyArray_DIMS(PyArrayObject *arr)

返回指向数组的维度/形状的指针。元素的数量与数组的维数匹配。可以返回 NULL 对于0维数组。

npy_intp *PyArray_SHAPE(PyArrayObject *arr)

1.7 新版功能.

同义词 PyArray_DIMS ，命名为与 shape Python中的用法。

npy_intp *PyArray_STRIDES(PyArrayObject *arr)

返回指向数组步幅的指针。元素数与数组的维数匹配。

npy_intp PyArray_DIM(PyArrayObject *arr, int n)

将形状返回到 n 尺寸。

npy_intp PyArray_STRIDE(PyArrayObject *arr, int n)

返回步伐 n 尺寸。

npy_intp PyArray_ITEMSIZE(PyArrayObject *arr)

返回此数组元素的项大小。

请注意，在1.7版中不推荐使用的旧API中，此函数具有返回类型 int .

npy_intp PyArray_SIZE(PyArrayObject *arr)

返回数组的总大小（元素数）。

npy_intp PyArray_Size(PyArrayObject *obj)

返回0如果 obj 不是ndarray的子类。否则，返回数组中元素的总数。更安全的版本 PyArray_SIZE （ obj ）

npy_intp PyArray_NBYTES(PyArrayObject *arr)

返回数组使用的字节总数。

PyObject *PyArray_BASE(PyArrayObject *arr)

这将返回数组的基对象。在大多数情况下，这意味着拥有数组所指向的内存的对象。

如果使用C API构造数组并指定自己的内存，则应使用函数 PyArray_SetBaseObject 将基设置为拥有内存的对象。

如果（已弃用） NPY_ARRAY_UPDATEIFCOPY 或 NPY_ARRAY_WRITEBACKIFCOPY 设置标志时，它具有不同的含义，即base是当前数组在复制分辨率后将复制到其中的数组。在未来的numpy版本中，两个函数的基属性重载可能会发生变化。

PyArray_Descr *PyArray_DESCR(PyArrayObject *arr)

返回对数组的dtype属性的借用引用。

PyArray_Descr *PyArray_DTYPE(PyArrayObject *arr)

1.7 新版功能.

pyarray_descr的同义词，命名为与python中的“dtype”用法一致。

PyObject *PyArray_GETITEM(PyArrayObject *arr, void *itemptr)

从ndarray中获取内置类型的python对象， arr ，位于itemptr指向的位置。返回 NULL 失败论。

numpy.ndarray.item 与pyarray_getitem相同。

数据访问

这些函数和宏提供了从C轻松访问ndarray元素的功能。这些功能适用于所有数组。但是，在访问数组中的数据时可能需要小心，如果数据不符合机器字节顺序、不对齐或不可写。换句话说，除非您知道自己在做什么，或者之前已经保证了一个数组是可写的、对齐的，并且使用 PyArray_FromAny . 如果您希望处理所有类型的数组，那么每种类型的copySwap函数对于处理行为错误的数组都很有用。有些平台（例如Solaris）不喜欢未对齐的数据，如果取消引用未对齐的指针，则会崩溃。其他平台（如x86 Linux）在处理未对齐的数据时只会工作得更慢。

void *PyArray_GetPtr(PyArrayObject *aobj, npy_intp *ind)

返回指向ndarray数据的指针， aobj ，在c数组给出的n维索引处， ind ，（必须至少是 aobj -Nd大小。您可能需要将返回的指针类型转换为ndarray的数据类型。

void *PyArray_GETPTR1(PyArrayObject *obj, npy_intp i)

void *PyArray_GETPTR2(PyArrayObject *obj, npy_intp i, npy_intp j)

void *PyArray_GETPTR3(PyArrayObject *obj, npy_intp i, npy_intp j, npy_intp k)

void *PyArray_GETPTR4(PyArrayObject *obj, npy_intp i, npy_intp j, npy_intp k, npy_intp l)

在ndarray中的给定坐标处快速、内联地访问元素， obj ，必须分别具有1、2、3或4个尺寸（未选中）。相应的 i ， j ， k 和 l 坐标可以是任意整数，但将解释为 npy_intp . 您可能需要将返回的指针类型转换为ndarray的数据类型。

创建数组

从头开始

PyObject *PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, npy_intp const *dims, npy_intp const *strides, void *data, int flags, PyObject *obj)

此函数窃取对 德克思 . 最简单的方法是使用 PyArray_DescrFromType .

这是主要的数组创建函数。大多数新数组都是用这个灵活的函数创建的。

返回的对象是python类型的对象 亚型 ，必须是的子类型 PyArray_Type . 数组有 nd 尺寸，描述人 dims . 新数组的数据类型描述符是 德克思 .

如果 亚型 是数组子类而不是基 &PyArray_Type 然后 obj 是要传递给的对象 __array_finalize__ 子类的方法。

如果 data 是 NULL 然后分配新的单元化内存 旗帜 可以是非零的，以指示Fortran样式的连续数组。使用 PyArray_FILLWBYTE 初始化内存。

如果 data 不是 NULL ，然后假定指向要用于数组和 旗帜 参数用作数组的新标志（状态除外 NPY_ARRAY_OWNDATA ， NPY_ARRAY_WRITEBACKIFCOPY 和 NPY_ARRAY_UPDATEIFCOPY 新数组的标志将被重置）。

此外，如果 data 非空，则 大步 也可以提供。如果 大步 是 NULL ，然后将数组步幅计算为C样式连续（默认）或Fortran样式连续（ 旗帜 是非零的 data = NULL 或 旗帜 & NPY_ARRAY_F_CONTIGUOUS 非零非空 data ）任何提供 dims 和 大步 为新的数组对象复制到新分配的维度和跨步数组中。

PyArray_CheckStrides 可以帮助验证非- NULL 步幅信息。

如果 data 如果提供，则它必须在阵列的生命周期内保持活动。一种方法是通过 PyArray_SetBaseObject

PyObject *PyArray_NewLikeArray(PyArrayObject *prototype, NPY_ORDER order, PyArray_Descr *descr, int subok)

1.6 新版功能.

此函数窃取对 德克思 如果不为空。此数组创建例程允许方便地创建与现有数组的形状和内存布局匹配的新数组，可能会更改布局和/或数据类型。

什么时候？ 秩序 是 NPY_ANYORDER ，结果顺序为 NPY_FORTRANORDER 如果 原型 是Fortran数组， NPY_CORDER 否则。什么时候？ 秩序 是 NPY_KEEPORDER ，结果顺序与 原型 ，即使当 原型 不是C或Fortran顺序。

如果 德克思 为空，数据类型为 原型 使用。

如果 苏博克 为1，新创建的数组将使用 原型 要创建新数组，否则它将创建一个基类数组。

PyObject *PyArray_New(PyTypeObject *subtype, int nd, npy_intp const *dims, int type_num, npy_intp const *strides, void *data, int itemsize, int flags, PyObject *obj)

这和 PyArray_NewFromDescr （…）除非使用 type_num 和 项目尺寸 在哪里 type_num 对应于内置（或用户定义）类型。如果类型始终具有相同的字节数，则忽略itemsize。否则，itemsize指定此数组的特定大小。

警告

如果数据传递到 PyArray_NewFromDescr 或 PyArray_New ，在删除新数组之前，不能释放此内存。如果此数据来自另一个Python对象，则可以使用 Py_INCREF 并设置新数组的基成员指向该对象。如果传入跨步，则它们必须与数组的维度、项大小和数据一致。

PyObject *PyArray_SimpleNew(int nd, npy_intp const *dims, int typenum)

创建新的类型为的未初始化数组， 铅字 ，其大小分别为 nd 维数由整数数组给出， dims 。数组的内存未初始化（除非typenum NPY_OBJECT 在这种情况下，数组中的每个元素都设置为空）。这个 铅字 参数允许指定任何内置数据类型，例如 NPY_FLOAT 或 NPY_LONG . 如果需要，可以使用 PyArray_FILLWBYTE （返回u对象，0）。此函数不能用于创建灵活类型数组（未给定itemsize）。

PyObject *PyArray_SimpleNewFromData(int nd, npy_intp const *dims, int typenum, void *data)

在周围创建数组包装 data 由给定指针指向的。数组标志将有一个默认值，即数据区域行为良好，C样式是连续的。数组的形状由 dims C-长度数组 nd . 数组的数据类型由 铅字 . 如果数据来自另一个引用计数的Python对象，则在传入指针后，应该增加此对象上的引用计数，并且返回的ndarray的基成员应该指向拥有数据的Python对象。这将确保在返回的数组存在时提供的内存不会被释放。要在释放ndarray后立即释放内存，请在返回的ndarray上设置OWNDATA标志。

PyObject *PyArray_SimpleNewFromDescr(int nd, npy_int const *dims, PyArray_Descr *descr)

此函数窃取对 德克思 .

使用提供的数据类型描述符创建新数组， 德克思 ，形状由 nd 和 dims .

void PyArray_FILLWBYTE(PyObject *obj, int val)

填充指向的数组 obj ---必须是一个（子类）ndarray---包含 val （以字节计算）。此宏调用memset，因此obj必须是连续的。

PyObject *PyArray_Zeros(int nd, npy_intp const *dims, PyArray_Descr *dtype, int fortran)

构建新的 nd -由给定形状的维数数组 dims 和数据类型 D型 .如果 福特朗 为非零，则创建Fortran顺序数组，否则创建C顺序数组。用零填充内存（如果 D型 对应于 NPY_OBJECT ）

PyObject *PyArray_ZEROS(int nd, npy_intp const *dims, int type_num, int fortran)

宏观形式 PyArray_Zeros 它采用类型号而不是数据类型对象。

PyObject *PyArray_Empty(int nd, npy_intp const *dims, PyArray_Descr *dtype, int fortran)

构建新的 nd -由给定形状的维数数组 dims 和数据类型 D型 .如果 福特朗 为非零，则创建Fortran顺序数组，否则创建C顺序数组。除非数据类型与 NPY_OBJECT 在这种情况下，数组被填充 Py_None .

PyObject *PyArray_EMPTY(int nd, npy_intp const *dims, int typenum, int fortran)

宏观形式 PyArray_Empty 它接受一个类型号， 铅字 ，而不是数据类型对象。

PyObject *PyArray_Arange(double start, double stop, double step, int typenum)

构造一个新的一维数据类型数组， 铅字 ，范围从 开始 到 stop （独占）增量为 step . 相当于 阿朗格 （ 开始 ， stop ， step ，Dype）。

PyObject *PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *descr)

构造一个新的一维数据类型数组，该数组由 descr ，范围从 start 到 stop （独占）增量为 step . 相当于阿兰奇（ start ， stop ， step ， typenum ）

int PyArray_SetBaseObject(PyArrayObject *arr, PyObject *obj)

1.7 新版功能.

这个函数 窃取推荐信 到 obj 并将其设置为 arr .

如果通过将自己的内存缓冲区作为参数传递来构造数组，则需要设置数组的 base 属性以确保内存缓冲区的生存期是适当的。

成功时返回值为0，失败时返回值为1。

如果提供的对象是数组，则此函数将遍历 base 指针，以便每个数组直接指向内存的所有者。一旦设置了基，就不能将其更改为其他值。

来自其他对象

PyObject *PyArray_FromAny(PyObject *op, PyArray_Descr *dtype, int min_depth, int max_depth, int requirements, PyObject *context)

这是用于从任何嵌套序列或公开数组接口的对象获取数组的主要函数， op . 参数允许指定所需的 D型 最小值（ min_depth ）和最大值（最大值） max_depth ）可接受的尺寸数量，以及其他 要求 对于数组。这个函数 窃取推荐信 到dtype参数，该参数必须是 PyArray_Descr 结构，指示所需的数据类型（包括所需的byteorder）。这个 D型 论点可能是 NULL ，表示可以接受任何数据类型（和字节顺序）。除非 NPY_ARRAY_FORCECAST 存在于 flags 如果无法从对象安全获取数据类型，则此调用将生成错误。如果你想用 NULL 对于 D型 并确保阵列没有交换，然后使用 PyArray_CheckFromAny . 深度参数的值为0会导致忽略该参数。可以添加以下任何数组标志（ e.g. 使用）获取 要求 争论。如果您的代码可以处理常规（ e.g. 跨步、字节交换或未对齐的数组），然后 要求 可能是0。此外，如果 op 不是数组（或不公开数组接口），则将创建一个新数组（并从中填充 op 使用序列协议）。新数组将具有 NPY_ARRAY_DEFAULT 作为其标志成员。这个 语境 参数未使用。

NPY_ARRAY_C_CONTIGUOUS

确保返回的数组是C样式的连续数组

NPY_ARRAY_F_CONTIGUOUS

确保返回的数组是Fortran样式的连续数组。

NPY_ARRAY_ALIGNED

确保返回的数组在其数据类型的适当边界上对齐。对齐数组的数据指针和每一步因子都是数据类型描述符的对齐因子的倍数。

NPY_ARRAY_WRITEABLE

确保返回的数组可以写入。

NPY_ARRAY_ENSURECOPY

确保副本是由 op . 如果不存在此标志，则可以避免复制数据。

NPY_ARRAY_ENSUREARRAY

确保结果是基类ndarray。默认情况下，如果 op 是ndarray子类的实例，返回该子类的实例。如果设置了此标志，则将返回一个ndarray对象。

NPY_ARRAY_FORCECAST

强制将强制转换为输出类型，即使不能安全地进行转换。如果没有此标志，只有在可以安全地进行数据转换时才会发生数据转换，否则会引发错误。

NPY_ARRAY_WRITEBACKIFCOPY

如果 op 已经是一个数组，但不满足要求，则生成一个副本（这将满足要求）。如果存在此标志，并且必须复制（已经是数组的对象的副本），则相应的 NPY_ARRAY_WRITEBACKIFCOPY 在返回的副本中设置标志，并且 op 设置为只读。你一定要打电话 PyArray_ResolveWritebackIfCopy 将内容复制回 op 以及 op 数组将再次变为可写。如果 op 开始时不可写，或者如果它不是数组，则会引发错误。

NPY_ARRAY_UPDATEIFCOPY

不赞成的使用 NPY_ARRAY_WRITEBACKIFCOPY ，这是相似的。当返回的数组被释放时，此标志“自动”将数据复制回，这在所有Python实现中都不受支持。

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_IN_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_IN_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_OUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_OUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_OUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_INOUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_UPDATEIFCOPY

NPY_ARRAY_INOUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_UPDATEIFCOPY

int PyArray_GetArrayParamsFromObject(PyObject *op, PyArray_Descr *requested_dtype, npy_bool writeable, PyArray_Descr **out_dtype, int *out_ndim, npy_intp *out_dims, PyArrayObject **out_arr, PyObject *context)

NumPy 版后已移除: 1.19

除非NumPy意识到此功能存在问题，否则此功能将按计划快速删除而不进行更换。

在 NumPy 版更改: 1.19

context 从未使用过。它的使用会导致一个错误。

1.6 新版功能.

PyObject *PyArray_CheckFromAny(PyObject *op, PyArray_Descr *dtype, int min_depth, int max_depth, int requirements, PyObject *context)

几乎等同于 PyArray_FromAny （…）除外 要求 可以包含 NPY_ARRAY_NOTSWAPPED （超过规范 D型 ） NPY_ARRAY_ELEMENTSTRIDES 这表明数组应该在步幅是元素大小的倍数的意义上对齐。

在numpy的1.6及更早版本中，以下标志没有 _ARRAY_ 其中的宏命名空间。这种形式的常量名在1.7中已被弃用。

NPY_ARRAY_NOTSWAPPED

确保返回的数组具有以机器字节顺序排列的数据类型描述符，而不是 D型 参数。通常，字节顺序要求由 D型 参数。如果设置了此标志并且dtype参数不指示机器字节顺序描述符（或为空，并且对象已经是一个数据类型描述符不在机器字节顺序中的数组），则将创建一个新的数据类型描述符，并将其字节顺序字段设置为native。

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

NPY_ARRAY_ELEMENTSTRIDES

确保返回的数组的步幅是元素大小的倍数。

PyObject *PyArray_FromArray(PyArrayObject *op, PyArray_Descr *newtype, int requirements)

特例 PyArray_FromAny 因为什么时候 op 已经是一个数组，但它必须是特定的 新类型 （包括字节顺序）或具有 要求 .

PyObject *PyArray_FromStructInterface(PyObject *op)

从显示 __array_struct__ 属性，并遵循数组接口协议。如果对象不包含此属性，则将借用对 Py_NotImplemented 返回。

PyObject *PyArray_FromInterface(PyObject *op)

从显示 __array_interface__ 数组接口协议后面的属性。如果对象不包含此属性，则将借用对 Py_NotImplemented 返回。

PyObject *PyArray_FromArrayAttr(PyObject *op, PyArray_Descr *dtype, PyObject *context)

从显示 __array__ 方法。这个 __array__ 方法可以采用0或1参数 ([dtype]) . context 未使用。

PyObject *PyArray_ContiguousFromAny(PyObject *op, int typenum, int min_depth, int max_depth)

此函数从任何嵌套序列或数组接口导出对象返回一个（C样式）连续且行为良好的函数数组， op ，属于（非灵活）类型，由枚举的 铅字 ，最小深度 min_depth ，最大深度 max_depth . 相当于呼叫 PyArray_FromAny 要求设置为 NPY_ARRAY_DEFAULT 类型参数的类型成员设置为 铅字 .

PyObject *PyArray_ContiguousFromObject(PyObject *op, int typenum, int min_depth, int max_depth)

此函数从任何嵌套序列或数组接口导出对象返回一个性能良好的C样式连续数组。数组可以具有的最小维数由 min_depth 最大值为 max_depth . 这相当于打电话 PyArray_FromAny 有要求的 NPY_ARRAY_DEFAULT 和 NPY_ARRAY_ENSUREARRAY .

PyObject *PyArray_FromObject(PyObject *op, int typenum, int min_depth, int max_depth)

从枚举的typenum给定的类型的任何嵌套序列或数组接口导出对象op返回一个对齐且位于本机的byteorder数组。数组的最小维数由最小深度给出，而最大深度为最大深度。这相当于呼叫 PyArray_FromAny 将要求设置为行为。

PyObject *PyArray_EnsureArray(PyObject *op)

这个函数 窃取推荐信 到 op 并确保 op 是基类ndarray。它的特殊情况是数组标量，否则调用 PyArray_FromAny （ op ，NULL，0, 0， NPY_ARRAY_ENSUREARRAY ，NULL）。

PyObject *PyArray_FromString(char *string, npy_intp slen, PyArray_Descr *dtype, npy_intp num, char *sep)

从二进制或（ASCII）文本构造单个类型的一维ndarray string 长度的 slen . 要创建的数组的数据类型由 dtype . 如果num为-1，则 copy 整个字符串并返回适当大小的数组，否则， num 是要执行的项目数 copy 从字符串开始。如果 sep 为空（或“”），然后将字符串解释为二进制数据的字节，否则转换由以下项分隔的子字符串 sep 到数据类型的项 dtype . 某些数据类型在文本模式下可能不可读，如果出现这种情况，将引发错误。所有错误都返回空值。

PyObject *PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep)

从二进制或文本文件构造单个类型的一维ndarray。打开的文件指针是 fp ，要创建的数组的数据类型由 dtype . 这必须与文件中的数据匹配。如果 num 是-1，然后读取直到文件结束，并返回大小适当的数组，否则， num 是要读取的项目数。如果 sep 为空（或“”），然后以二进制模式从文件中读取，否则以文本模式从文件中读取 sep 提供项目分隔符。某些数组类型不能以文本模式读取，在这种情况下会引发错误。

PyObject *PyArray_FromBuffer(PyObject *buf, PyArray_Descr *dtype, npy_intp count, npy_intp offset)

从对象构造一个单一类型的一维ndarray， buf, that exports the (single-segment) buffer protocol (or has an attribute __buffer__ that returns an object that exports the buffer protocol). A writeable buffer will be tried first followed by a read- only buffer. The NPY_ARRAY_WRITEABLE flag of the returned array will reflect which one was successful. The data is assumed to start at offset bytes from the start of the memory location for the object. The type of the data in the buffer will be interpreted depending on the data- type descriptor, dtype. 如果 count 为负，则根据缓冲区的大小和请求的项大小确定，否则， count 表示应该从缓冲区转换多少元素。

int PyArray_CopyInto(PyArrayObject *dest, PyArrayObject *src)

从源数组复制， src ，进入目标数组， dest ，根据需要执行数据类型转换。如果发生错误，返回-1（否则为0）。形状 src 必须能够以 dest . dest和src的数据区域不能重叠。

int PyArray_MoveInto(PyArrayObject *dest, PyArrayObject *src)

从源数组中移动数据， src ，进入目标数组， dest ，根据需要执行数据类型转换。如果发生错误，返回-1（否则为0）。形状 src 必须能够以 dest . dest和src的数据区域可能重叠。

PyArrayObject *PyArray_GETCONTIGUOUS(PyObject *op)

如果 op 已经是（C样式）连续且行为良好的，然后只返回引用，否则返回数组的（连续且行为良好）副本。参数op必须是ndarray的（子类），并且没有检查。

PyObject *PyArray_FROM_O(PyObject *obj)

转换 obj 对一个黑人参数可以是导出数组接口的任何嵌套序列或对象。这是一个宏形式 PyArray_FromAny 使用 NULL 其他参数为0、0、0。您的代码必须能够处理任何数据类型描述符和任何数据标志组合才能使用此宏。

PyObject *PyArray_FROM_OF(PyObject *obj, int requirements)

类似 PyArray_FROM_O 但它可以接受 要求 指示结果数组必须具有的属性。可以强制执行的可用需求是 NPY_ARRAY_C_CONTIGUOUS ， NPY_ARRAY_F_CONTIGUOUS ， NPY_ARRAY_ALIGNED ， NPY_ARRAY_WRITEABLE ， NPY_ARRAY_NOTSWAPPED ， NPY_ARRAY_ENSURECOPY ， NPY_ARRAY_WRITEBACKIFCOPY ， NPY_ARRAY_UPDATEIFCOPY ， NPY_ARRAY_FORCECAST 和 NPY_ARRAY_ENSUREARRAY . 还可以使用标志的标准组合：

PyObject *PyArray_FROM_OT(PyObject *obj, int typenum)

类似 PyArray_FROM_O 但它可以接受 铅字 指定返回数组的类型号。

PyObject *PyArray_FROM_OTF(PyObject *obj, int typenum, int requirements)

组合 PyArray_FROM_OF 和 PyArray_FROM_OT 允许两者兼具 铅字 和A 旗帜 要提供的参数。

PyObject *PyArray_FROMANY(PyObject *obj, int typenum, int min, int max, int requirements)

类似 PyArray_FromAny 但数据类型是使用类型号指定的。 PyArray_DescrFromType （ 铅字 ）直接传递给 PyArray_FromAny . 此宏还添加了 NPY_ARRAY_DEFAULT 符合要求，如果 NPY_ARRAY_ENSURECOPY 按要求传递。

PyObject *PyArray_CheckAxis(PyObject *obj, int *axis, int requirements)

封装采用axis=关键字并使用none作为axis参数的函数和方法的功能。输入数组是 obj ，同时 *axis 是一个转换后的整数（因此>=maxdims是none值），并且 requirements 给出了 obj . 输出是输入的一个转换版本，这样就满足了需求，如果需要的话，就会发生扁平化。关于输出负值 *axis 转换并检查新值以确保与 obj .

处理类型

python类型的常规检查

int PyArray_Check(PyObject *op)

如果计算为真 op 是一个python对象，其类型是 PyArray_Type .

int PyArray_CheckExact(PyObject *op)

如果计算为真 op 是类型为的python对象 PyArray_Type .

int PyArray_HasArrayInterface(PyObject *op, PyObject *out)

如果 op 实现数组接口的任何部分，然后 out 将包含使用接口或 out 将包含 NULL 如果转换过程中发生错误。否则，out将包含对 Py_NotImplemented 未设置错误条件。

int PyArray_HasArrayInterfaceType(PyObject *op, PyArray_Descr *dtype, PyObject *context, PyObject *out)

如果 op 实现数组接口的任何部分，然后 out 将包含使用接口或 out 将包含 NULL 如果转换过程中发生错误。否则，out将包含对Pyu NotImplemented的借用引用，并且不设置错误条件。此版本允许在数组接口中查找 __array__ 属性。 context 未使用。

int PyArray_IsZeroDim(PyObject *op)

如果计算为真 op 是（的子类）的实例 PyArray_Type 并且有0个维度。

PyArray_IsScalar(op, cls)

如果计算为真 op 是的实例 Py{{cls}}ArrType_Type .

int PyArray_CheckScalar(PyObject *op)

如果计算为真 op 是数组标量（子类型的实例 PyGenericArr_Type 或（的子类）的实例 PyArray_Type 其维数为0。

int PyArray_IsPythonNumber(PyObject *op)

如果计算为真 op 是内置数值类型（int、float、complex、long、bool）的实例

int PyArray_IsPythonScalar(PyObject *op)

如果计算为真 op 是一个内置的Python标量对象（int、float、complex、bytes、str、long、bool）。

int PyArray_IsAnyScalar(PyObject *op)

如果计算为真 op 是python标量对象（请参见 PyArray_IsPythonScalar ）或数组标量（子类型 PyGenericArr_Type ）

int PyArray_CheckAnyScalar(PyObject *op)

如果计算为真 op 是python标量对象（请参见 PyArray_IsPythonScalar ，数组标量（子类型的实例 PyGenericArr_Type ）或子类型的实例 PyArray_Type 其维数为0。

数据类型检查

对于typenum宏，参数是表示枚举数组数据类型的整数。对于数组类型检查宏，参数必须是 PyObject* 可以直接解释为 PyArrayObject* .

int PyTypeNum_ISUNSIGNED(int num)

int PyDataType_ISUNSIGNED(PyArray_Descr *descr)

int PyArray_ISUNSIGNED(PyArrayObject *obj)

类型表示无符号整数。

int PyTypeNum_ISSIGNED(int num)

int PyDataType_ISSIGNED(PyArray_Descr *descr)

int PyArray_ISSIGNED(PyArrayObject *obj)

类型表示有符号整数。

int PyTypeNum_ISINTEGER(int num)

int PyDataType_ISINTEGER(PyArray_Descr *descr)

int PyArray_ISINTEGER(PyArrayObject *obj)

类型表示任何整数。

int PyTypeNum_ISFLOAT(int num)

int PyDataType_ISFLOAT(PyArray_Descr *descr)

int PyArray_ISFLOAT(PyArrayObject *obj)

类型表示任何浮点数。

int PyTypeNum_ISCOMPLEX(int num)

int PyDataType_ISCOMPLEX(PyArray_Descr *descr)

int PyArray_ISCOMPLEX(PyArrayObject *obj)

类型表示任何复杂的浮点数。

int PyTypeNum_ISNUMBER(int num)

int PyDataType_ISNUMBER(PyArray_Descr *descr)

int PyArray_ISNUMBER(PyArrayObject *obj)

类型表示任何整数、浮点数或复杂浮点数。

int PyTypeNum_ISSTRING(int num)

int PyDataType_ISSTRING(PyArray_Descr *descr)

int PyArray_ISSTRING(PyArrayObject *obj)

类型表示字符串数据类型。

int PyTypeNum_ISPYTHON(int num)

int PyDataType_ISPYTHON(PyArray_Descr *descr)

int PyArray_ISPYTHON(PyArrayObject *obj)

类型表示对应于标准python标量（bool、int、float或complex）之一的枚举类型。

int PyTypeNum_ISFLEXIBLE(int num)

int PyDataType_ISFLEXIBLE(PyArray_Descr *descr)

int PyArray_ISFLEXIBLE(PyArrayObject *obj)

类型表示灵活的数组类型之一（ NPY_STRING ， NPY_UNICODE 或 NPY_VOID ）

int PyDataType_ISUNSIZED(PyArray_Descr *descr)

类型没有附加大小信息，可以调整大小。只应在灵活的数据类型上调用。附加到数组的类型将始终调整大小，因此该宏的数组形式不存在。

在 1.18 版更改.

对于没有字段的结构化数据类型，此函数现在返回False。

int PyTypeNum_ISUSERDEF(int num)

int PyDataType_ISUSERDEF(PyArray_Descr *descr)

int PyArray_ISUSERDEF(PyArrayObject *obj)

类型表示用户定义的类型。

int PyTypeNum_ISEXTENDED(int num)

int PyDataType_ISEXTENDED(PyArray_Descr *descr)

int PyArray_ISEXTENDED(PyArrayObject *obj)

类型是灵活的或用户定义的。

int PyTypeNum_ISOBJECT(int num)

int PyDataType_ISOBJECT(PyArray_Descr *descr)

int PyArray_ISOBJECT(PyArrayObject *obj)

类型表示对象数据类型。

int PyTypeNum_ISBOOL(int num)

int PyDataType_ISBOOL(PyArray_Descr *descr)

int PyArray_ISBOOL(PyArrayObject *obj)

类型表示布尔数据类型。

int PyDataType_HASFIELDS(PyArray_Descr *descr)

int PyArray_HASFIELDS(PyArrayObject *obj)

类型有与其关联的字段。

int PyArray_ISNOTSWAPPED(PyArrayObject *m)

如果Ndarray的数据区域为 m 根据数组的数据类型描述符按机器字节顺序排列。

int PyArray_ISBYTESWAPPED(PyArrayObject *m)

如果Ndarray的数据区域为 m 是 not 按照数组的数据类型描述符的机器字节顺序。

npy_bool PyArray_EquivTypes(PyArray_Descr *type1, PyArray_Descr *type2)

返回 NPY_TRUE 如果 1型 和 2型 实际上表示此平台的等效类型（忽略每种类型的Fortran成员）。例如，在32位平台上， NPY_LONG 和 NPY_INT 是等效的。否则返回 NPY_FALSE .

npy_bool PyArray_EquivArrTypes(PyArrayObject *a1, PyArrayObject *a2)

返回 NPY_TRUE 如果 a1 和 a2 是具有此平台的等效类型的数组。

npy_bool PyArray_EquivTypenums(int typenum1, int typenum2)

特例 PyArray_EquivTypes （…）不接受灵活的数据类型，但可能更容易调用。

int PyArray_EquivByteorders(int b1, int b2)

如果字节顺序字符 b1 和 b2 （ NPY_LITTLE ， NPY_BIG ， NPY_NATIVE ， NPY_IGNORE ）与本机字节顺序的规范相同或等效。因此，在一个小endian机器上 NPY_LITTLE 和 NPY_NATIVE 当它们在big-endian机器上不等价时，它们是等价的。

转换数据类型

PyObject *PyArray_Cast(PyArrayObject *arr, int typenum)

主要用于与数字C-API的向后兼容性，以及简单的强制转换为非灵活类型。返回具有以下元素的新数组对象 arr 强制转换为数据类型 铅字 它必须是枚举类型之一，而不是灵活类型。

PyObject *PyArray_CastToType(PyArrayObject *arr, PyArray_Descr *type, int fortran)

返回一个新的 type 指定，铸造 arr 视情况而定。Fortran参数指定输出数组的顺序。

int PyArray_CastTo(PyArrayObject *out, PyArrayObject *in)

从1.6开始，此函数只调用 PyArray_CopyInto 处理铸件。

强制转换数组元素 in 进入数组 out . 输出数组应该是可写的，具有输入数组中元素数的整数倍（可以将多个副本放入输出中），并且具有作为内置类型之一的数据类型。成功时返回0，如果发生错误则返回-1。

PyArray_VectorUnaryFunc *PyArray_GetCastFunc(PyArray_Descr *from, int totype)

返回要从给定描述符转换为内置类型号的低级转换函数。如果不存在强制转换函数，返回 NULL 并设置错误。使用此函数而不是直接访问 from ->f->cast将允许支持添加到描述符casting字典中的任何用户定义的casting函数。

int PyArray_CanCastSafely(int fromtype, int totype)

如果数据类型为数组，则返回非零 来自类型 无法强制转换为数据类型的数组 ToType 不会丢失信息。一个例外是，允许64位整数强制转换为64位浮点值，即使这可能会降低大整数的精度，以便在没有显式请求的情况下不增加长双精度数的使用。灵活的数组类型不会根据其长度使用此函数进行检查。

int PyArray_CanCastTo(PyArray_Descr *fromtype, PyArray_Descr *totype)

PyArray_CanCastTypeTo 取代numpy 1.6及更高版本中的此函数。

相当于pyarray_cancastypeto（fromtype、totype、npy_safe_casting）。

int PyArray_CanCastTypeTo(PyArray_Descr *fromtype, PyArray_Descr *totype, NPY_CASTING casting)

1.6 新版功能.

如果数据类型为数组，则返回非零 来自类型 （可以包括灵活的类型）可以安全地强制转换为数据类型的数组 ToType （可包括柔性类型）根据铸造规则 铸造 . 对于简单类型 NPY_SAFE_CASTING ，这基本上是一个包装 PyArray_CanCastSafely 但对于字符串或Unicode之类的灵活类型，它会根据其大小生成结果。整型和浮点型只能用以下方法强制转换为字符串或Unicode类型： NPY_SAFE_CASTING 如果字符串或Unicode类型足够大，可以保存从中转换的整数/浮点类型的最大值。

int PyArray_CanCastArrayTo(PyArrayObject *arr, PyArray_Descr *totype, NPY_CASTING casting)

1.6 新版功能.

返回非零if arr 可以铸造成 ToType 根据中给出的铸造规则 铸造 . 如果 arr 是一个数组标量，它的值会被考虑在内，当该值在转换为较小的类型时不会溢出或被截断为整数时，也会返回非零。

这几乎与pyarray_cancastypeto（pyarray_minscalartype（arr）、totype、casting）的结果相同，但它也处理出现的特殊情况，因为uint值集不是具有相同位数的类型的int值的子集。

PyArray_Descr *PyArray_MinScalarType(PyArrayObject *arr)

1.6 新版功能.

如果 arr 是数组，返回其数据类型描述符，但如果 arr 是一个数组标量（有0个维度），它查找最小大小的数据类型，该数据类型的值可以在不溢出或截断的情况下转换为整数。

此函数不会将复杂值降级为浮点值或任何值，而是将有符号整数降级为无符号整数（当标量值为正时）。

PyArray_Descr *PyArray_PromoteTypes(PyArray_Descr *type1, PyArray_Descr *type2)

1.6 新版功能.

查找最小大小和类型的数据类型 1型 和 2型 可安全转换。这个函数是对称和关联的。字符串或Unicode结果的大小将适合存储转换为字符串或Unicode的输入类型的最大值。

PyArray_Descr *PyArray_ResultType(npy_intp narrs, PyArrayObject **arrs, npy_intp ndtypes, PyArray_Descr **dtypes)

1.6 新版功能.

这将对所有输入应用类型提升，使用numpy规则组合标量和数组，以确定一组操作数的输出类型。这与UFUNCS生成的结果类型相同。具体算法如下。

类别是通过首先检查布尔值、整数（int/uint）或浮点（float/complex）中的哪一个来确定的，所有数组和标量的最大类型是。

如果只有标量，或者标量的最大类别高于数组的最大类别，则数据类型将与 PyArray_PromoteTypes 以产生返回值。

否则，将对每个数组调用pyarray_minscalartype，并将生成的数据类型与 PyArray_PromoteTypes 以产生返回值。

对于具有相同位数的类型，int值集不是uint值的子集，而不是反映在 PyArray_MinScalarType ，但在pyarray的resultType中作为特殊情况处理。

int PyArray_ObjectType(PyObject *op, int mintype)

此功能被取代 PyArray_MinScalarType 和/或 PyArray_ResultType .

此函数用于确定可以将两个或多个数组转换为的公共类型。它只适用于不灵活的数组类型，因为没有传递itemsize信息。这个 迷你型 参数表示可接受的最小类型，以及 op 表示将转换为数组的对象。返回值是表示 op 应该有的。

void PyArray_ArrayType(PyObject *op, PyArray_Descr *mintype, PyArray_Descr *outtype)

此功能被取代 PyArray_ResultType .

此函数的工作原理与 PyArray_ObjectType （…）但它处理灵活的数组。这个 迷你型 参数不能具有itemsize成员和 外型 参数将具有一个itemsize成员，该成员至少与对象一样大，但可能更大，具体取决于对象 op .

PyArrayObject **PyArray_ConvertToCommonType(PyObject *op, int *n)

它提供的功能在很大程度上被迭代器所取代 NpyIter 在1.6中引入，带有标志 NPY_ITER_COMMON_DTYPE 或对所有操作数使用相同的dtype参数。

转换包含在 op 每个数组都具有相同的数据类型。选择类型的方式与 PyArray_ResultType . 序列的长度以 n 和一个 n -长度数组 PyArrayObject 指针是返回值（或 NULL 如果发生错误）。此例程的调用方必须释放返回的数组（使用 PyDataMem_FREE ）以及其中的所有数组对象 DECREF 否则会发生内存泄漏。下面的示例模板代码显示了一个典型的用法：

在 1.18.0 版更改: 标量和零维数组的混合现在生成了一个能够保存标量值的类型。以前优先考虑数组的数据类型。

mps = PyArray_ConvertToCommonType(obj, &n);
if (mps==NULL) return NULL;
{code}
<before return>
for (i=0; i<n; i++) Py_DECREF(mps[i]);
PyDataMem_FREE(mps);
{return}

char *PyArray_Zero(PyArrayObject *arr)

指向新创建的大小为的内存的指针 arr ->保存该类型的0表示形式的itemsize。返回的指针， ret ， 必须解放 使用 PyDataMem_FREE （RET）不再需要时。

char *PyArray_One(PyArrayObject *arr)

指向新创建的大小为的内存的指针 arr ->itemsize，它保存该类型的1表示形式。返回的指针， ret ， 必须解放 使用 PyDataMem_FREE （RET）不再需要时。

int PyArray_ValidType(int typenum)

返回 NPY_TRUE 如果 铅字 表示有效的类型号（内置或用户定义或字符代码）。否则，此函数返回 NPY_FALSE .

新数据类型

void PyArray_InitArrFuncs(PyArray_ArrFuncs *f)

将所有函数指针和成员初始化为 NULL .

int PyArray_RegisterDataType(PyArray_Descr *dtype)

将数据类型注册为新的用户定义的数组数据类型。类型必须填写其大部分条目。这并不总是被检查的，错误可能会产生段故障。尤其是 dtype 结构必须用具有固定大小元素大小的python类型填充，该元素大小与的elsize成员相对应。 D型 . 也 f 成员必须具有所需的函数：nonzero、copyswap、copyswapn、getitem、setitem和cast（某些转换函数可能是 NULL 如果不需要支持）。为了避免混淆，您应该选择一个唯一的字符类型代码，但这不是强制的，也不是内部依赖的。

返回唯一标识该类型的用户定义类型号。然后可以从中获取指向新结构的指针 PyArray_DescrFromType 使用返回的类型号。如果发生错误，则返回-1。如果这样 D型 已注册（仅由指针地址检查），然后返回以前分配的类型号。

int PyArray_RegisterCastFunc(PyArray_Descr *descr, int totype, PyArray_VectorUnaryFunc *castfunc)

注册低级强制转换函数， 斯卡芬克 ，要从数据类型转换， 德克思 ，到给定的数据类型编号， ToType . 任何旧的强制转换函数都是重写的。一 0 成功返回或 -1 失败论。

int PyArray_RegisterCanCast(PyArray_Descr *descr, int totype, NPY_SCALARKIND scalar)

注册数据类型编号， ToType ，作为数据类型对象的可强制转换， 德克思 的，给定的 标量 种类。使用 标量 = NPY_NOSCALAR 注册一个数据类型的数组 德克思 可以安全地强制转换为数据类型，其类型编号为 ToType .

npy_对象的特殊功能

int PyArray_INCREF(PyArrayObject *op)

用于数组， op ，它包含任何python对象。它根据 op . 如果发生错误，则返回-1，否则返回0。

void PyArray_Item_INCREF(char *ptr, PyArray_Descr *dtype)

用于增加该位置上所有对象的函数 ptr 根据数据类型 D型 .如果 ptr 是一个结构化类型的开头，对象位于任意偏移量处，然后这将（递归地）增加结构化类型中所有与对象类似的项的引用计数。

int PyArray_XDECREF(PyArrayObject *op)

用于数组， op ，它包含任何python对象。它根据 op . 正常返回值为0。如果发生错误，则返回-1。

void PyArray_Item_XDECREF(char *ptr, PyArray_Descr *dtype)

一个函数，用于xdecref该位置上所有类似对象的项 ptr 如数据类型中所记录的， D型 . 这是递归工作的，因此如果 dtype 它本身具有包含类似对象项的数据类型的字段，所有类似对象的字段都将是xdecref 'd .

void PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj)

用对象数据类型在结构中的所有位置用单个值obj填充新创建的数组。不进行检查，但 arr 必须是数据类型 NPY_OBJECT 且为单段且未初始化（位置上没有以前的对象）。使用 PyArray_XDECREF （ arr ）如果需要在调用此函数之前减少对象数组中的所有项。

int PyArray_SetUpdateIfCopyBase(PyArrayObject *arr, PyArrayObject *base)

先决条件： arr 是一份拷贝 base （尽管可能有不同的步幅、顺序等）设置updateifcopy标志并 arr->base 所以当 arr 已销毁，它将把所有更改复制回 base . 弃用，使用 PyArray_SetWritebackIfCopyBase .

成功时返回0，失败时返回1。

int PyArray_SetWritebackIfCopyBase(PyArrayObject *arr, PyArrayObject *base)

先决条件： arr 是一份拷贝 base （尽管可能有不同的步幅、顺序等）设置 NPY_ARRAY_WRITEBACKIFCOPY 旗与 arr->base 并设置 base 只读。呼叫 PyArray_ResolveWritebackIfCopy 打电话之前 Py_DECREF 为了将任何更改复制回 base 并重置只读标志。

成功时返回0，失败时返回1。

数组标志

这个 flags 的属性 PyArrayObject 结构包含有关数组使用的内存（由数据成员指向）的重要信息。此标志信息必须保持准确或奇怪的结果，甚至可能导致SEG故障。

有6个（二进制）标志描述数据缓冲区使用的内存区域。这些常量定义在 arrayobject.h 并确定标志位的位置。python公开了一个很好的基于属性的接口，以及一个类似字典的接口，用于获取（如果合适的话，还可以设置）这些标志。

所有类型的内存区域都可以通过一个数据数组来指向，这就需要这些标志。如果你武断 PyArrayObject 在C代码中，您需要知道设置的标志。如果需要保证某种类型的数组（如 NPY_ARRAY_C_CONTIGUOUS 和 NPY_ARRAY_BEHAVED ，然后将这些需求从任何函数传递到pyarray。

基本数组标志

一个ndarray可以有一个数据段，它不是一个简单的、连续的、可操作的、性能良好的内存块。它可能与单词边界不一致（在某些平台上非常重要）。它的数据的字节顺序可能与机器识别的不同。它可能不可写。它可能是Fortran的连续顺序。数组标志用于指示与数组关联的数据的含义。

在numpy的1.6及更早版本中，以下标志没有 _ARRAY_ 其中的宏命名空间。这种形式的常量名在1.7中已被弃用。

NPY_ARRAY_C_CONTIGUOUS

数据区域是C样式的连续顺序（最后一个索引变化最快）。

NPY_ARRAY_F_CONTIGUOUS

数据区域采用FORTRAN样式的连续顺序（第一个索引变化最快）。

注解

数组可以同时为C样式和Fortran样式。这对于一维数组来说是显而易见的，但对于更高维数组也是如此。

即使对于连续的数组，对于给定的维也是一个步骤。 arr.strides[dim] 可能是 任意的 如果 arr.shape[dim] == 1 或者数组没有元素。它确实 not 一般认为 self.strides[-1] == self.itemsize 对于C型连续数组或 self.strides[0] == self.itemsize 对于Fortran样式，连续数组为true。正确的访问方法 itemsize 来自C API的数组的 PyArray_ITEMSIZE(arr) .

参见

Internal memory layout of an ndarray

NPY_ARRAY_OWNDATA

数据区域属于此数组。

NPY_ARRAY_ALIGNED

数据区域和所有数组元素都适当地对齐。

NPY_ARRAY_WRITEABLE

数据区域可以写入。

请注意，以上3个标志是定义的，因此新的、行为良好的数组将这些标志定义为true。

NPY_ARRAY_WRITEBACKIFCOPY

数据区域表示一个（行为良好的）副本，当 PyArray_ResolveWritebackIfCopy 被称为。

这是一个特殊标志，如果此数组表示由于用户需要某些标志 PyArray_FromAny 必须用其他数组（用户要求在这种情况下设置此标志）创建一个副本。然后，基属性指向“行为不当”数组（设置为只读）。 :c:func`PyArray_ResolveWritebackIfCopy` will copy its contents back to the "misbehaved" array (casting if necessary) and will reset the "misbehaved" array to NPY_ARRAY_WRITEABLE . 如果“行为不当”数组不是 NPY_ARRAY_WRITEABLE 从那时开始 PyArray_FromAny 会返回一个错误，因为 NPY_ARRAY_WRITEBACKIFCOPY 那是不可能的。

NPY_ARRAY_UPDATEIFCOPY

已弃用的版本 NPY_ARRAY_WRITEBACKIFCOPY 这取决于 dealloc 触发写回。为了向后兼容， PyArray_ResolveWritebackIfCopy 被调用 dealloc 但是依赖于这种行为是不赞成的，并且在Pypy中不受支持。

PyArray_UpdateFlags （obj，flags）将更新 obj->flags 对于 flags 可以是任何 NPY_ARRAY_C_CONTIGUOUS ， NPY_ARRAY_F_CONTIGUOUS ， NPY_ARRAY_ALIGNED 或 NPY_ARRAY_WRITEABLE .

数组标志的组合

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_UPDATE_ALL

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

类标志常量

这些常量用于 PyArray_FromAny （及其宏形式）指定新数组的所需属性。

NPY_ARRAY_FORCECAST

强制转换为所需的类型，即使它不能在不丢失信息的情况下完成。

NPY_ARRAY_ENSURECOPY

确保生成的数组是原始数组的副本。

NPY_ARRAY_ENSUREARRAY

确保生成的对象是实际的ndarray，而不是子类。

标志检查

对于所有这些宏 arr 必须是（的子类）的实例 PyArray_Type .

int PyArray_CHKFLAGS(PyObject *arr, int flags)

第一个参数arr必须是ndarray或子类。参数， 旗帜 ，应该是一个整数，由数组可以具有的可能标志的位组合组成： NPY_ARRAY_C_CONTIGUOUS ， NPY_ARRAY_F_CONTIGUOUS ， NPY_ARRAY_OWNDATA ， NPY_ARRAY_ALIGNED ， NPY_ARRAY_WRITEABLE ， NPY_ARRAY_WRITEBACKIFCOPY ， NPY_ARRAY_UPDATEIFCOPY .

int PyArray_IS_C_CONTIGUOUS(PyObject *arr)

如果计算为真 arr C样式是连续的。

int PyArray_IS_F_CONTIGUOUS(PyObject *arr)

如果计算为真 arr Fortran样式是连续的。

int PyArray_ISFORTRAN(PyObject *arr)

如果计算为真 arr Fortran样式是连续的并且 not C型相邻。 PyArray_IS_F_CONTIGUOUS 是测试Fortran样式连续性的正确方法。

int PyArray_ISWRITEABLE(PyObject *arr)

如果的数据区域 arr 可以写入

int PyArray_ISALIGNED(PyObject *arr)

如果的数据区域 arr 在机器上正确对齐。

int PyArray_ISBEHAVED(PyObject *arr)

如果的数据区域 arr 根据其描述符以机器字节顺序对齐和可写。

int PyArray_ISBEHAVED_RO(PyObject *arr)

如果的数据区域 arr 按机器字节顺序对齐。

int PyArray_ISCARRAY(PyObject *arr)

如果的数据区域 arr C样式是连续的，并且 PyArray_ISBEHAVED （ arr ）是真的。

int PyArray_ISFARRAY(PyObject *arr)

如果的数据区域 arr Fortran样式是连续的并且 PyArray_ISBEHAVED （ arr ）是真的。

int PyArray_ISCARRAY_RO(PyObject *arr)

如果的数据区域 arr C样式是连续的、对齐的，并且是按机器字节顺序排列的。

int PyArray_ISFARRAY_RO(PyObject *arr)

如果的数据区域 arr FORTRAN样式是连续的、对齐的，并且是按机器字节顺序排列的 .

int PyArray_ISONESEGMENT(PyObject *arr)

如果的数据区域 arr 由单个（C样式或Fortran样式）连续段组成。

void PyArray_UpdateFlags(PyArrayObject *arr, int flagmask)

这个 NPY_ARRAY_C_CONTIGUOUS ， NPY_ARRAY_ALIGNED 和 NPY_ARRAY_F_CONTIGUOUS 数组标志可以从数组对象本身“计算”。此例程更新以下一个或多个标志： arr 如中所述 旗罩 通过执行所需的计算。

警告

保持标记更新（使用 PyArray_UpdateFlags 可以帮助）每当对数组执行可能导致它们更改的操作时。依赖于这些标志状态的numpy中的后续计算不会重复计算以更新它们。

数组方法替代API

转换

PyObject *PyArray_GetField(PyArrayObject *self, PyArray_Descr *dtype, int offset)

相当于 ndarray.getfield （ self ， D型 ， 抵消 ). 此函数 steals a reference 到 PyArray_Descr 并返回给定 dtype 在指定的 offset 以字节为单位。这个 offset 加上新数组类型的itemsize必须小于 self ->descr->elsize 或出现错误。使用与原始阵列相同的形状和步幅。因此，此函数具有从结构化数组返回字段的效果。但是，它也可以用于从任何数组类型中选择特定的字节或字节组。

int PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype, int offset, PyObject *val)

相当于 ndarray.setfield （ self ， val ， D型 ， 抵消 ）将字段设置为从开始 抵消 以字节和为单位 D型 到 val . 这个 抵消 加 D型 ->elsize必须小于 self ->DESCR->ELSIZE或引发错误。否则， val 参数转换为数组并复制到指向的字段中。如有必要， val 重复以填充目标数组，但目标中的元素数必须是中元素数的整数倍。 val .

PyObject *PyArray_Byteswap(PyArrayObject *self, npy_bool inplace)

相当于 ndarray.byteswap （ self ， 原地 ）返回其数据区域为byteswapped的数组。如果 原地 为非零，然后执行byteswap就地操作并返回对self的引用。否则，创建一个字节映射副本并保持自身不变。

PyObject *PyArray_NewCopy(PyArrayObject *old, NPY_ORDER order)

相当于 ndarray.copy （ self ， 福特朗 ）复制 old 数组。返回的数组总是对齐和可写的，数据的解释与旧数组相同。如果 秩序 是 NPY_CORDER ，然后返回C样式的连续数组。如果 秩序 是 NPY_FORTRANORDER ，然后返回一个Fortran样式的连续数组。如果 秩序是 NPY_ANYORDER ，则返回的数组只有在旧数组是连续的情况下才是Fortran样式；否则，它是C样式连续的。

PyObject *PyArray_ToList(PyArrayObject *self)

相当于 ndarray.tolist （ self ）从返回嵌套的python列表 self .

PyObject *PyArray_ToString(PyArrayObject *self, NPY_ORDER order)

相当于 ndarray.tobytes （ self ， 秩序 ）以python字符串返回此数组的字节。

PyObject *PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format)

写下的内容 self 指向文件指针 fp 以C样式连续的方式。如果 sep 是字符串“”还是 NULL . 否则，写下 self 作为文本使用 sep 字符串作为项目分隔符。每个项目都将打印到文件中。如果 格式 字符串不是 NULL 或者“”，那么它是一个python print语句格式字符串，显示如何写入这些项。

int PyArray_Dump(PyObject *self, PyObject *file, int protocol)

把物体腌起来 self 到给定的 file （字符串或python文件对象）。如果 file 是一个python字符串，它被认为是以二进制模式打开的文件名。给定的 协议 使用（如果） 协议 为负，或使用最高可用值）。这是围绕cpickle.dump的简单包装。（ self ， file ， 协议 ）

PyObject *PyArray_Dumps(PyObject *self, int protocol)

把物体腌起来 self 返回一个python字符串。用泡菜 协议 提供（或在 协议 是否定的）。

int PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)

填充数组， arr ，对于给定的标量对象， obj . 对象首先转换为 arr ，然后复制到每个位置。如果发生错误，则返回-1，否则返回0。

PyObject *PyArray_View(PyArrayObject *self, PyArray_Descr *dtype, PyTypeObject *ptype)

相当于 ndarray.view （ self ， D型 ）返回数组的新视图 self 可能是另一种数据类型， D型 以及不同的数组子类 P型 .

如果 D型 是 NULL ，则返回的数组的数据类型与 self . 新数据类型必须与 self . 项大小必须相同，或者 self 必须是单个段，总字节数必须相同。在后一种情况下，返回数组的维度将在最后一个维度（或对于Fortran样式的连续数组，第一个维度）中更改。返回的数组和self的数据区域完全相同。

形状操纵

PyObject *PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newshape, NPY_ORDER order)

结果将是一个新数组（指向与 self 如果可能的话），但形状由 新形状 . 如果新形状与 self ，然后将返回具有新指定形状的数组的副本。

PyObject *PyArray_Reshape(PyArrayObject *self, PyObject *shape)

相当于 ndarray.reshape （ self ， 形状 何处 形状 是一个序列。皈依者 形状 到A PyArray_Dims 结构和调用 PyArray_Newshape 内部的。对于向后兼容——不推荐

PyObject *PyArray_Squeeze(PyArrayObject *self)

相当于 ndarray.squeeze （ self ）返回的新视图 self 从形状中删除长度为1的所有尺寸。

警告

矩阵对象总是二维的。因此， PyArray_Squeeze 对矩阵子类的数组没有影响。

PyObject *PyArray_SwapAxes(PyArrayObject *self, int a1, int a2)

相当于 ndarray.swapaxes （ self ， a1 ， a2 ）返回的数组是中数据的新视图 self 对于给定的轴， a1 和 a2 交换。

PyObject *PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, NPY_ORDER fortran)

相当于 ndarray.resize （ self ， 新形状 复查 = 再检查 ，order=fortran）。此函数仅适用于单段数组。它改变了 self 替换并重新分配内存 self 如果 新形状 元素总数与旧形状不同。如果需要重新分配，则 self 必须拥有自己的数据，拥有 self - >base==NULL 有 self - >weakrefs==NULL 和（除非refcheck为0）不被任何其他数组引用。Fortran参数可以是 NPY_ANYORDER ， NPY_CORDER 或 NPY_FORTRANORDER . 目前没有效果。最终，它可以用于确定在构造不同维度的数组时，调整大小操作应如何查看数据。成功时返回“无”，错误时返回“空”。

PyObject *PyArray_Transpose(PyArrayObject *self, PyArray_Dims *permute)

相当于 ndarray.transpose （ self ， 置换 ）排列Ndarray对象的轴 self 根据数据结构 置换 并返回结果。如果 置换 是 NULL ，则生成的数组的轴反转。例如，如果 self 有形状 和 置换 .ptr 是（0,2,1）结果的形状是 如果 置换 是 NULL ，结果的形状为

PyObject *PyArray_Flatten(PyArrayObject *self, NPY_ORDER order)

相当于 ndarray.flatten （ self ， 秩序 ）返回数组的一维副本。如果 秩序 是 NPY_FORTRANORDER 元素按FORTRAN顺序扫描（第一个维度变化最快）。如果 秩序 是 NPY_CORDER ，元素 self 按C顺序扫描（最后一个尺寸变化最快）。如果 秩序 NPY_ANYORDER ，然后是 PyArray_ISFORTRAN （ self ）用于确定要展平的顺序。

PyObject *PyArray_Ravel(PyArrayObject *self, NPY_ORDER order)

相当于 self ravel 秩序 ）基本功能与 PyArray_Flatten （ self ， 秩序 除外） 秩序 是0和 self 是C样式连续的，形状已更改，但不执行复制。

项目选择和操作

PyObject *PyArray_TakeFrom(PyArrayObject *self, PyObject *indices, int axis, PyArrayObject *ret, NPY_CLIPMODE clipmode)

相当于 ndarray.take （ self ， 指数 ， axis ， ret ， 剪辑模式 除外 axis =python中的none是通过设置 axis = NPY_MAXDIMS 在C中，从由整数值表示的自指示项中提取项 指数 沿着给定的 轴。 clipMode参数可以是 NPY_RAISE ， NPY_WRAP 或 NPY_CLIP 指示如何处理超出界限的索引。这个 ret 参数可以指定输出数组，而不是在内部创建输出数组。

PyObject *PyArray_PutTo(PyArrayObject *self, PyObject *values, PyObject *indices, NPY_CLIPMODE clipmode)

相当于 self 放 价值观 ， 指数 ， 剪辑模式 ）放 价值观 进入之内 self 在相应的（平坦的） 指数 .如果 价值观 太小，必要时会重复。

PyObject *PyArray_PutMask(PyArrayObject *self, PyObject *values, PyObject *mask)

放置 价值观 在里面 self 任何地方的相应位置（使用扁平上下文） mask 是真的。这个 mask 和 self 数组的元素总数必须相同。如果 价值观 太小，必要时会重复。

PyObject *PyArray_Repeat(PyArrayObject *self, PyObject *op, int axis)

相当于 ndarray.repeat （ self ， op ， axis ）复制的元素 self ， op 给定时间 axis . 要么 op 是标量整数或长度序列 self >尺寸 [ axis ] 指示沿轴重复每个项的次数。

PyObject *PyArray_Choose(PyArrayObject *self, PyObject *op, PyArrayObject *ret, NPY_CLIPMODE clipmode)

相当于 ndarray.choose （ self ， op ， ret ， 剪辑模式 ）通过从中的数组序列中选择元素来创建新数组 op 基于中的整数值 self . 数组必须都可以广播到相同的形状和中的条目。 self 应该在0和len之间（ op ）输出放在 ret 除非它是 NULL 在这种情况下，将创建新的输出。这个 剪辑模式 参数确定当项位于 self 不在0和len之间（ op ）

NPY_RAISE

引发ValueError；

NPY_WRAP

通过添加len使值小于0（ op ）且值大于等于len（ op ）减去len（ op ）直到它们在射程内；

NPY_CLIP

所有值都被剪切到区域[0，len（ op ）

PyObject *PyArray_Sort(PyArrayObject *self, int axis, NPY_SORTKIND kind)

相当于 ndarray.sort （ self ， axis ， kind ）返回包含以下项的数组 self 排序沿 axis . 使用表示为的算法对数组进行排序。 kind ，它是指向所用排序算法类型的整数/枚举。

PyObject *PyArray_ArgSort(PyArrayObject *self, int axis)

相当于 ndarray.argsort （ self ， axis ）返回一个索引数组，以便沿着给定的 axis 将返回的排序版本 self .如果 self ->descr是定义了字段的数据类型，然后使用self->descr->name来确定排序顺序。第一个字段相等的比较将使用第二个字段，依此类推。要更改结构化数组的排序顺序，请使用不同的名称顺序创建新的数据类型，并使用该新数据类型构造数组的视图。

PyObject *PyArray_LexSort(PyObject *sort_keys, int axis)

给定数组序列（ sort_keys ）对于相同形状，返回一个索引数组（类似于 PyArray_ArgSort （…））将按字典顺序对数组排序。字典排序指定当发现两个键相等时，顺序基于后续键的比较。需要为这些类型定义合并排序（使相等的条目保持不变）。排序是通过首先使用第一个索引对索引进行排序来完成的。 sort_key 然后用第二个 sort_key 诸如此类。这相当于lexsort（ sort_keys ， axis ）python命令。由于合并排序的工作方式，请务必了解 sort_keys 必须是in（与比较两个元素时使用的顺序相反）。

如果这些数组都是在结构化数组中收集的，那么 PyArray_Sort （…）还可以用于直接对数组进行排序。

PyObject *PyArray_SearchSorted(PyArrayObject *self, PyObject *values, NPY_SEARCHSIDE side, PyObject *perm)

相当于 ndarray.searchsorted （ self ， 价值观 ， side ， perm ）假设 self 是按升序排列的一维数组，则输出是与形状相同的索引数组 价值观 这样，如果元素 价值观 在索引前插入 self 会被保存。不检查自我是否按升序排列。

这个 side 参数指示返回的索引是否应为第一个合适位置的索引（如果 NPY_SEARCHLEFT ）或最后一个（如果 NPY_SEARCHRIGHT ）

这个 分拣机 参数，如果不是 NULL ，必须是长度与 self ，按升序排序。这通常是调用 PyArray_ArgSort （…）二进制搜索用于查找所需的插入点。

int PyArray_Partition(PyArrayObject *self, PyArrayObject *ktharray, int axis, NPY_SELECTKIND which)

相当于 ndarray.partition （ self ， K数组 ， axis ， kind ）对数组进行分区，以便索引元素的值 K数组 如果数组是完全排序的，并且将所有小于前面的第kth的元素和所有等于或大于第kth元素的元素放在第kth元素之后，那么它们将处于它们的位置。分区内所有元素的顺序未定义。如果 self ->descr是定义了字段的数据类型，然后使用self->descr->name来确定排序顺序。第一个字段相等的比较将使用第二个字段，依此类推。要更改结构化数组的排序顺序，请使用不同的名称顺序创建新的数据类型，并使用该新数据类型构造数组的视图。成功时返回零，失败时返回-1。

PyObject *PyArray_ArgPartition(PyArrayObject *op, PyArrayObject *ktharray, int axis, NPY_SELECTKIND which)

相当于 ndarray.argpartition （ self ， K数组 ， axis ， kind ）返回一个索引数组，以便沿着给定的 axis 将返回的分区版本 self .

PyObject *PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2)

相当于 ndarray.diagonal （ self ， 抵消 ， 第一轴 ， AXIS2 ）返回 抵消 二维数组的对角线由 第一轴 和 AXIS2 .

npy_intp PyArray_CountNonzero(PyArrayObject *self)

1.6 新版功能.

计算数组对象中非零元素的数目 self .

PyObject *PyArray_Nonzero(PyArrayObject *self)

相当于 ndarray.nonzero （ self ）返回选择元素的索引数组的元组。 self 这不是零。如果（ND= PyArray_NDIM （ self ））==1，则返回单个索引数组。索引数组具有数据类型 NPY_INTP . 如果返回元组（nd 1），则其长度为nd。

PyObject *PyArray_Compress(PyArrayObject *self, PyObject *condition, int axis, PyArrayObject *out)

相当于 ndarray.compress （ self ， 条件 ， axis ）返回元素 axis 对应于的元素 条件 那是真的。

计算

小技巧

传球 NPY_MAXDIMS 对于轴，以达到通过传入获得的相同效果 axis=None 在python中（将数组视为一维数组）。

注解

out参数指定放置结果的位置。如果out为空，则创建输出数组，否则输出将放入out，而out的大小和类型必须正确。即使out不为空，也始终返回对输出数组的新引用。例行程序的调用方有责任 Py_DECREF 如果不为空，则会出现内存泄漏。

PyObject *PyArray_ArgMax(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.argmax （ self ， axis ）返回的最大元素的索引 self 沿着 axis .

PyObject *PyArray_ArgMin(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.argmin （ self ， axis ）返回的最小元素的索引 self 沿着 axis .

PyObject *PyArray_Max(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.max （ self ， axis ）返回的最大元素 self 沿着给定的 axis . 当结果是单个元素时，返回numpy标量而不是ndarray。

PyObject *PyArray_Min(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.min （ self ， axis ）返回的最小元素 self 沿着给定的 axis . 当结果是单个元素时，返回numpy标量而不是ndarray。

PyObject *PyArray_Ptp(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.ptp （ self ， axis ）返回 self 沿着 axis 最小的元素 self 沿着 axis . 当结果是单个元素时，返回numpy标量而不是ndarray。

注解

rType参数指定应进行缩减的数据类型。如果数组的数据类型不足以处理输出，则这一点很重要。默认情况下，所有整数数据类型的大小至少与 NPY_LONG 对于“加”和“乘”ufuncs（构成mean、sum、cumsum、prod和cumprod函数的基础）。

PyObject *PyArray_Mean(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.mean （ self ， axis ， R型 ）返回给定元素的平均值 axis ，使用枚举类型 R型 作为要求和的数据类型。默认和行为是使用 NPY_NOTYPE 对于 R型 .

PyObject *PyArray_Trace(PyArrayObject *self, int offset, int axis1, int axis2, int rtype, PyArrayObject *out)

相当于 ndarray.trace （ self ， 抵消 ， 第一轴 ， AXIS2 ， R型 ）返回总和（使用 R型 作为总和的数据类型） 抵消 二维数组的对角元素由 第一轴 和 AXIS2 变量。正偏移选择主对角线上方的对角线。负偏移选择主对角线下方的对角线。

PyObject *PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max)

相当于 ndarray.clip （ self ， min ， max ）剪辑数组， self ，使值大于 max 固定到 max 值小于 min 固定到 min .

PyObject *PyArray_Conjugate(PyArrayObject *self)

相当于 ndarray.conjugate （ self ）返回的复共轭 self .如果 self 不是复杂数据类型，然后返回 self 参考文献。

PyObject *PyArray_Round(PyArrayObject *self, int decimals, PyArrayObject *out)

相当于 ndarray.round （ self ， 小数 ， out ）返回数组，元素四舍五入到最接近的小数点。小数点定义为 数字使之为负数 小数 使四舍五入到最接近的10's、100's等，如果out为 NULL ，然后创建输出数组，否则输出将放置在 out 必须是正确的大小和类型。

PyObject *PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.std （ self ， axis ， R型 ）使用数据返回标准偏差 axis 转换为数据类型 R型 .

PyObject *PyArray_Sum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.sum （ self ， axis ， R型 ）返回元素的一维矢量和 self 沿着 axis . 将数据转换为数据类型后执行求和 R型 .

PyObject *PyArray_CumSum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.cumsum （ self ， axis ， R型 ）返回元素的累积一维和 self 沿着 axis . 将数据转换为数据类型后执行求和 R型 .

PyObject *PyArray_Prod(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.prod （ self ， axis ， R型 ）返回元素的一维产品 self 沿着 axis . 将数据转换为数据类型后执行产品 R型 .

PyObject *PyArray_CumProd(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)

相当于 ndarray.cumprod （ self ， axis ， R型 ）返回元素的一维累积积 self 沿着 axis . 将数据转换为数据类型后执行产品 rtype .

PyObject *PyArray_All(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.all （ self ， axis ）为每个1-d子数组返回一个包含真元素的数组 self 由定义 axis 所有元素都是真的。

PyObject *PyArray_Any(PyArrayObject *self, int axis, PyArrayObject *out)

相当于 ndarray.any （ self ， axis ）为每个1-d子数组返回一个包含真元素的数组 self 由定义 axis 其中任何元素都是真的。

功能

数组函数

int PyArray_AsCArray(PyObject **op, void *ptr, npy_intp *dims, int nd, int typenum, int itemsize)

有时，将多维数组作为C样式的多维数组访问是有用的，这样算法就可以使用C's a实现。 [i] [j] [k] 语法。此例程返回一个指针， ptr ，它模拟这种C样式数组，用于1、2和3-D ndarrays。

参数

• op -- 任何python对象的地址。此python对象将替换为由最后两个参数指定的给定数据类型的等效、行为良好、C样式连续、ndarray。确保以这种方式窃取输入对象的引用是合理的。

• ptr -- a（ctype）的地址 * for 1-d, ctype* * for 2-d or ctype* ** for 3-d) variable where ctype is the equivalent C-type for the data type. On return, * ptr*可以作为一维、二维或三维数组寻址。

• dims -- 包含数组对象形状的输出数组。这个数组给出了将发生的任何循环的边界。

• nd -- 数组的维数（1、2或3）。

• typenum -- 数组的预期数据类型。

• itemsize -- 只有在以下情况下才需要此参数 铅字 表示灵活的数组。否则应该是0。

注解

对于二维和三维阵列，C型阵列的模拟尚未完成。例如，指针的模拟数组不能传递给需要特定、静态定义的二维和三维数组的子例程。要传递给需要这些类型输入的函数，必须静态定义所需的数组并复制数据。

int PyArray_Free(PyObject *op, void *ptr)

必须使用从返回的相同对象和内存位置调用 PyArray_AsCArray （…）此函数用于清除否则会泄漏的内存。

PyObject *PyArray_Concatenate(PyObject *obj, int axis)

将对象序列连接到 obj 一起沿着 axis 一个数组。如果维度或类型不兼容，则会引发错误。

PyObject *PyArray_InnerProduct(PyObject *obj1, PyObject *obj2)

计算的最后一个维度的积和 obj1 和 obj2 . 两个数组都不是共轭的。

PyObject *PyArray_MatrixProduct(PyObject *obj1, PyObject *obj)

计算的最后一个维度的积和 obj1 第二个到最后一个维度 obj2 . 对于二维数组，这是一个矩阵积。两个数组都不是共轭的。

PyObject *PyArray_MatrixProduct2(PyObject *obj1, PyObject *obj, PyArrayObject *out)

1.6 新版功能.

与pyarray的matrixproduct相同，但将结果存储在 out . 输出数组必须具有正确的形状、类型和C-连续，否则将引发异常。

PyObject *PyArray_EinsteinSum(char *subscripts, npy_intp nop, PyArrayObject **op_in, PyArray_Descr *dtype, NPY_ORDER order, NPY_CASTING casting, PyArrayObject *out)

1.6 新版功能.

对提供的数组操作数应用爱因斯坦求和约定，返回新数组或将结果放入 out . 中的字符串 下标 是以逗号分隔的索引字母列表。操作数在 nop 和 op_in 是包含这些操作数的数组。输出的数据类型可以强制 D型 ，输出顺序可以强制 秩序 (NPY_KEEPORDER 建议），以及何时 D型 已指定， 铸造 指示数据转换的允许程度。

见 einsum 函数获取更多详细信息。

PyObject *PyArray_CopyAndTranspose(PyObject *op)

一种专门的复制和转置函数，只适用于二维数组。返回的数组是 op .

PyObject *PyArray_Correlate(PyObject *op1, PyObject *op2, int mode)

计算一维数组的一维相关性 op1 和 op2 . 相关系数在每个输出点通过乘以 op1 换了个版本 op2 总结结果。由于移位，所需值超出了定义的范围 op1 和 op2 被解释为零。模式决定返回多少个移位：0-只返回不需要假定为零值的移位；1-返回与相同大小的对象 op1 ，2-返回所有可能的班次（任何重叠都可以接受）。

笔记

这并不能计算通常的相关性：如果op2大于op1，参数将被交换，并且不会对复杂数组采用共轭。有关常见的信号处理相关性，请参见pyarray_correlate2。

PyObject *PyArray_Correlate2(PyObject *op1, PyObject *op2, int mode)

pyarray_correlate的更新版本，它使用1d数组的常见相关定义。相关系数在每个输出点通过乘以 op1 换了个版本 op2 总结结果。由于移位，所需值超出了定义的范围 op1 和 op2 被解释为零。模式决定返回多少个移位：0-只返回不需要假定为零值的移位；1-返回与相同大小的对象 op1 ，2-返回所有可能的班次（任何重叠都可以接受）。

笔记

计算z如下：

z[k] = sum_n op1[n] * conj(op2[n+k])

PyObject *PyArray_Where(PyObject *condition, PyObject *x, PyObject *y)

如果两者 x 和 y 是 NULL ，然后返回 PyArray_Nonzero （ 条件 ）否则，两者兼而有之 x 和 y 必须给定并且返回的对象的形状为 条件 并具有以下元素 x 和 y 在哪里？ 条件 分别为真或假。

其他功能

npy_bool PyArray_CheckStrides(int elsize, int nd, npy_intp numbytes, npy_intp const *dims, npy_intp const *newstrides)

确定是否 新跨越 步幅数组是否与 nd -带形状的维度数组 dims 元素大小， 放大 . 这个 新跨越 检查数组，看按每个方向上提供的字节数跳转是否意味着跳转超过 数字字节 这是可用内存段的假定大小。如果 数字字节 为0，则为等效值 数字字节 计算假设 nd ， dims 和 放大 参考单段阵列。返回 NPY_TRUE 如果 新跨越 可以接受，否则返回 NPY_FALSE .

npy_intp PyArray_MultiplyList(npy_intp const *seq, int n)

int PyArray_MultiplyIntList(int const *seq, int n)

这两个例程都会使 n 长度数组， seq ，并返回结果。不执行溢出检查。

int PyArray_CompareLists(npy_intp const *l1, npy_intp const *l2, int n)

给出两个 n -整数的长度数组， l1 和 l2 ，如果列表相同，则返回1；否则，返回0。

具有对象语义的辅助数据

1.7.0 新版功能.

type NpyAuxData

当处理由其他数据类型（如结构数据类型）组成的更复杂的数据类型时，创建操作数据类型的内部循环需要携带额外的数据。numpy通过一个结构支持这个想法 NpyAuxData ，强制执行一些公约，以便能够做到这一点。

定义一个 NpyAuxData 类似于在C++中定义类，但是对象API必须手动跟踪，因为API位于C.中。这里是一个例子，该函数使用元素复印机函数作为元素加倍元素。

typedef struct {
    NpyAuxData base;
    ElementCopier_Func *func;
    NpyAuxData *funcdata;
} eldoubler_aux_data;

void free_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *d = (eldoubler_aux_data *)data;
    /* Free the memory owned by this auxdata */
    NPY_AUXDATA_FREE(d->funcdata);
    PyArray_free(d);
}

NpyAuxData *clone_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        return NULL;
    }

    /* Raw copy of all data */
    memcpy(ret, data, sizeof(eldoubler_aux_data));

    /* Fix up the owned auxdata so we have our own copy */
    ret->funcdata = NPY_AUXDATA_CLONE(ret->funcdata);
    if (ret->funcdata == NULL) {
        PyArray_free(ret);
        return NULL;
    }

    return (NpyAuxData *)ret;
}

NpyAuxData *create_element_doubler_aux_data(
                            ElementCopier_Func *func,
                            NpyAuxData *funcdata)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    memset(&ret, 0, sizeof(eldoubler_aux_data));
    ret->base->free = &free_element_doubler_aux_data;
    ret->base->clone = &clone_element_doubler_aux_data;
    ret->func = func;
    ret->funcdata = funcdata;

    return (NpyAuxData *)ret;
}

type NpyAuxData_FreeFunc

npyauxdata自由函数的函数指针类型。

type NpyAuxData_CloneFunc

npyauxdata克隆函数的函数指针类型。这些函数不应该将python异常设置为出错，因为它们可以从多线程上下文中调用。

void NPY_AUXDATA_FREE(NpyAuxData *auxdata)

如果auxdata为空，则适当调用auxdata的自由函数的宏将不执行任何操作。

NpyAuxData *NPY_AUXDATA_CLONE(NpyAuxData *auxdata)

一种宏，它适当地调用auxdata的clone函数，返回辅助数据的深度副本。

数组迭代器

从numpy1.6.0开始，这些数组迭代器将被新的数组迭代器取代， NpyIter .

数组迭代器是一种快速有效地访问N维数组元素的简单方法。截面 2 提供了关于这种在数组上循环的有用方法的更多描述和示例。

PyObject *PyArray_IterNew(PyObject *arr)

从数组返回数组迭代器对象， arr .这相当于 arr . flat . 数组迭代器对象使以C样式的连续方式循环N维非连续数组变得容易。

PyObject *PyArray_IterAllButAxis(PyObject *arr, int *axis)

返回一个数组迭代器，该迭代器将遍历除中提供的轴以外的所有轴。 *axis . 返回的迭代器不能与一起使用 PyArray_ITER_GOTO1D . 这个迭代器可以用来编写类似于ufuncs所做的事情，其中最大轴上的循环是由一个单独的子例程完成的。如果 *axis 则为负值 *axis 将设置为步幅最小的轴，该轴将被使用。

PyObject *PyArray_BroadcastToShape(PyObject *arr, npy_intp const *dimensions, int nd)

返回一个数组迭代器，该迭代器被广播以作为由提供的形状的数组进行迭代 尺寸 和 nd .

int PyArrayIter_Check(PyObject *op)

如果计算为真 op 是数组迭代器（或数组迭代器类型的子类的实例）。

void PyArray_ITER_RESET(PyObject *iterator)

重置一个 迭代器 到数组的开头。

void PyArray_ITER_NEXT(PyObject *iterator)

增加的索引和dataptr成员 迭代器 指向数组的下一个元素。如果数组不是（C样式）连续的，也可以增加N维坐标数组。

void *PyArray_ITER_DATA(PyObject *iterator)

指向数组当前元素的指针。

void PyArray_ITER_GOTO(PyObject *iterator, npy_intp *destination)

设置 迭代器 索引、dataptr和将成员协调到n维c数组指示的数组中的位置， 目的地 ，其大小必须至少为 迭代器 -Nd1 M1+ 1。

void PyArray_ITER_GOTO1D(PyObject *iterator, npy_intp index)

设置 迭代器 索引和dataptr到整数指示的数组中的位置 指数 指向C样式扁平数组中的元素。

int PyArray_ITER_NOTDONE(PyObject *iterator)

只要迭代器没有循环遍历所有元素，则计算结果为true，否则计算结果为false。

广播（多迭代器）

PyObject *PyArray_MultiIterNew(int num, ...)

简化的广播接口。此函数获取要广播的数组数，然后 num 额外的（ PyObject * ）参数。这些参数转换为数组，并创建迭代器。 PyArray_Broadcast 然后对生成的多迭代器对象调用。然后返回生成的广播mult迭代器对象。然后可以使用单个循环执行广播操作，并使用 PyArray_MultiIter_NEXT （…）

void PyArray_MultiIter_RESET(PyObject *multi)

将所有迭代器重置为多迭代器对象的开头， 多种 .

void PyArray_MultiIter_NEXT(PyObject *multi)

在多迭代器对象中推进每个迭代器， 多种 到它的下一个（广播的）元素。

void *PyArray_MultiIter_DATA(PyObject *multi, int i)

返回的数据指针 i 多迭代器对象中的迭代器。

void PyArray_MultiIter_NEXTi(PyObject *multi, int i)

只向前移动指针 i 迭代器。

void PyArray_MultiIter_GOTO(PyObject *multi, npy_intp *destination)

在多迭代器对象中推进每个迭代器， 多种 ，给予 维的 目的地 在哪里？ 是广播数组中的维度数。

void PyArray_MultiIter_GOTO1D(PyObject *multi, npy_intp index)

在多迭代器对象中推进每个迭代器， 多种 ，到 指数 在平坦的广播阵列中。

int PyArray_MultiIter_NOTDONE(PyObject *multi)

只要多迭代器没有循环遍历所有元素（广播结果的），则计算结果为true，否则计算结果为false。

int PyArray_Broadcast(PyArrayMultiIterObject *mit)

此函数封装广播规则。这个 mit 容器应该已经包含所有需要广播的数组的迭代器。返回时，将调整这些迭代器，以便同时对每个迭代器进行迭代以完成广播。如果发生错误，则返回负数。

int PyArray_RemoveSmallest(PyArrayMultiIterObject *mit)

此函数采用以前“广播”过的多迭代器对象，在广播结果中查找具有最小“步幅总和”的维度，并调整所有迭代器，以便不在该维度上迭代（有效地使它们在该维度中的长度为1）。返回相应的维度，除非 mit ->nd为0，则返回-1。此函数可用于构建类UFUNC的例程，这些例程正确地广播其输入，然后将该例程的跨步一维版本作为内部循环调用。这个1-D版本通常针对速度进行了优化，因此应该在不需要大跨步跳跃的轴上执行循环。

邻域迭代器

1.4.0 新版功能.

邻域迭代器是迭代器对象的子类，可以用于对点的邻域进行迭代。例如，您可能希望迭代三维图像的每个体素，对于每个这样的体素，迭代超立方体。邻域迭代器自动处理边界，因此比起手动边界处理，这种代码编写起来要容易得多，开销很小。

PyObject *PyArray_NeighborhoodIterNew(PyArrayIterObject *iter, npy_intp bounds, int mode, PyArrayObject *fill_value)

此函数从现有迭代器创建新的邻域迭代器。邻域将相对于当前所指的位置进行计算。 iter ，边界定义邻域迭代器的形状，模式参数定义边界处理模式。

这个 界限 参数应为（2 * iter->ao->nd) arrays, such as the range bound[2* I~>界 [2*i+1] 定义尺寸I的行走范围（两个边界都包含在行走坐标中）。边界应为每个维度（边界）排序 [2*i] <界限> [2*i+1] ）

模式应为：

NPY_NEIGHBORHOOD_ITER_ZERO_PADDING

零填充。外部边界值将为0。

NPY_NEIGHBORHOOD_ITER_ONE_PADDING

一个填充，外部边界值将为1。

NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING

不断填充。外部边界值将与fillu值中的第一项相同。

NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING

后视镜衬垫。外部边界值将如同镜像了数组项一样。例如，对于数组 [1, 2, 3，4] ，X [-2] 将是2，X [-2] 将是1，X [4] 将是4，X [5] 将是1等…

NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING

圆形填充。外部边界值将与数组重复一样。例如，对于数组 [1, 2, 3，4] ，X [-2] 将是3，X [-2] 将是4，X [4] 将是1，X [5] 将是2等…

如果模式是恒定填充 (NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING )，fillu value应指向保存填充值的数组对象（如果数组包含多个项，则第一项将是填充值）。对于其他情况，fillu值可能为空。

• 迭代器保存对ITER的引用

• 失败时返回空值（在这种情况下，ITER的引用计数没有更改）

• ITER本身可以是一个邻域迭代器：这对于自动边界处理很有用。

• 此函数返回的对象应该可以安全地用作普通迭代器

• 如果ITER的位置发生更改，则对Pyarryneghborhoditer_next的任何后续调用都是未定义的行为，必须调用Pyarryneghborhoditer_reset。

PyArrayIterObject *iter;
PyArrayNeighborhoodIterObject *neigh_iter;
iter = PyArray_IterNew(x);

/*For a 3x3 kernel */
bounds = {-1, 1, -1, 1};
neigh_iter = (PyArrayNeighborhoodIterObject*)PyArrayNeighborhoodIter_New(
     iter, bounds, NPY_NEIGHBORHOOD_ITER_ZERO_PADDING, NULL);

for(i = 0; i < iter->size; ++i) {
     for (j = 0; j < neigh_iter->size; ++j) {
             /* Walk around the item currently pointed by iter->dataptr */
             PyArrayNeighborhoodIter_Next(neigh_iter);
     }

     /* Move to the next point of iter */
     PyArrayIter_Next(iter);
     PyArrayNeighborhoodIter_Reset(neigh_iter);
}

int PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject *iter)

将迭代器位置重置为邻域的第一个点。当Pyarray_neighborhooditerobject中给出的iter参数更改时，应该调用此函数（参见示例）

int PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject *iter)

在这个调用之后，iter->dataptr指向邻居的下一个点。在访问了邻居的每个点之后调用此函数是未定义的。

数组标量

PyObject *PyArray_Return(PyArrayObject *arr)

此函数窃取对 arr .

此函数检查是否 arr 是一个0维数组，如果是，则返回相应的数组标量。它应该在0维数组可以返回到Python时使用。

PyObject *PyArray_Scalar(void *data, PyArray_Descr *dtype, PyObject *itemsize)

返回给定枚举的数组标量对象 铅字 和 项目尺寸 通过 复印 从记忆指向 data .如果 swap 如果不为零，则此函数将根据数据类型对数据进行字节交换，因为数组标量始终处于正确的机器字节顺序中。

PyObject *PyArray_ToScalar(void *data, PyArrayObject *arr)

返回数组对象所指示类型和项大小的数组标量对象 arr 从指向的内存复制 data 如果数据在 arr 不是机器字节顺序。

PyObject *PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)

返回由以下项确定的类型的0维数组 外码 从 标量 它应该是数组标量对象。如果 外码 为空，则类型由 标量 .

void PyArray_ScalarAsCtype(PyObject *scalar, void *ctypeptr)

返回 小辫子 指向数组标量中实际值的指针。没有错误检查，所以 标量 必须是数组标量对象，并且ctyptpr必须有足够的空间来容纳正确的类型。对于灵活大小的类型，将指向数据的指针复制到 小辫子 对于所有其他类型，实际数据将复制到 小辫子 .

void PyArray_CastScalarToCtype(PyObject *scalar, void *ctypeptr, PyArray_Descr *outcode)

返回数据（强制转换为 外码 ）从数组标量， 标量 在记忆中被指向 小辫子 （必须足够大以处理传入内存）。

PyObject *PyArray_TypeObjectFromType(int type)

从类型号返回标量类型对象， type . 相当于 PyArray_DescrFromType （ type ）->类型obj，除了参考计数和错误检查。成功时返回对typeobject的新引用，或者 NULL 失败论。

NPY_SCALARKIND PyArray_ScalarKind(int typenum, PyArrayObject **arr)

查看功能 PyArray_MinScalarType 对于numpy 1.6.0中引入的替代机制。

返回由表示的标量类型 铅字 以及阵列 *arr （如果 arr 不是 NULL ）假定数组为0级，并且仅在以下情况下使用 铅字 表示有符号整数。如果 arr 不是 NULL 第一个元素是负的，然后 NPY_INTNEG_SCALAR 被退回，否则 NPY_INTPOS_SCALAR 已返回。返回值中的可能值 NPY_SCALARKIND .

int PyArray_CanCoerceScalar(char thistype, char neededtype, NPY_SCALARKIND scalar)

查看功能 PyArray_ResultType 有关numpy类型提升的详细信息，请在numpy 1.6.0中更新。

实现标量强制的规则。只有当此函数返回非零时，才会静默地将scalar从thistype强制为needededtype。如果标量是 NPY_NOSCALAR ，则此函数等于 PyArray_CanCastSafely . 规则是相同类型的标量可以强制转换为相同类型的数组。这条规则意味着高精度的标量永远不会导致同一类的低精度数组被向上转换。

数据类型描述符

警告

必须对数据类型对象进行引用计数，因此请注意不同C-API调用的数据类型引用上的操作。标准规则是，当返回数据类型对象时，它是一个新的引用。功能 PyArray_Descr* 对象和返回数组会窃取对其输入的数据类型的引用，除非另有说明。因此，必须拥有对任何用作此类函数输入的数据类型对象的引用。

int PyArray_DescrCheck(PyObject *obj)

如果 obj 是数据类型对象（ PyArray_Descr* ）

PyArray_Descr *PyArray_DescrNew(PyArray_Descr *obj)

返回从中复制的新数据类型对象 obj （字段引用刚刚更新，以便新对象指向相同的字段字典（如果有）。

PyArray_Descr *PyArray_DescrNewFromType(int typenum)

从由指示的内置（或用户注册）数据类型创建新的数据类型对象 铅字 . 所有内置类型不应更改任何字段。这将创建 PyArray_Descr 结构，以便您可以根据需要填充它。对于需要具有新ELSIZE成员才能在数组构造中有意义的灵活数据类型，尤其需要此函数。

PyArray_Descr *PyArray_DescrNewByteorder(PyArray_Descr *obj, char newendian)

根据 纽芬兰人的 . 所有引用的数据类型对象（在subdescr和数据类型对象的成员字段中）也会发生更改（递归）。

价值 纽芬兰人的 是以下宏之一：

NPY_IGNORE

NPY_SWAP

NPY_NATIVE

NPY_LITTLE

NPY_BIG

如果一个字节顺序 NPY_IGNORE 遇到它时，它是单独存在的。如果讷文典是 NPY_SWAP ，然后交换所有字节顺序。其他有效的newendian值为 NPY_NATIVE ， NPY_LITTLE 和 NPY_BIG 这都会导致返回的数据类型描述符（及其引用的所有数据类型描述符）具有相应的字节顺序。

PyArray_Descr *PyArray_DescrFromObject(PyObject *op, PyArray_Descr *mintype)

从对象中确定适当的数据类型对象 op （应该是“嵌套”序列对象）和最小数据类型描述符mintype（可以是 NULL ）与数组的行为相似（ op .Dype。不要将此函数与 PyArray_DescrConverter . 此函数主要查看（嵌套）序列中的所有对象，并根据找到的元素确定数据类型。

PyArray_Descr *PyArray_DescrFromScalar(PyObject *scalar)

从数组标量对象返回数据类型对象。不进行检查以确保 标量 是数组标量。如果无法确定合适的数据类型，则 NPY_OBJECT 默认情况下返回。

PyArray_Descr *PyArray_DescrFromType(int typenum)

返回对应于 铅字 . 这个 铅字 可以是枚举类型之一、枚举类型之一的字符代码或用户定义的类型。如果要使用灵活的大小数组，则需要 flexible typenum 并设置结果 elsize 所需大小的参数。typenum是 NPY_TYPES .

int PyArray_DescrConverter(PyObject *obj, PyArray_Descr **dtype)

转换任何兼容的python对象， obj ，到中的数据类型对象 D型 . 大量的python对象可以转换为数据类型对象。见 数据类型对象 (dtype ） 完整的描述。此版本的转换器将无对象转换为 NPY_DEFAULT_TYPE 数据类型对象。此函数可与中的“o&”字符代码一起使用。 PyArg_ParseTuple 处理。

int PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **dtype)

转换任何兼容的python对象， obj ，到中的数据类型对象 D型 . 此版本的转换器不转换任何对象，因此返回的数据类型为 NULL . 此函数还可以与pyarg_parsetuple处理中的“o&”字符一起使用。

int Pyarray_DescrAlignConverter(PyObject *obj, PyArray_Descr **dtype)

喜欢 PyArray_DescrConverter 但它会像编译器那样在单词边界上对齐类似C结构的对象。

int Pyarray_DescrAlignConverter2(PyObject *obj, PyArray_Descr **dtype)

喜欢 PyArray_DescrConverter2 但它会像编译器那样在单词边界上对齐类似C结构的对象。

PyObject *PyArray_FieldNames(PyObject *dict)

拿着菲尔兹字典， dict ，例如附加到数据类型对象的字段名，并构造字段名的有序列表，例如存储在 PyArray_Descr 对象。

转换实用程序

供使用 PyArg_ParseTuple

所有这些功能都可以用于 PyArg_ParseTuple （…）使用“o&”格式说明符自动将任何Python对象转换为所需的C对象。所有这些函数都返回 NPY_SUCCEED 如果成功，并且 NPY_FAIL 如果不是。所有这些函数的第一个参数都是一个Python对象。第二个论点是 地址 将python对象转换为的C类型。

警告

在使用这些转换函数时，一定要了解应该采取哪些步骤来管理内存。这些函数可能需要释放内存和/或根据您的使用更改特定对象的引用计数。

int PyArray_Converter(PyObject *obj, PyObject **address)

将任何python对象转换为 PyArrayObject .如果 PyArray_Check （ obj ）为true，则其引用计数递增，并将引用放入 地址 .如果 obj 不是数组，然后使用 PyArray_FromAny . 无论返回什么，都必须在 地址 当你完成了它。

int PyArray_OutputConverter(PyObject *obj, PyArrayObject **address)

这是给函数的输出数组的默认转换器。如果 obj 是 Py_None 或 NULL 然后 *address 将 NULL 但这一呼吁会成功。如果 PyArray_Check （ obj ）如果为真，则返回 *address 不增加其引用计数。

int PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)

转换任何python序列， obj 小于 NPY_MAXDIMS C数组 npy_intp . python对象也可以是单个数字。这个 seq 变量是指向具有成员ptr和len的结构的指针。成功返回后， seq ->ptr包含指向内存的指针，必须通过调用 PyDimMem_FREE ，以避免内存泄漏。对内存大小的限制使得这个转换器可以方便地用于将序列解释为数组形状。

int PyArray_BufferConverter(PyObject *obj, PyArray_Chunk *buf)

转换任何python对象， obj ，通过一个（单段）缓冲区接口连接到一个变量，该变量的成员详细说明了对象对其内存块的使用。这个 buf 变量是指向具有base、ptr、len和flags成员的结构的指针。这个 PyArray_Chunk 结构与python的buffer对象是二进制兼容的（通过32位平台上的len成员和64位平台或python 2.5上的ptr成员）。返回时，基础成员设置为 obj （或者它的基础如果 obj 已经是指向另一个对象的缓冲区对象）。如果需要保留内存，请确保增加基成员。内存块被指向 buf ->ptr成员并具有长度 buf -LeN。旗的成员 buf 是 NPY_ARRAY_ALIGNED 与 NPY_ARRAY_WRITEABLE 标志设置为 obj 具有可写缓冲区接口。

int PyArray_AxisConverter(PyObject *obj, int *axis)

转换python对象， obj ，将轴参数表示为传递给接受整数轴的函数的适当值。具体来说，如果 obj 没有， axis 设置为 NPY_MAXDIMS 它由采用axis参数的C-API函数正确解释。

int PyArray_BoolConverter(PyObject *obj, npy_bool *value)

转换任何python对象， obj ，至 NPY_TRUE 或 NPY_FALSE ，并将结果放入 价值 .

int PyArray_ByteorderConverter(PyObject *obj, char *endian)

将python字符串转换为相应的字节顺序字符：“>”、“<”、“s”、“=”或“”。

int PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sort)

将python字符串转换为 NPY_QUICKSORT （以“q”或“q”开头） NPY_HEAPSORT （以“h”或“h”开头） NPY_MERGESORT （以“m”或“m”开头）或 NPY_STABLESORT （以“t”或“t”开头）。 NPY_MERGESORT 和 NPY_STABLESORT 为向后兼容而互相别名，并且可以根据数据类型引用几种稳定排序算法中的一种。

int PyArray_SearchsideConverter(PyObject *obj, NPY_SEARCHSIDE *side)

将python字符串转换为 NPY_SEARCHLEFT （以“l”或“l”开头），或 NPY_SEARCHRIGHT （以“r”或“r”开头）。

int PyArray_OrderConverter(PyObject *obj, NPY_ORDER *order)

将python字符串“c”、“f”、“a”和“k”转换为 NPY_ORDER 枚举 NPY_CORDER ， NPY_FORTRANORDER ， NPY_ANYORDER 和 NPY_KEEPORDER .

int PyArray_CastingConverter(PyObject *obj, NPY_CASTING *casting)

将python字符串'no'、'equiv'、'safe'、'same_kind'和'unsafe'转换为 NPY_CASTING 枚举 NPY_NO_CASTING ， NPY_EQUIV_CASTING ， NPY_SAFE_CASTING ， NPY_SAME_KIND_CASTING 和 NPY_UNSAFE_CASTING .

int PyArray_ClipmodeConverter(PyObject *object, NPY_CLIPMODE *val)

将python字符串“clip”、“wrap”和“raise”转换为 NPY_CLIPMODE 枚举 NPY_CLIP ， NPY_WRAP 和 NPY_RAISE .

int PyArray_ConvertClipmodeSequence(PyObject *object, NPY_CLIPMODE *modes, int n)

将clipmodes序列或单个clipmode转换为 NPY_CLIPMODE 价值观。clipmodes的数目 n 在调用此函数之前必须是已知的。此函数用于帮助函数允许为每个维度使用不同的剪辑模式。

其他转换

int PyArray_PyIntAsInt(PyObject *op)

将各种python对象（包括数组和数组标量）转换为标准整数。出错时返回-1并设置异常。您可能会发现宏很有用：

#define error_converting(x) (((x) == -1) && PyErr_Occurred())

npy_intp PyArray_PyIntAsIntp(PyObject *op)

将各种python对象（包括数组和数组标量）转换为（平台指针大小）整数。出错时返回-1并设置异常。

int PyArray_IntpFromSequence(PyObject *seq, npy_intp *vals, int maxvals)

将传入的任何python序列（或单个python编号）转换为 seq 到（到） 麦克瓦尔斯 指针大小的整数并将它们放在 vals 数组。序列可以更小 麦克瓦尔斯 返回已转换对象的数目。

int PyArray_TypestrConvert(int itemsize, int gentype)

转换字符串字符（使用 项目尺寸 ）到基本的枚举数据类型。识别和转换与有符号和无符号整数、浮点数和复杂浮点数相对应的字符串。返回gentype的其他值。此函数可用于将字符串“f4”转换为 NPY_FLOAT32 .

其他

导入API

为了利用来自另一个扩展模块的C-API， import_array 必须调用函数。如果扩展模块独立于一个.c文件中，那么这就是需要完成的全部工作。但是，如果扩展模块涉及多个需要C-API的文件，那么必须采取一些额外的步骤。

void import_array(void)

必须在将使用C-API的模块的初始化部分调用此函数。它导入存储函数指针表的模块，并将正确的变量指向该模块。

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRAY

使用这些定义，您可以在多个文件中为单个扩展模块使用C-API。在每个文件中，必须定义 PY_ARRAY_UNIQUE_SYMBOL 保存C-API的某个名称（ e.g. myextension_数组_api）。必须这样做 之前 包括numpy/arrayobject.h文件。在您调用的模块初始化例程中 import_array . 此外，在没有模块初始化子程序定义的文件中 NO_IMPORT_ARRAY 包括numpy/arrayobject.h.之前

假设我有两个文件coolmodule.c和coolhelper.c，它们需要编译并链接到一个扩展模块中。假设coolmodule.c包含所需的initcool模块初始化函数（调用了import_array（）函数）。然后，coolmodule.c将在顶部：

#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

另一方面，CoolHelper.c将在顶部包含：

#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

您还可以将公共的最后两行放入扩展本地头文件中，只要确保在包含该文件之前没有定义任何_Import_数组。

在内部，这些定义的工作如下：

• 如果两者都没有定义，则将C-API声明为 static void** ，因此它只在编译单元中可见，其中包含numpy/arrayObject.h。

• 如果 PY_ARRAY_UNIQUE_SYMBOL 定义了，但是 NO_IMPORT_ARRAY 不是，C-API声明为 void** ，以便其他编译单元也可以看到它。

• 如果 NO_IMPORT_ARRAY 定义，无论是否 PY_ARRAY_UNIQUE_SYMBOL 是，C-API声明为 extern void** ，因此应该在另一个编译单元中定义它。

• 无论何时 PY_ARRAY_UNIQUE_SYMBOL 定义后，它还会更改保存C-API的变量的名称，默认为 PyArray_API ，无论宏定义为什么。

检查API版本

因为在大多数平台上，Python扩展的使用方式与通常的库不同，所以在构建时甚至运行时都无法自动检测到某些错误。例如，如果使用仅适用于numpy>=1.3.0的函数构建扩展，并且稍后使用numpy 1.2导入扩展，则不会出现导入错误（但调用函数时几乎肯定会出现分段错误）。这就是为什么提供了几个函数来检查numpy版本。宏指令 NPY_VERSION 和 NPY_FEATURE_VERSION 对应于用于构建扩展的numpy版本，而函数返回的版本 PyArray_GetNDArrayCVersion 和 PyArray_GetNDArrayCFeatureVersion 对应于运行时numpy的版本。

ABI和API兼容性规则总结如下：

• 无论何时 NPY_VERSION ！= PyArray_GetNDArrayCVersion() ，必须重新编译扩展（ABI不兼容）。

• NPY_VERSION = PyArray_GetNDArrayCVersion() 和 NPY_FEATURE_VERSION <= PyArray_GetNDArrayCFeatureVersion() 表示向后兼容的更改。

ABI不兼容会在每个numpy的版本中自动检测到。numpy1.4.0增加了API不兼容检测。如果您想用一个扩展二进制文件支持多个不同的numpy版本，就必须用最低的 NPY_FEATURE_VERSION 尽可能的。

NPY_VERSION

ndarray对象的当前版本（检查是否定义了此变量以保证 numpy/arrayobject.h 正在使用标头）。

NPY_FEATURE_VERSION

C-API的当前版本。

unsigned int PyArray_GetNDArrayCVersion(void)

这只是返回值 NPY_VERSION . NPY_VERSION 每当ABI级别发生向后不兼容的更改时都会进行更改。但是，因为它在C-API中，所以将该函数的输出与当前头中定义的值进行比较可以测试C-API是否发生了更改，从而需要重新编译使用C-API的扩展模块。这将自动签入函数 import_array .

unsigned int PyArray_GetNDArrayCFeatureVersion(void)

1.4.0 新版功能.

这只是返回值 NPY_FEATURE_VERSION . NPY_FEATURE_VERSION 每当API更改时（例如，添加函数）都会更改。更改的值并不总是需要重新编译。

内部灵活性

int PyArray_SetNumericOps(PyObject *dict)

numpy存储了一个python可调用对象的内部表，这些对象用于实现数组的算术运算以及某些数组计算方法。此函数允许用户用自己的版本替换这些python对象中的任何或所有对象。字典的键， dict ，是要替换的命名函数，成对的值是要使用的python可调用对象。应注意，用于替换内部数组操作的函数本身不会回调该内部数组操作（除非您已经设计了处理该操作的函数），否则会导致未经检查的无限递归（可能导致程序崩溃）。表示可以替换的操作的键名是：

add ， 减去 ， 乘 ， 分 ， 余数 ， 权力 ， 广场 ， 倒数 ， ones_like ， sqrt ， **** ， 积极的 ， 绝对的 ， 使转化 ， left_shift ， right_shift ， bitwise_and ， bitwise_xor ， bitwise_or ， less ， less_equal ， 平等的 ， not_equal ， 更大的 ， greater_equal ， floor_divide ， true_divide ， logical_or ， logical_and ， 地板 ， ceil ， 最大限度 ， 最低限度 ， rint .

这里包括这些函数，因为它们在数组对象的方法中至少使用过一次。如果要分配的对象之一不可调用，则函数返回-1（不设置python错误）。

1.16 版后已移除.

PyObject *PyArray_GetNumericOps(void)

返回包含存储在内部算术运算表中的可调用python对象的python字典。本词典的关键字在解释中给出。 PyArray_SetNumericOps .

1.16 版后已移除.

void PyArray_SetStringFunction(PyObject *op, int repr)

此函数允许您将数组对象的tp_str和tp_repr方法更改为任何python函数。因此，当从python调用str（arr）或repr（arr）时，可以更改所有数组的情况。要调用的函数作为 op .如果 repr 为非零，则将响应repr（arr）调用此函数，否则将响应str（arr）调用此函数。不检查是否 op 是否执行可调用。可调用的传入到 op 应为数组参数，并应返回要打印的字符串。

内存管理

char *PyDataMem_NEW(size_t nbytes)

void PyDataMem_FREE(char *ptr)

char *PyDataMem_RENEW(void *ptr, size_t newbytes)

用于分配、释放和重新分配内存的宏。这些宏在内部用于创建数组。

npy_intp *PyDimMem_NEW(int nd)

void PyDimMem_FREE(char *ptr)

npy_intp *PyDimMem_RENEW(void *ptr, size_t newnd)

用于分配、释放和重新分配维度和跨步内存的宏。

void *PyArray_malloc(size_t nbytes)

void PyArray_free(void *ptr)

void *PyArray_realloc(npy_intp *ptr, size_t nbytes)

这些宏使用不同的内存分配器，具体取决于常量 NPY_USE_PYMEM . 系统malloc在以下情况下使用： NPY_USE_PYMEM 是0，如果 NPY_USE_PYMEM 为1，则使用python内存分配器。

NPY_USE_PYMEM

int PyArray_ResolveWritebackIfCopy(PyArrayObject *obj)

如果 obj.flags 有 NPY_ARRAY_WRITEBACKIFCOPY 或（弃用） NPY_ARRAY_UPDATEIFCOPY ，此函数清除标志， DECREF S obj->base 使其可写，并设置 obj->base 无效。然后复制 obj->data 到 obj->base->data ，并返回复制操作的错误状态。这与 PyArray_SetWritebackIfCopyBase . 通常这是当你完成 obj ，就在之前 Py_DECREF(obj) . 可以多次调用，也可以使用 NULL 输入。也见 PyArray_DiscardWritebackIfCopy .

如果未执行任何操作，则返回0；如果发生错误，则返回1；如果执行了操作，则返回1。

穿线支架

这些宏只有在 NPY_ALLOW_THREADS 在编译扩展模块期间计算为true。否则，这些宏相当于空白。python为每个python进程使用一个全局解释器锁（gil），这样一次只能执行一个线程（甚至在多CPU机器上）。当调用一个可能需要时间来计算的已编译函数（并且对于其他线程（如更新的全局变量）没有副作用）时，应该释放gil，以便其他python线程可以在执行耗时计算时运行。这可以使用两组宏来完成。通常，如果在代码块中使用一个组中的宏，则所有宏都必须在同一代码块中使用。目前， NPY_ALLOW_THREADS 定义为python定义的 WITH_THREADS 常量，除非环境变量 NPY_NOSMP 在这种情况下设置 NPY_ALLOW_THREADS 定义为0。

NPY_ALLOW_THREADS

WITH_THREADS

第1组

此组用于调用可能需要一些时间但不使用任何Python C-API调用的代码。因此，应在计算期间释放gil。

NPY_BEGIN_ALLOW_THREADS

相当于 Py_BEGIN_ALLOW_THREADS 除了使用 NPY_ALLOW_THREADS 确定宏是否替换为空白。

NPY_END_ALLOW_THREADS

相当于 Py_END_ALLOW_THREADS 除了使用 NPY_ALLOW_THREADS 确定宏是否替换为空白。

NPY_BEGIN_THREADS_DEF

放入变量声明区域。此宏设置存储python状态所需的变量。

NPY_BEGIN_THREADS

放在不需要python解释器的代码前面（不需要python C-api调用）。此宏保存python状态并释放gil。

NPY_END_THREADS

放在不需要Python解释器的代码之后。此宏获取gil并从保存的变量恢复python状态。

void NPY_BEGIN_THREADS_DESCR(PyArray_Descr *dtype)

只有当 D型 不包含在循环执行期间可能需要Python解释器的任意Python对象。

void NPY_END_THREADS_DESCR(PyArray_Descr *dtype)

在使用该宏的开始形式释放gil的情况下，可以重新获得gil。

void NPY_BEGIN_THREADS_THRESHOLDED(int loop_size)

只有当 loop_size 超过了当前设置为500的最小阈值。应与 NPY_END_THREADS 夺回金边。

第2组

这个组用于在发布python gil之后重新获取它。例如，假设已经释放了gil（使用前面的调用），然后代码中的某个路径（可能在另一个子例程中）需要使用python c-api，那么这些宏对于获取gil很有用。这些宏基本上完成了前三个宏的相反操作（获取锁，保存它的状态），然后用保存的状态重新释放它。

NPY_ALLOW_C_API_DEF

放置在变量声明区域以设置必要的变量。

NPY_ALLOW_C_API

放在需要调用python c-api的代码之前（当知道gil已经发布时）。

NPY_DISABLE_C_API

放在需要调用python c-api（以重新发布gil）的代码之后。

小技巧

在线程支持宏后不要使用分号。

优先

NPY_PRIORITY

数组的默认优先级。

NPY_SUBTYPE_PRIORITY

默认子类型优先级。

NPY_SCALAR_PRIORITY

默认标量优先级（非常小）

double PyArray_GetPriority(PyObject *obj, double def)

返回 __array_priority__ 的属性（转换为double） obj 或 def 如果不存在该名称的属性。为类型为的对象提供了避免属性查找的快速返回 PyArray_Type .

默认缓冲区

NPY_BUFSIZE

用户可设置的内部缓冲区的默认大小。

NPY_MIN_BUFSIZE

用户可设置的内部缓冲区的最小大小。

NPY_MAX_BUFSIZE

用户可设置缓冲区允许的最大大小。

其他常数

NPY_NUM_FLOATTYPE

浮点类型的数目

NPY_MAXDIMS

数组中允许的最大维度数。

NPY_MAXARGS

函数中可以使用的最大数组参数数。

NPY_FALSE

定义为0，用于bool。

NPY_TRUE

定义为1，用于bool。

NPY_FAIL

使用中的“o&”语法调用的失败转换器函数的返回值 PyArg_ParseTuple -像函数一样。

NPY_SUCCEED

使用中的“o&”语法调用的成功转换器函数的返回值。 PyArg_ParseTuple -像函数一样。

其他宏

int PyArray_SAMESHAPE(PyArrayObject *a1, PyArrayObject *a2)

如果数组的值为true a1 和 a2 形状相同。

PyArray_MAX(a, b)

返回最大值 a 和 b . 如果（ a （或） b ）是两次计算的表达式。

PyArray_MIN(a, b)

返回的最小值 a 和 b . 如果（ a （或） b ）是两次计算的表达式。

PyArray_CLT(a, b)

PyArray_CGT(a, b)

PyArray_CLE(a, b)

PyArray_CGE(a, b)

PyArray_CEQ(a, b)

PyArray_CNE(a, b)

使用Numpy对字典式排序的定义来实现两个复数（带有实数和imag成员的结构）之间的复杂比较：先比较实数部分，然后在实数部分相等的情况下比较复数部分。

npy_intp PyArray_REFCOUNT(PyObject *op)

返回任何python对象的引用计数。

void PyArray_DiscardWritebackIfCopy(PyObject *obj)

如果 obj.flags 有 NPY_ARRAY_WRITEBACKIFCOPY 或（弃用） NPY_ARRAY_UPDATEIFCOPY ，此函数清除标志， DECREF S obj->base 使其可写，并设置 obj->base 无效。与…对比 PyArray_DiscardWritebackIfCopy 它不会试图从 obj->base 这个撤销 PyArray_SetWritebackIfCopyBase . 通常，当您完成 obj ，就在之前 Py_DECREF(obj) . 可以多次调用，也可以使用 NULL 输入。

void PyArray_XDECREF_ERR(PyObject *obj)

1.14中已弃用，使用 PyArray_DiscardWritebackIfCopy 然后 Py_XDECREF

decref是一个数组对象，它可能具有（已弃用） NPY_ARRAY_UPDATEIFCOPY 或 NPY_ARRAY_WRITEBACKIFCOPY 在不导致内容复制回原始数组的情况下设置的标志。重置 NPY_ARRAY_WRITEABLE 基对象上的标志。这对于使用写回语义时从错误条件中恢复很有用，但会导致错误的结果。

枚举类型

enum NPY_SORTKIND

一种特殊的变量类型，可以采用不同的值来表示所使用的排序算法。

enumerator NPY_QUICKSORT

enumerator NPY_HEAPSORT

enumerator NPY_MERGESORT

enumerator NPY_STABLESORT

用作的别名 NPY_MERGESORT 维卡也一样。

enumerator NPY_NSORTS

定义为排序数。由于需要向后兼容性，它被固定为3，因此 NPY_MERGESORT 和 NPY_STABLESORT 是彼此的别名，可以根据数据类型引用几种稳定排序算法中的一种。

enum NPY_SCALARKIND

一种特殊的变量类型，指示在确定标量强制规则时区分的标量“种类”的数量。此变量可以采用以下值：

enumerator NPY_NOSCALAR

enumerator NPY_BOOL_SCALAR

enumerator NPY_INTPOS_SCALAR

enumerator NPY_INTNEG_SCALAR

enumerator NPY_FLOAT_SCALAR

enumerator NPY_COMPLEX_SCALAR

enumerator NPY_OBJECT_SCALAR

enumerator NPY_NSCALARKINDS

定义为标量类型的数量（不包括 NPY_NOSCALAR ）

enum NPY_ORDER

指示数组应在其中解释的元素顺序的枚举类型。创建新数组时，通常仅 NPY_CORDER 和 NPY_FORTRANORDER 使用，但是当提供一个或多个输入时，订单可以基于它们。

enumerator NPY_ANYORDER

如果所有输入都是FORTRAN，则为FORTRAN顺序，否则为C。

enumerator NPY_CORDER

C级。

enumerator NPY_FORTRANORDER

FORTRAN指令。

enumerator NPY_KEEPORDER

一种尽可能接近输入顺序的顺序，即使输入既不是C顺序也不是FORTRAN顺序。

enum NPY_CLIPMODE

一种变量类型，指示应在某些函数中应用的剪切类型。

enumerator NPY_RAISE

大多数操作的默认值在索引超出界限时引发异常。

enumerator NPY_CLIP

如果索引超出界限，则将其剪辑到有效范围。

enumerator NPY_WRAP

如果索引超出界限，则将其包装到有效范围。

enum NPY_SEARCHSIDE

一种变量类型，指示返回的索引是否应该是第一个合适位置的索引（如果 NPY_SEARCHLEFT ）或最后一个（如果 NPY_SEARCHRIGHT ）

enumerator NPY_SEARCHLEFT

enumerator NPY_SEARCHRIGHT

enum NPY_SELECTKIND

表示所用选择算法的变量类型。

enumerator NPY_INTROSELECT

enum NPY_CASTING

1.6 新版功能.

指示允许数据转换方式的枚举类型。这是由numpy 1.6中添加的迭代器使用的，并打算在将来的版本中更广泛地使用。

enumerator NPY_NO_CASTING

只允许相同的类型。

enumerator NPY_EQUIV_CASTING

允许相同和涉及字节交换的强制转换。

enumerator NPY_SAFE_CASTING

仅允许不导致值被舍入、截断或以其他方式更改的强制转换。

enumerator NPY_SAME_KIND_CASTING

允许任何安全的强制转换，并在相同类型之间强制转换。例如，此规则允许使用float64->float32。

enumerator NPY_UNSAFE_CASTING

允许任何强制转换，无论发生何种数据丢失。

数据类型API 数组迭代器API