Array API

Data access

这些函数和宏提供容易访问ndarray的元素从C。这些工作对所有数组。你可能需要在访问数组中的数据时注意，但是，如果它不是机器字节顺序，未对齐或不可写。换句话说，一定要尊重标志的状态，除非你知道你在做什么，或者以前保证一个数组是可写，对齐的，并且使用PyArray_FromAny以机器字节顺序。如果你希望处理所有类型的数组，每种类型的copyswap函数对于处理不当数组是有用的。一些平台（例如Solaris）不喜欢错位的数据，如果你解引用一个未对齐的指针，会崩溃。其他平台（例如x86 Linux）只会在未对齐数据时工作速度较慢。

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

在由c阵列ind给出的N维索引处返回指向ndarray的数据的指针aobj（其必须至少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的数据类型。

From scratch

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

此函数窃取对descr的引用。

这是主要的数组创建功能。最新的数组是用这个灵活的函数创建的。

返回的对象是Python类型子类型的对象，它必须是PyArray_Type的子类型。数组具有nd维度，由dims描述。新数组的数据类型描述符为descr。

如果子类型是数组子类而不是基本&PyArray_Type，则obj是要传递到__array_finalize__

如果data为NULL，则将分配新的内存，并且标志可以为非零，以指示Fortran风格的连续数组。如果数据不是NULL，则假定指向要用于数组的存储器，并且使用标志参数作为数组的新标志（除了新数组的NPY_OWNDATA和NPY_ARRAY_UPDATEIFCOPY标志的状态将被复位）。

另外，如果数据是非NULL，则也可以提供步幅。If strides is NULL, then the array strides are computed as C-style contiguous (default) or Fortran-style contiguous (flags is nonzero for data = NULL or flags & NPY_ARRAY_F_CONTIGUOUS is nonzero non-NULL data). 任何提供的dims和strides都会复制到新分配的维度中，并且新建数组的数组。

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

版本1.6中的新功能。

如果它不为NULL，此函数将窃取对descr的引用。

此数组创建例程允许方便地创建与现有数组的形状和存储器布局匹配的新数组，可能改变布局和/或数据类型。

当订单是NPY_ANYORDER时，结果顺序为NPY_FORTRANORDER if if prototype is fortran数组，NPY_CORDER当命令为NPY_KEEPORDER时，结果顺序与原型匹配，即使原型在C或Fortran顺序。

如果descr为NULL，则使用原型的数据类型。

如果subok为1，则新创建的数组将使用原型的子类型创建新数组，否则将创建基类数组。

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

这类似于PyArray_DescrNew（...），除非你用type_num和itemsize指定数据类型描述符，其中type_num 对应于内置（或用户定义）类型。如果类型总是具有相同的字节数，则忽略itemsize。否则，itemsize指定此数组的特定大小。

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

创建类型为typenum的新未初始化数组，其每个和维中的大小由整数数组dims给出。此函数不能用于创建一个灵活类型的数组（没有给定itemize）。

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

在给定指针指向的数据周围创建一个数组包装。数组标志将具有默认值，即数据区域运行良好并且C型连续。数组的形状由长度nd的dims c-数组给出。数组的数据类型由typenum指示。

PyObject* PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, PyArray_Descr* descr)

如果它不为NULL，此函数将窃取对descr的引用。

使用提供的数据类型描述符descr创建由nd和dims确定的形状的新数组。

PyArray_FILLWBYTE(PyObject* obj, int val)

填充由obj指向的数组 - 它必须是bigndarray的子​​类，其中val（作为字节计算）。这个宏调用memset，所以obj必须是连续的。

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

使用由dims给出的形状和由dtype给出的数据类型构造新的nd -dimensional数组。如果fortran不为零，则创建Fortran顺序数组，否则创建C顺序数组。用零填充存储器（如果dtype对应于NPY_OBJECT，则为0对象）。

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

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

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

使用由dims给出的形状和由dtype给出的数据类型构造新的nd -dimensional数组。如果fortran不为零，则创建Fortran顺序数组，否则创建C顺序数组。数组未初始化，除非数据类型对应于NPY_OBJECT，在这种情况下数组用Py_None填充。

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

PyArray_Empty的宏形式，它采用类型号，typenum而不是数据类型对象。

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

Construct a new 1-dimensional array of data-type, typenum, that ranges from start to stop (exclusive) in increments of step . 等同于arange（开始，停止，步骤，dtype）。

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

构建由descr确定的数据类型的新的1维数组，范围从start到stop（排除），增量为step。等于arange（start，stop，step，typenum）。

int PyArray_SetBaseObject(PyArrayObject* arr, PyObject* obj)

版本1.7中的新功能。

此函数将引用挪到obj，并将其设置为arr的基本属性。

如果你通过传入你自己的内存缓冲区作为参数来构造一个数组，你需要设置数组的base属性，以确保内存缓冲区的生命周期是合适的。

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

如果提供的对象是数组，则此函数遍历base指针链，以使每个数组直接指向内存所有者。一旦基本设置，它可能不会更改为另一个值。

From other objects

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

这是用于从任何嵌套序列或暴露数组接口op的对象获取数组的主函数。The parameters allow specification of the required dtype, the minimum (min_depth) and maximum (max_depth) number of dimensions acceptable, and other requirements for the array. dtype参数需要是指示所需数据类型（包括所需的字节序）的PyArray_Descr结构。dtype参数可以为NULL，表示任​​何数据类型（和字节序）都是可以接受的。除非flags中存在FORCECAST，如果无法从对象安全获取数据类型，则此调用将生成错误。如果你想对dtype使用NULL，并确保数组没有被切换，请使用PyArray_CheckFromAny。任何深度参数的值为0将导致该参数被忽略。可以添加以下任何数组标志（例如使用|）以获取需求参数。如果您的代码可以处理一般（例如 stride，字节交换或未对齐的数组），则要求可能为0。此外，如果op不是数组（或不公开数组接口），则将创建一个新数组（并使用序列协议从op填充） 。新数组将具有NPY_DEFAULT作为其标志成员。上下文参数被传递给op的__array__方法，并且仅当数组以这种方式构造时才使用。几乎总是此参数为NULL。

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

NPY_ARRAY_C_CONTIGUOUS

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

NPY_ARRAY_F_CONTIGUOUS

NPY_ARRAY_ALIGNED

确保返回的数组在其数据类型的正确边界上对齐。对齐数组具有数据指针和每个步幅因子作为数据类型描述符的对准因子的倍数。

NPY_ARRAY_WRITEABLE

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

NPY_ARRAY_ENSURECOPY

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

NPY_ARRAY_ENSUREARRAY

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

NPY_ARRAY_FORCECAST

强制转换为输出类型，即使它不能安全地完成。没有这个标志，只有当它可以安全地进行时，才会发生数据转换，否则会引发错误。

NPY_ARRAY_UPDATEIFCOPY

如果op已经是一个数组，但不满足要求，那么将进行一个副本（这将满足要求）。如果此标志存在并且必须创建一个（已经是数组的对象的）副本，则在返回的副本中设置相应的NPY_ARRAY_UPDATEIFCOPY标志，并且op为设为只读。当返回的副本被删除时（可能是在计算完成后），其内容将被复制回op，并且op数组将再次可写。如果op无法写入，则会引发错误。如果op不是数组，则此标志无效。

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_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_UPDATEIFCOPY

NPY_ARRAY_INOUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | 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)

版本1.6中的新功能。

检索用于查看/将任意PyObject *转换为NumPy数组的数组参数。这允许发现Python列表列表的“先天类型和形状”，而无需实际转换为数组。PyArray_FromAny调用此函数来分析其输入。

在某些情况下，例如结构化数组和__array__接口，需要使用数据类型来理解对象。当需要时，为'requested_dtype'提供一个Descr，否则提供NULL。此引用不会被窃取。此外，如果请求的dtype不修改输入的解释，out_dtype仍将获得对象的“先天”dtype，而不是在'requested_dtype'中传递的dtype。

如果需要写入“op”中的值，请将布尔值“writeable”设置为1。当'op'是标量，列表列表或其他不可写入的'op'时，会出现错误。这不同于将NPY_ARRAY_WRITEABLE传递到PyArray_FromAny，其中可写数组可以是输入的副本。

当返回成功（返回值为0）时，out_arr将填充一个非空的PyArrayObject，其余的参数保持不变，或out_arr填充为NULL，其余的参数将被填充。

典型用途：

PyArrayObject *arr = NULL;
PyArray_Descr *dtype = NULL;
int ndim = 0;
npy_intp dims[NPY_MAXDIMS];

if (PyArray_GetArrayParamsFromObject(op, NULL, 1, &dtype,
                                    &ndim, &dims, &arr, NULL) < 0) {
    return NULL;
}
if (arr == NULL) {
    ... validate/change dtype, validate flags, ndim, etc ...
    // Could make custom strides here too
    arr = PyArray_NewFromDescr(&PyArray_Type, dtype, ndim,
                                dims, NULL,
                                fortran ? NPY_ARRAY_F_CONTIGUOUS : 0,
                                NULL);
    if (arr == NULL) {
        return NULL;
    }
    if (PyArray_CopyObject(arr, op) < 0) {
        Py_DECREF(arr);
        return NULL;
    }
}
else {
    ... in this case the other parameters weren't filled, just
        validate and possibly copy arr itself ...
}
... use arr ...

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

几乎与PyArray_FromAny（...）除了要求可以包含NPY_ARRAY_NOTSWAPPED（覆盖dtype ）和NPY_ARRAY_ELEMENTSTRIDES，表示数组应该对齐，因为步长是元素大小的倍数。

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

NPY_ARRAY_NOTSWAPPED

确保返回的数组具有按机器字节顺序的数据类型描述符，超越了dtype参数中的任何规范。通常，字节顺序要求由dtype参数决定。如果这个标志被设置，并且dtype参数不指示机器字节顺序描述符（或者是NULL，并且该对象已经是具有不是机器字节顺序的数据类型描述符的数组），则新的数据 - 类型描述符被创建并使用，其字节顺序字段设置为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)

Special case of PyArray_FromAny for when op is already an array but it needs to be of a specific newtype (including byte-order) or has certain requirements.

PyObject* PyArray_FromStructInterface(PyObject* op)

从公开了__array_struct__属性并遵循数组接口协议的Python对象返回一个ndarray对象。如果对象不包含此属性，则返回对Py_NotImplemented的借用引用。

PyObject* PyArray_FromInterface(PyObject* op)

从暴露数组接口协议后的__array_interface__属性的Python对象返回一个ndarray对象。如果对象不包含此属性，则返回对Py_NotImplemented的借用引用。

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

从暴露了__array__方法的Python对象返回一个ndarray对象。__array__方法可以取0,1或2个参数（[dtype，context]），其中上下文用于传递有关__array__

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

此函数从枚举的typenum指定的（非灵活）类型的任何嵌套序列或数组接口导出对象op返回（C样式） t1>，最小深度min_depth和最大深度max_depth。等效于对PyArray_FromAny的调用，其要求设置为NPY_DEFAULT，类型参数的type_num成员设置为typenum。

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

从枚举类型给定的类型的任何嵌套序列或数组接口导出对象op返回对齐的和本地字节序数组。数组可以具有的最小维数由min_depth给出，而最大值为max_depth。这等同于对需求设置为BEHAVED的PyArray_FromAny的调用。

PyObject* PyArray_EnsureArray(PyObject* op)

此函数将引用挪到op，并确保op是基类的ndarray。它是特殊情况的数组标量，但是否则调用PyArray_FromAny（op，NULL，0，0，NPY_ARRAY_ENSUREARRAY）。

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

从长度为slen的二进制或（ASCII）文本string构造单一类型的一维数组。要创建的数组的数据类型由dtype给出。如果num是-1，则复制整个字符串并返回一个适当大小的数组，否则num是要复制字符串。If sep is NULL (or “”), then interpret the string as bytes of binary data, otherwise convert the sub-strings separated by sep to items of data-type dtype. 某些数据类型在文本模式下可能无法读取，如果发生错误，则会出现错误。所有错误返回NULL。

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

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

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

从导出（单段）缓冲区协议（或具有返回导出缓冲区协议的对象的__buffer__属性）的对象buf构造单个类型的一维数组。首先尝试可写缓冲区，然后尝试只读缓冲区。返回的数组的NPY_ARRAY_WRITEABLE标志将反映哪个成功。The data is assumed to start at offset bytes from the start of the memory location for the object. 缓冲区中的数据类型将根据数据类型描述符dtype.如果count为负，那么将根据缓冲区的大小和所请求的itemsize来确定，否则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转换为ndarray。参数可以是导出数组接口的任何嵌套序列或对象。这是PyArray_FromAny的宏形式，使用NULL，0,0,0作为其他参数。您的代码必须能够处理任何数据类型描述符和任何data-flags的组合，以使用此宏。

PyObject* PyArray_FROM_OF(PyObject* obj, int requirements)

类似于PyArray_FROM_O，但它可以接受要求的参数，指示生成的数组必须具有的属性。Available requirements that can be enforced are NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_ALIGNED, NPY_ARRAY_WRITEABLE, NPY_ARRAY_NOTSWAPPED, NPY_ARRAY_ENSURECOPY, NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_FORCECAST, and NPY_ARRAY_ENSUREARRAY. 还可以使用标志的标准组合：

PyObject* PyArray_FROM_OT(PyObject* obj, int typenum)

类似于PyArray_FROM_O，除了它可以接受typenum的参数，指定返回的数组的类型号。

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

组合PyArray_FROM_OF和PyArray_FROM_OT，允许提供typenum和标志参数。

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

类似于PyArray_FromAny，除了使用类型号指定数据类型。PyArray_DescrFromType（typenum）直接传递到PyArray_FromAny。如果NPY_ARRAY_ENSURECOPY作为需求传递，此宏还将NPY_DEFAULT添加到要求中。

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

封装具有axis =关键字的函数和方法的功能，并且以None作为轴参数正常工作。输入数组是obj，而*axis是一个转换的整数（因此> = MAXDIMS是None值），requirements需要的属性obj。输出是输入的转换版本，以满足要求，并且如果需要，发生平坦化。对*axis的输出负值进行转换，并检查新值以确保与obj的形状一致。

General check of Python Type

PyArray_Check(op)

如果op是类型为PyArray_Type的子类型的Python对象，则计算true。

PyArray_CheckExact(op)

如果op是类型为PyArray_Type的Python对象，则计算true。

PyArray_HasArrayInterface(op, out)

如果op实现数组接口的任何部分，则out将包含对使用接口或out NULL如果在转换期间发生错误。否则，out将包含对Py_NotImplemented的借用引用，并且未设置错误条件。

PyArray_HasArrayInterfaceType(op, type, context, out)

如果op实现数组接口的任何部分，则out将包含对使用接口或out NULL如果在转换期间发生错误。否则，out将包含对Py_NotImplemented的借用引用，并且不设置错误条件。此版本允许在查找__array__属性的数组接口部分中设置类型和上下文。

PyArray_IsZeroDim(op)

如果op是PyArray_Type（的子类）的实例并且具有0个维度，则计算true。

PyArray_IsScalar(op, cls)

如果op是Py{cls}ArrType_Type的实例，则计算true。

PyArray_CheckScalar(op)

如果op是数组标量（PyGenericArr_Type的子类型的实例）或PyArray_Type

PyArray_IsPythonNumber(op)

如果op是内置数值类型的实例（int，float，complex，long，bool）

PyArray_IsPythonScalar(op)

如果op是内置的Python标量对象（int，float，complex，str，unicode，long，bool），则计算true。

PyArray_IsAnyScalar(op)

如果op是Python标量对象（请参阅PyArray_IsPythonScalar）或数组标量（PyGenericArr_Type的子类型的实例） 。

PyArray_CheckAnyScalar(op)

如果op是Python标量对象（参见PyArray_IsPythonScalar），即数组标量（PyGenericArr_Type的子类型的实例），其维度为0的PyArray_Type的子类型的实例。

Data-type checking

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

PyTypeNum_ISUNSIGNED(num)

PyDataType_ISUNSIGNED(descr)

PyArray_ISUNSIGNED(obj)

类型表示无符号整数。

PyTypeNum_ISSIGNED(num)

PyDataType_ISSIGNED(descr)

PyArray_ISSIGNED(obj)

类型表示有符号整数。

PyTypeNum_ISINTEGER(num)

PyDataType_ISINTEGER(descr)

PyArray_ISINTEGER(obj)

类型表示任何整数。

PyTypeNum_ISFLOAT(num)

PyDataType_ISFLOAT(descr)

PyArray_ISFLOAT(obj)

类型表示任何浮点数。

PyTypeNum_ISCOMPLEX(num)

PyDataType_ISCOMPLEX(descr)

PyArray_ISCOMPLEX(obj)

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

PyTypeNum_ISNUMBER(num)

PyDataType_ISNUMBER(descr)

PyArray_ISNUMBER(obj)

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

PyTypeNum_ISSTRING(num)

PyDataType_ISSTRING(descr)

PyArray_ISSTRING(obj)

Type表示字符串数据类型。

PyTypeNum_ISPYTHON(num)

PyDataType_ISPYTHON(descr)

PyArray_ISPYTHON(obj)

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

PyTypeNum_ISFLEXIBLE(num)

PyDataType_ISFLEXIBLE(descr)

PyArray_ISFLEXIBLE(obj)

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

PyTypeNum_ISUSERDEF(num)

PyDataType_ISUSERDEF(descr)

PyArray_ISUSERDEF(obj)

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

PyTypeNum_ISEXTENDED(num)

PyDataType_ISEXTENDED(descr)

PyArray_ISEXTENDED(obj)

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

PyTypeNum_ISOBJECT(num)

PyDataType_ISOBJECT(descr)

PyArray_ISOBJECT(obj)

类型表示对象数据类型。

PyTypeNum_ISBOOL(num)

PyDataType_ISBOOL(descr)

PyArray_ISBOOL(obj)

类型表示布尔数据类型。

PyDataType_HASFIELDS(descr)

PyArray_HASFIELDS(obj)

类型具有与其相关联的字段。

PyArray_ISNOTSWAPPED(m)

根据数组的数据类型描述符，如果ndarray m的数据区域是机器字节顺序，则评估为真。

PyArray_ISBYTESWAPPED(m)

根据数组的数据类型描述符，如果机器字节顺序中ndarray m的数据区不是，则判断为真。

Bool PyArray_EquivTypes(PyArray_Descr* type1, PyArray_Descr* type2)

返回NPY_TRUE如果type1和type2实际上代表此平台的等效类型（每个类型的fortran成员被忽略）。例如，在32位平台上，NPY_LONG和NPY_INT是等效的。否则返回NPY_FALSE。

Bool PyArray_EquivArrTypes(PyArrayObject* a1, PyArrayObject * a2)

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

Bool PyArray_EquivTypenums(int typenum1, int typenum2)

PyArray_EquivTypes（...）的特殊情况，它不接受灵活的数据类型，但可能更容易调用。

int PyArray_EquivByteorders({byteorder} b1, {byteorder} b2)

如果字节顺序字符（NPY_LITTLE，NPY_BIG，NPY_NATIVE，NPY_IGNORE）等于或等于其规格的本地字节顺序。因此，对于小端机器，NPY_LITTLE和NPY_NATIVE是等效的，它们在大端机器上不等效。

Converting data types

PyObject* PyArray_Cast(PyArrayObject* arr, int typenum)

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

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

返回指定的类型的新数组，适当地投射arr的元素。fortran参数指定输出数组的顺序。

int PyArray_CastTo(PyArrayObject* out, PyArrayObject* in)

从1.6开始，该函数只调用PyArray_CopyInto，它处理转换。

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

PyArray_VectorUnaryFunc* PyArray_GetCastFunc(PyArray_Descr* from, int totype)

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

int PyArray_CanCastSafely(int fromtype, int totype)

如果数据类型fromtype的数组可以转换为数据类型totype的数组，而不会丢失信息，则返回非零。一个例外是64位整数允许转换为64位浮点值，即使这样可能会丢失大整数的精度，以便在没有展开请求的情况下不增加使用长双精度。使用此功能，不会根据其长度检查灵活的数组类型。

int PyArray_CanCastTo(PyArray_Descr* fromtype, PyArray_Descr* totype)

PyArray_CanCastTypeTo在NumPy 1.6及更高版本中取代此函数。

相当于PyArray_CanCastTypeTo（fromtype，totype，NPY_SAFE_CASTING）。

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

版本1.6中的新功能。

如果数据类型fromtype（可以包括灵活类型）的数组可以安全地转换到数据类型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中的新功能。

如果arr可以根据投射中给出的投射规则投射到totype，则返回非零值。如果arr是数组标量，则会考虑其值，并且当值不会溢出或在转换为较小类型时被截断为整数时，也会返回非零。

这几乎与PyArray_CanCastTypeTo（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中的新功能。

查找type1和type2可以安全转换的最小尺寸和种类的数据类型。此函数是对称和关联的。字符串或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替代。

此函数用于确定两个或多个数组可以转换为的公共类型。它只适用于非灵活数组类型，因为没有传递项目信息。mintype参数表示可接受的最小类型，op表示将转换为数组的对象。返回值是表示op应该具有的数据类型的枚举类型号。

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

此函数由PyArray_ResultType替代。

此函数与PyArray_ObjectType（...）类似，除了它处理灵活数组。mintype参数可以有一个itemize成员，并且outtype参数将有一个itemsize成员至少与对象op 。

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

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

将op中包含的Python对象序列转换为每个都具有相同数据类型的ndarrays的数组。基于类型号（在较小的类型号上选择较大的类型号）选择类型，忽略只是标量的对象。序列的长度在n中返回，PyArrayObject指针的n长度数组是返回值（或NULL如果发生错误）。返回的数组必须由此例程的调用者（使用PyDataMem_FREE）和其中的所有数组对象（DECREF'd）释放，否则将发生内存泄漏。下面的示例模板代码显示了一个典型的用法：

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 - > itemsize的新创建的内存的指针，它保存该类型的表示形式。当不再需要时，使用PyDataMem_FREE（ret）必须释放返回的指针ret，

char* PyArray_One(PyArrayObject* arr)

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

int PyArray_ValidType(int typenum)

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

New data types

void PyArray_InitArrFuncs(PyArray_ArrFuncs* f)

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

int PyArray_RegisterDataType(PyArray_Descr* dtype)

将数据类型注册为数组的新用户定义数据类型。类型必须填充大多数条目。这不总是被检查，错误可以产生segfaults。特别地，dtype结构的typeobj成员必须用具有对应于dtype的elsize成员的固定大小的元素大小的Python类型填充。此外，f成员必须具有必需的函数：非零，copyswap，copyswapn，getitem，setitem和cast（如果不需要支持，某些转换函数可以是NULL ）。为了避免混淆，你应该选择一个唯一的字符类型，但这不是强制的，不是内部依赖。

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

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

注册低级别转换函数castfunc，将数据类型descr转换为给定的数据类型编号totype 。任何旧的铸造功能都被覆盖。成功时返回0或失败时返回-1。

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

从给定的标量类型的数据类型对象descr注册数据类型号totype使用标量 = NPY_NOSCALAR注册数据类型descr的数组可以安全地转换为type_number为totype。

Special functions for NPY_OBJECT

int PyArray_INCREF(PyArrayObject* op)

用于包含任何Python对象的数组op。它根据op的数据类型增加数组中每个对象的引用计数。如果发生错误，则返回-1，否则返回0。

void PyArray_Item_INCREF(char* ptr, PyArray_Descr* dtype)

根据数据类型dtype，在位置ptr处对所有对象进行INCREF的函数。如果ptr是具有任何偏移量的对象的结构化类型的开始，则这将（递归地）增加结构化类型中所有类似对象的项的引用计数。

int PyArray_XDECREF(PyArrayObject* op)

用于包含任何Python对象的数组op。它根据op的数据类型减少数组中每个对象的引用计数。正常返回值为0。如果发生错误，则返回-1。

void PyArray_Item_XDECREF(char* ptr, PyArray_Descr* dtype)

XDECREF函数用于记录数据类型dtype中位置ptr的所有类似对象的项目。这样递归地工作，以便如果dtype本身具有包含类似对象的项的数据类型的字段，则所有类似于对象的字段将是XDECREF 'd。

void PyArray_FillObjectArray(PyArrayObject* arr, PyObject* obj)

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

Basic Array Flags

一个ndarray可以有一个数据段，不是一个简单的连续块的良好的记忆你可以操纵。它可能不与字边界对齐（在某些平台上非常重要）。它可能具有不同于机器识别的字节顺序的数据。它可能不可写。它可能是Fortan连续的顺序。数组标志用于指示关于与数组相关联的数据的内容。

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

NPY_ARRAY_C_CONTIGUOUS

数据区以C样式连续顺序（最后索引变化最快）。

NPY_ARRAY_F_CONTIGUOUS

数据区域是Fortran风格的连续顺序（第一个索引变化最快）。

NPY_ARRAY_OWNDATA

数据区由此数组所有。

NPY_ARRAY_ALIGNED

数据区和所有数组元素都对齐。

NPY_ARRAY_WRITEABLE

数据区可以写入。

注意，上面的3个标志是定义的，所以一个新的，行为良好的数组有这些标志被定义为真。

NPY_ARRAY_UPDATEIFCOPY

数据区表示一个（行为良好的）副本，当删除此数组时，该副本的信息应该被传回原始。

这是一个特殊的标志，如果这个数组代表一个拷贝，因为用户需要在PyArray_FromAny中的某些标志，并且一个副本必须由其他数组组成（并且用户要求这个标志在这种情况下设置）。base属性然后指向“misbehaved”数组（设置为read_only）。当具有此标志集的数组被解除分配时，它将其内容复制回“错误的”数组（如果必要的话），并将“错误的”数组重置为NPY_ARRAY_WRITEABLE。如果“misbehaved”数组不是NPY_ARRAY_WRITEABLE开始，则PyArray_FromAny将返回错误，因为不能使用NPY_ARRAY_UPDATEIFCOPY。

PyArray_UpdateFlags (obj, flags) will update the obj->flags for flags which can be any of NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_ALIGNED, or NPY_ARRAY_WRITEABLE.

Combinations of array flags

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

Flag-like constants

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

NPY_ARRAY_FORCECAST

投射到所需类型，即使它不能在不丢失信息的情况下完成。

NPY_ARRAY_ENSURECOPY

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

NPY_ARRAY_ENSUREARRAY

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

NPY_ARRAY_NOTSWAPPED

仅在PyArray_CheckFromAny中用于覆盖传入的数据类型对象的字节顺序。

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

Flag checking

对于所有这些宏arr必须是PyArray_Type（的子类）的实例，但不进行检查。

PyArray_CHKFLAGS(arr, flags)

第一个参数arr必须是一个ndarray或子类。参数flags应为包含数组可能具有的标志的按位组合的整数：NPY_ARRAY_C_CONTIGUOUS，NPY_ARRAY_F_CONTIGUOUS，NPY_ARRAY_OWNDATA，NPY_ARRAY_ALIGNED，NPY_ARRAY_WRITEABLE，NPY_ARRAY_UPDATEIFCOPY。

PyArray_IS_C_CONTIGUOUS(arr)

如果arr是C样式连续，则计算true。

PyArray_IS_F_CONTIGUOUS(arr)

如果arr是Fortran风格连续，则计算true。

PyArray_ISFORTRAN(arr)

如果arr是Fortran风格连续且不是 C风格连续，则评估为true。PyArray_IS_F_CONTIGUOUS是测试Fortran风格邻接的正确方法。

PyArray_ISWRITEABLE(arr)

如果arr的数据区可以写入，则评估为true

PyArray_ISALIGNED(arr)

如果arr的数据区在机器上正确对齐，则评估为true。

PyArray_ISBEHAVED(arr)

如果arr的数据区域根据其描述符对齐和可写，并按机器字节顺序，则计算true。

PyArray_ISBEHAVED_RO(arr)

如果arr的数据区域以机器字节顺序对齐，则评估为true。

PyArray_ISCARRAY(arr)

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

PyArray_ISFARRAY(arr)

如果arr的数据区域是Fortran式连续且PyArray_ISBEHAVED（arr）为真，则评估为true。

PyArray_ISCARRAY_RO(arr)

如果arr的数据区是C样式连续，对齐和以机器字节顺序，则评估为true。

PyArray_ISFARRAY_RO(arr)

如果arr的数据区域是Fortran风格的连续，对齐，并且在机器字节顺序中，则评估为真。

PyArray_ISONESEGMENT(arr)

如果arr的数据区域由单个（C风格或Fortran风格）连续段组成，则评估为true。

void PyArray_UpdateFlags(PyArrayObject* arr, int flagmask)

可以从数组对象本身“计算”NPY_ARRAY_C_CONTIGUOUS，NPY_ARRAY_ALIGNED和NPY_ARRAY_F_CONTIGUOUS数组标志。此例程通过执行所需的计算，更新flagmask中指定的arr的一个或多个标志。

Conversion

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

等同于ndarray.getfield（self，dtype，offset）。使用当前数组中指定的偏移量中的数据（以字节为单位）返回给定dtype的新数组。偏移加上新数组类型的itemsize必须小于self - > descr-> elsize或出现错误。使用与原数组相同的形状和步幅。因此，此函数具有从结构化数组返回字段的效果。但是，它也可以用于从任何数组类型中选择特定字节或字节组。

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

等效于ndarray.setfield（self，val，dtype，offset）。Set the field starting at offset in bytes and of the given dtype to val. 偏移加上dtype - > elsize必须小于self - > descr-> elsize或出现错误。否则，val参数将转换为数组并复制到指向的字段中。如果需要，重复val的元素以填充目标数组。但是，目标中的元素数必须是val中元素数的整数倍数。 。

PyObject* PyArray_Byteswap(PyArrayObject* self, Bool inplace)

等效于ndarray.byteswap（self，inplace）。返回其数据区域已进行字节交换的数组。如果inplace为非零，则执行byteswap inplace并返回对self的引用。否则，创建字节交换副本并保持不变。

PyObject* PyArray_NewCopy(PyArrayObject* old, NPY_ORDER order)

等同于ndarray.copy（self，fortran）。制作旧数组的副本。返回的数组总是对齐和可写的，数据解释与旧数组相同。如果order是NPY_CORDER，则返回C风格的连续数组。如果order是NPY_FORTRANORDER，则返回Fortran风格的连续数组。如果顺序是 NPY_ANYORDER，则返回的数组是Fortran风格的连续的，如果旧的；否则，它是C型连续的。

PyObject* PyArray_ToList(PyArrayObject* self)

等效于ndarray.tolist（self）。从self返回嵌套的Python列表。

PyObject* PyArray_ToString(PyArrayObject* self, NPY_ORDER order)

等效于ndarray.tobytes（self，order）。在Python字符串中返回此数组的字节。

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

以C样式连续方式将self的内容写入文件指针fp。如果sep是字符串“”或NULL，则将数据写为二进制字节。否则，使用sep字符串作为项目分隔符，将self的内容作为文本写入。每个项目将打印到文件。如果格式字符串不是NULL或“”，那么它是一个Python打印语句格式字符串，显示如何写入项目。

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

将self中的对象拣到给定的文件（字符串或Python文件对象）。如果文件是Python字符串，它被认为是一个文件的名称，然后以二进制模式打开。使用给定的协议（如果协议为负值，或使用最高可用值）。这是cPickle.dump（self，文件，协议）的简单包装器。

PyObject* PyArray_Dumps(PyObject* self, int protocol)

将self中的对象转换为Python字符串并返回。使用提供的Pickle 协议（如果协议为负值，则为最高可用）。

int PyArray_FillWithScalar(PyArrayObject* arr, PyObject* obj)

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

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

等效于ndarray.view（self，dtype）。返回数组self的新视图可能是不同的数据类型，dtype和不同的数组子类ptype。

如果dtype是NULL，则返回的数组将具有与self相同的数据类型。新数据类型必须与self的大小一致。要么项目必须相同，要么self必须是单段，并且字节总数必须相同。在后一种情况下，返回的数组的维度将在最后一个（或第一个为Fortran风格的连续数组）维度中更改。返回的数组和self的数据区完全相同。

Shape Manipulation

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

结果将是一个新的数组（如果可能，指向与self相同的内存位置），但具有由newshape给出的形状。如果新形状与self的步幅不兼容，则将返回具有新指定形状的数组的副本。

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

等同于ndarray.reshape（self，shape）其中shape是一个序列。将形状转换为PyArray_Dims结构，并在内部调用PyArray_Newshape。对于向后兼容性 - 不推荐

PyObject* PyArray_Squeeze(PyArrayObject* self)

等同于ndarray.squeeze（self）。返回self的新视图，其中从形状中删除所有长度为1的维度。

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，newshape，refcheck = refcheck = fortran）。此功能仅适用于单段数组。它会改变self的形状，并且如果newshape具有与旧形状不同的元素总数，则会重新分配self的内存。If reallocation is necessary, then self must own its data, have self - >base==NULL, have self - >weakrefs==NULL, and (unless refcheck is 0) not be referenced by any other array. fortran参数可以是NPY_ANYORDER，NPY_CORDER或NPY_FORTRANORDER。它目前没有效果。最终，它可以用于确定在构造不同维度的数组时，调整大小操作应如何查看数据。成功时返回None，出错时返回NULL。

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

等同于ndarray.transpose（self，permute）。根据数据结构permute，允许ndarray对象的轴self并返回结果。如果permute是NULL，则结果数组的轴反转。例如，如果self具有形状，并且permute .ptr为（0,2,1），则结果的形状如果permute为NULL，则结果的形状为

PyObject* PyArray_Flatten(PyArrayObject* self, NPY_ORDER order)

等同于ndarray.flatten（self，order）。返回数组的1-d副本。如果order是NPY_FORTRANORDER，则以Fortran顺序扫描元素（第一维度的变化最快）。如果order是NPY_CORDER，则以C顺序扫描self的元素（最后一个维度变化最快）。如果order NPY_ANYORDER，则PyArray_ISFORTRAN（self）的结果用于确定要展平的顺序。

PyObject* PyArray_Ravel(PyArrayObject* self, NPY_ORDER order)

等同于self .ravel（order）。除了order为0和self之外，与PyArray_Flatten（self，order t6>是C型连续，形状改变，但不执行复制。

Item selection and manipulation

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

等于ndarray.take（self，索引，轴，ret通过在C中设置axis = NPY_MAXDIMS可以获得axis = None中的沿着给定的轴的整数值索引表示。clipmode参数可以是NPY_RAISE，NPY_WRAP或NPY_CLIP以指示如何处理超出索引。ret参数可以指定输出数组，而不是在内部创建。

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

等效于self .put（值，索引，clipmode）。将值置入self中相应的（扁平）索引。如果值太小，则会根据需要重复。

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

在掩码中的对应位置（使用展平的上下文）为真时，将值置于自中。掩码和自身数组必须具有相同的元素总数。如果值太小，则将根据需要重复。

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

等同于ndarray.repeat（self，op，axis）。沿给定的轴复制self，op的元素。op是标量整数或长度self - > dimension [axis]的序列，表示沿轴重复每个项目的次数。

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

等效于ndarray.choose（self，op，ret，clipmode）。基于self中的整数值，从op中的数组序列中选择元素，创建一个新的数组。数组必须都可以广播到相同的形状，self中的条目应该在0和len之间（op）。输出位于ret中，除非NULL，在这种情况下会创建新的输出。clipmode参数确定self中的条目不在0和len（op）之间的行为。

NPY_RAISE

提高ValueError；

NPY_WRAP

wrap values < 0 by adding len(op) and values >=len(op) by subtracting len(op) until they are in range;

NPY_CLIP

所有值都剪裁到区域[0，len（op））。

PyObject* PyArray_Sort(PyArrayObject* self, int axis)

等效于ndarray.sort（self，轴）。返回具有沿轴排序的self项目的数组。

PyObject* PyArray_ArgSort(PyArrayObject* self, int axis)

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

PyObject* PyArray_LexSort(PyObject* sort_keys, int axis)

给定一个相同形状的数组（sort_keys）序列，返回一个数组的索引（类似于PyArray_ArgSort（...）），它将按数组排序数组。词典式排序指定当发现两个键相等时，顺序基于随后的键的比较。需要为类型定义合并排序（保留相等的条目未移动）。通过使用第一个sort_key首先对索引排序，然后使用第二个sort_key等来完成排序。这相当于lexsort（sort_keys，axis）Python命令。由于合并排序的工作方式，请务必理解sort_keys必须在的顺序（与比较两个元素时使用的顺序相反）。

如果这些数组都在结构化数组中收集，则PyArray_Sort（...）也可以用于直接对数组进行排序。

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

等同于ndarray.searchsorted（self，值，侧，perm）。假设self是以升序排列的1-d数组，则输出是与值相同形状的索引的数组，使得如果值插入索引之前，将保留self的顺序。没有检查自我是否是升序。

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

分类器参数，如果不是NULL，必须是与self长度相同的整数索引的1D数组，将其按升序排序。这通常是调用PyArray_ArgSort（...）的结果。二进制搜索用于查找所需的插入点。

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

等效于ndarray.partition（self，ktharray，axis，kind）。对数组进行分区，使得ktharray索引的元素的值位于数组完全排序的位置，并且所有元素小于第k个之前，所有元素等于或大于第k个元素。分区内所有元素的排序未定义。如果self - > descr是定义了字段的数据类型，则使用自 - > descr->名称来确定排序顺序。第一个字段相等的比较将使用第二个字段，以此类推。要更改结构化数组的排序顺序，请创建具有不同名称顺序的新数据类型，并使用该新数据类型构建数组的视图。成功时返回零，失败时返回-1。

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

等同于ndarray.argpartition（self，ktharray，axis，kind）。返回一个索引数组，沿着给定的axis选择这些索引将返回self的分区版本。

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

等效于ndarray.diagonal（self，offset，axis1，axis2）。返回由axis1和axis2定义的2-d数组的偏移对角线。

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，条件，轴）。返回轴中对应于条件的元素为真的元素。

Calculation

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

等效于ndarray.argmax（self，axis）。返回self沿轴的最大元素的索引。

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

Equivalent to ndarray.argmin (self, axis). 返回self沿轴的最小元素的索引。

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

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

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

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

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

等同于ndarray.ptp（self，轴）。返回沿轴的self的最大元素与沿轴的self的最小元素之间的差值。当结果是单个元素时，返回numpy标量而不是ndarray。

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

等效于ndarray.mean（self，axis，rtype）。返回沿给定轴的元素的平均值，使用枚举类型rtype作为求和的数据类型。对于rtype，使用NPY_NOTYPE获取默认总和行为。

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

Equivalent to ndarray.trace (self, offset, axis1, axis2, rtype). Return the sum (using rtype as the data type of summation) over the offset diagonal elements of the 2-d arrays defined by axis1 and axis2 variables. 正偏移选择主对角线上方的对角线。负偏移选择主对角线下方的对角线。

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，100等。如果out是NULL，则创建输出数组，否则输出放置在out中，它必须是正确的大小和类型。

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

等效于ndarray.std（self，axis，rtype）。使用沿轴的数据返回标准偏差，转换为数据类型rtype。

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

等效于ndarray.sum（self，axis，rtype）。返回沿轴的self中的元素的1-d向量和。在将数据转换为数据类型rtype之后执行求和。

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

等效于ndarray.cumsum（self，axis，rtype）。返回沿轴的self中的元素的累积1-d总和。在将数据转换为数据类型rtype之后执行求和。

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

等同于ndarray.prod（self，axis，rtype）。沿轴返回self中的元素的1-d乘积。将数据转换为数据类型rtype后执行产品。

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

等效于ndarray.cumprod（self，axis，rtype）。沿axis返回self中元素的1-d累积积。将数据转换为数据类型rtype后执行产品。

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

等效于ndarray.all（self，axis）。对于由axis定义的self的每个1-d子数组，返回一个具有True元素的数组，其中所有元素都为True。

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

等效于ndarray.any（self，axis）。对于由轴定义的self的每个1-d子数组，返回一个具有True元素的数组，其中任何元素都为True。

Array Functions

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

有时，访问作为C风格多维数组的多维数组是有用的，使得可以使用C的a [i] [j] [k]语法来实现算法。这个例程返回一个指针，ptr，它模拟这种C风格的数组，用于1，2和3-d ndarrays。

参数：	op - 任何Python对象的地址。这个Python对象将被替换为由最后两个参数指定的给定数据类型的等效行为，C样式连续的ndarray。确保以这种方式将引用挪到输入对象是合理的。 ptr - 指向（c-type *为1-d，ctype **为2-d或ctype ***为3-d）变量的地址，其中ctype是数据的等效C类型类型。返回时，ptr将可寻址为1-d，2-d或3-d数组。 dims - 包含数组对象形状的输出数组。这个数组给出了将要发生的任何循环的边界。 nd - 数组的维数（1,2或3）。 typenum - 数组的预期数据类型。 itemsize - 仅当typenum表示灵活数组时，才需要此参数。否则应为0。

int PyArray_Free(PyObject* op, void* ptr)

必须使用从PyArray_AsCArray（...）返回的相同对象和内存位置进行调用。这个函数清理内存，否则会泄露。

PyObject* PyArray_Concatenate(PyObject* obj, int axis)

沿轴将obj中的对象序列合并到单个数组中。如果尺寸或类型不兼容，则会出现错误。

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

计算obj1和obj2的最后一个维度的乘积和。数组都未共轭。

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

计算obj1的最后一个维度和obj2的第二个到最后一个维度的乘积和。对于2-d数组，这是一个矩阵积。数组都未共轭。

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

版本1.6中的新功能。

与PyArray_MatrixProduct相同，但将结果存储在out中。

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是包含这些操作数的数组。The data type of the output can be forced with dtype, the output order can be forced with order (NPY_KEEPORDER is recommended), and when dtype is specified, casting indicates how permissive the data conversion should be.

有关详细信息，请参阅einsum功能。

PyObject* PyArray_CopyAndTranspose(PyObject * op)

仅适用于2-d数组的专用复制和转置函数。返回的数组是op的转置副本。

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

计算1-d数组op1和op2的1-d相关性。通过将op1乘以op2的移位版本并对结果求和，在每个输出点计算相关性。作为移位的结果，在op1和op2的定义范围之外的所需值被解释为零。The mode determines how many shifts to return: 0 - return only shifts that did not need to assume zero- values; 1 - return an object that is the same size as op1, 2 - return all possible shifts (any overlap at all is accepted).

笔记

这不计算通常的相关性：如果op2大于op1，则参数被交换，并且从不采用复数数组的共轭。对于通常的信号处理相关性，参见PyArray_Correlate2。

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

PyArray_Correlate的更新版本，它使用1d数组的相关性的通常定义。通过将op1乘以op2的移位版本并对结果求和，在每个输出点计算相关性。作为移位的结果，在op1和op2的定义范围之外的所需值被解释为零。模式决定了转移到返回：0 - 只返回并不需要承担零值的变化； 1 - 返回一个对象，它是大小 OP1 T0>，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（condition）。否则，必须给出x和y，并且返回的对象的形状类似于条件，并且元素为x和y其中条件分别为True或False。

Other functions

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

Determine if newstrides is a strides array consistent with the memory of an nd -dimensional array with shape dims and element-size, elsize. 检查newstrides数组以查看在每个方向上跳过所提供的字节数是否意味着跳过多于numbytes，这是可用存储器段的假定大小。If numbytes is 0, then an equivalent numbytes is computed assuming nd, dims, and elsize refer to a single-segment array. 如果newstrides是可接受的，则返回NPY_TRUE，否则返回NPY_FALSE。

npy_intp PyArray_MultiplyList(npy_intp* seq, int n)

int PyArray_MultiplyIntList(int* seq, int n)

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

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

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

For use with 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将其转换为数组。不管返回什么，当你完成后，你必须在address中DECREF这个例程返回的对象。

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

这是一个给函数的输出数组的默认转换器。如果obj为Py_None或NULL，则* address将为NULL调用就会成功。如果PyArray_Check（obj）为TRUE，则在* address中返回，而不增加其引用计数。

int PyArray_IntpConverter(PyObject* obj, PyArray_Dims* seq)

将小于NPY_MAXDIMS的任何Python序列obj转换为npy_intp的C数组。Python对象也可以是单个数字。seq变量​​是指向具有成员ptr和len的结构的指针。成功返回后，seq - > ptr包含指向必须释放的内存的指针，以避免内存泄漏。对存储器大小的限制允许该转换器方便地用于旨在被解释为数组形状的序列。

int PyArray_BufferConverter(PyObject* obj, PyArray_Chunk* buf)

使用（单段）缓冲区接口将任何Python对象obj转换为具有详细描述对象使用其内存块的成员的变量。buf变量​​是指向具有base，ptr，len和flags成员的结构的指针。PyArray_Chunk结构与Python的缓冲区对象是二进制兼容的（通过32位平台上的len成员和64位平台上的ptr成员或Python 2.5）。返回时，基本成员设置为obj（或者如果obj已经是指向另一个对象的缓冲对象，则其基本成员）。如果你需要保持内存，一定要INCREF基本成员。内存块由buf - > ptr member指向，并且长度为buf - > len。如果obj具有可写缓冲区接口，则buf的标志成员为NPY_BEHAVED_RO，并设置NPY_ARRAY_WRITEABLE标志。

int PyArray_AxisConverter(PyObject * obj, int* axis)

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

int PyArray_BoolConverter(PyObject* obj, Bool* value)

将任何Python对象obj转换为NPY_TRUE或NPY_FALSE，并将结果放在值中。

int PyArray_ByteorderConverter(PyObject* obj, char* endian)

将Python字符串转换为相应的字节顺序字符：'>'，

int PyArray_SortkindConverter(PyObject* obj, NPY_SORTKIND* sort)

将Python字符串转换为NPY_QUICKSORT（以“q”或“Q”开头），NPY_HEAPSORT（以“h”或“H”开头）或NPY_MERGESORT（以“m”或“M”开头）。

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)

Convert the Python strings ‘C’, ‘F’, ‘A’, and ‘K’ into the NPY_ORDER enumeration NPY_CORDER, NPY_FORTRANORDER, NPY_ANYORDER, and NPY_KEEPORDER.

int PyArray_CastingConverter(PyObject* obj, NPY_CASTING* casting)

Convert the Python strings ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, and ‘unsafe’ into the NPY_CASTING enumeration NPY_NO_CASTING, NPY_EQUIV_CASTING, NPY_SAFE_CASTING, NPY_SAME_KIND_CASTING, and 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)

将剪辑模式序列或单个剪辑模式转换为NPY_CLIPMODE值的C数组。在调用此函数之前，必须知道剪辑模式的数量n。提供此函数以帮助功能允许每个维度使用不同的剪辑模式。

Other conversions

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)

将以seq传递的任何Python序列（或单个Python号）转换为（最多）maxvals个指针大小的整数，并将它们放在vals t2 >数组。当返回转换对象的数量时，该序列可以小于maxvals。

int PyArray_TypestrConvert(int itemsize, int gentype)

将打字字符（itemize）转换为基本枚举数据类型。对应于有符号和无符号整数，浮点数和复数浮点数的typestring字符被识别和转换。返回gentype的其他值。此函数可用于将字符串'f4'转换为NPY_FLOAT32。

Importing the API

为了使用来自另一个扩展模块的C-API，必须使用import_array()命令。如果扩展模块是自包含在一个单一的.c文件，那就是所有需要做的。然而，如果扩展模块涉及需要C-API的多个文件，则必须采取一些额外的步骤。

void import_array(void)

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

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRAY

使用这些#defines你可以在单个扩展模块的多个文件中使用C-API。在每个文件中，您必须将PY_ARRAY_UNIQUE_SYMBOL定义为将保存C-API的某个名称（，例如 myextension_ARRAY_API）。这必须在之前完成，包括numpy / arrayobject.h文件。在模块初始化例程中，调用import_array()。此外，在没有模块初始化的文件中，sub_routine在包含numpy / arrayobject.h之前定义NO_IMPORT_ARRAY。

假设我有两个文件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

你也可以把普通的最后两行放入一个扩展本地头文件，只要你确保NO_IMPORT_ARRAY #define之前#include该文件。

Checking the API Version

因为在大多数平台上，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

在每个numpy的版本中自动检测ABI不兼容性。在numpy 1.4.0中添加了API不兼容性检测。如果你想支持许多不同的numpy版本与一个扩展二进制，你必须建立你的扩展与最低的NPY_FEATURE_VERSION尽可能。

unsigned int PyArray_GetNDArrayCVersion(void)

这只是返回值NPY_VERSION。每当ABI级别发生向后不兼容更改时，NPY_VERSION会更改。因为它在C-API中，然而，从当前标题中定义的值比较该函数的输出提供了一种方式来测试C-API是否已经改变，因此需要重新编译使用C-API的扩展模块-API。这将在函数import_array中自动检查。

unsigned int PyArray_GetNDArrayCFeatureVersion(void)

版本1.4.0中的新功能。

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

Internal Flexibility

int PyArray_SetNumericOps(PyObject* dict)

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

add, subtract, multiply, divide, remainder, power, square, reciprocal, ones_like, sqrt, negative, absolute, invert, left_shift, right_shift, bitwise_and, bitwise_xor, bitwise_or, less, less_equal, equal, not_equal, greater, greater_equal, floor_divide, true_divide, logical_or, logical_and, floor, ceil, maximum, minimum, rint.

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

PyObject* PyArray_GetNumericOps(void)

返回一个包含存储在内部算术运算表中的可调用Python对象的Python字典。此字典的键在PyArray_SetNumericOps的说明中给出。

void PyArray_SetStringFunction(PyObject* op, int repr)

此函数允许您将数组对象的tp_str和tp_repr方法更改为任何Python函数。因此，当str（arr）或repr（arr）从Python调用时，你可以改变对所有数组的发生。要调用的函数以op传入。如果repr不为零，则将响应repr（arr）调用此函数，否则将响应str（arr）调用函数。不执行是否可调用op的检查。传递给op的可调用应该有一个数组参数，并应返回要打印的字符串。

Memory management

char* PyDataMem_NEW(size_t nbytes)

PyDataMem_FREE(char* ptr)

char* PyDataMem_RENEW(void * ptr, size_t newbytes)

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

npy_intp* PyDimMem_NEW(nd)

PyDimMem_FREE(npy_intp* ptr)

npy_intp* PyDimMem_RENEW(npy_intp* ptr, npy_intp newnd)

宏分配，释放和重新分配维度和跨越内存。

PyArray_malloc(nbytes)

PyArray_free(ptr)

PyArray_realloc(ptr, nbytes)

这些宏使用不同的内存分配器，具体取决于常量NPY_USE_PYMEM。当NPY_USE_PYMEM为0时，如果NPY_USE_PYMEM为1，则使用系统malloc，然后使用Python内存分配器。

Threading support

这些宏仅在NPY_ALLOW_THREADS在编译扩展模块期间求值为True时才有意义。否则，这些宏等同于空格。Python为每个Python进程使用单个全局解释器锁（GIL），因此一次只能执行一个线程（即使在多CPU系统上）。当调用可能需要时间来计算（并且对于其他线程，如更新​​的全局变量）没有副作用的编译函数时，GIL应该被释放，以便其他Python线程可以运行，同时执行耗时的计算。这可以使用两组宏来实现。通常，如果在代码块中使用组中的一个宏，则所有这些宏必须在相同的代码块中使用。Currently, NPY_ALLOW_THREADS is defined to the python-defined WITH_THREADS constant unless the environment variable NPY_NOSMP is set in which case NPY_ALLOW_THREADS is defined to be 0.

Priority

NPY_PRIORITY

数组的默认优先级。

NPY_SUBTYPE_PRIORITY

默认子类型优先级。

NPY_SCALAR_PRIORITY

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

double PyArray_GetPriority(PyObject* obj, double def)

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

Default buffers

NPY_BUFSIZE

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

NPY_MIN_BUFSIZE

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

NPY_MAX_BUFSIZE

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

Other constants

NPY_NUM_FLOATTYPE

浮点类型的数量

NPY_MAXDIMS

数组中允许的最大维数。

NPY_VERSION

ndarray对象的当前版本（检查这个变量是否被定义以保证numpy / arrayobject.h头被使用）。

NPY_FALSE

定义为0，与Bool一起使用。

NPY_TRUE

定义为1与Bool一起使用。

NPY_FAIL

使用PyArg_ParseTuple类函数中的“O＆”语法调用的失败转换器函数的返回值。

NPY_SUCCEED

使用PyArg_ParseTuple类函数中的“O＆”语法调用的成功转换器函数的返回值。

Miscellaneous Macros

PyArray_SAMESHAPE(a1, a2)

如果数组a1和a2具有相同的形状，则计算为True。

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成员的结构）之间的复杂比较：首先比较实部，然后如果实部相等，则比较复数部分。

PyArray_REFCOUNT(PyObject* op)

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

PyArray_XDECREF_ERR(PyObject *obj)

DECREF的数组对象可以设置NPY_ARRAY_UPDATEIFCOPY标志，而不会将内容复制回原始数组。重置基础对象上的NPY_ARRAY_WRITEABLE标志。当使用NPY_ARRAY_UPDATEIFCOPY时，这对于从错误状态恢复非常有用。

Enumerated Types

NPY_SORTKIND

可以取值NPY_{KIND}的特殊变量类型，其中{KIND}是

QUICKSORT，HEAPSORT，MERGESORT

NPY_NSORTS

定义为排序的数量。

NPY_SCALARKIND

指示在确定标量强制规则中区分的标量的“种类”的数量的特殊变量类型。此变量可以取值NPY_{KIND}，其中{KIND}可以是

NOSCALAR，BOOL_SCALAR，INTPOS_SCALAR，INTNEG_SCALAR，FLOAT_SCALAR，COMPLEX_SCALAR ，OBJECT_SCALAR

NPY_NSCALARKINDS

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

NPY_ORDER

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

NPY_ANYORDER

Fortran的顺序如果所有的输入都是Fortran，否则C。

NPY_CORDER

C命令。

NPY_FORTRANORDER

Fortran顺序。

NPY_KEEPORDER

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

NPY_CLIPMODE

指示应在某些功能中应用的剪辑类型的变量类型。

NPY_RAISE

大多数操作的默认值，如果索引超出边界则引发异常。

NPY_CLIP

如果索引超出范围，则将其限制为有效范围。

NPY_WRAP

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

NPY_CASTING

版本1.6中的新功能。

一种枚举类型，指示应该如何进行许可数据转换。这是由NumPy 1.6中添加的迭代器使用的，并且旨在在未来版本中更广泛地使用。

NPY_NO_CASTING

只允许相同类型。

NPY_EQUIV_CASTING

允许相同的转换，涉及字节交换。

NPY_SAFE_CASTING

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

NPY_SAME_KIND_CASTING

允许任何安全投射，并在同种类型之间投射。例如，此规则允许使用float64 - > float32。

NPY_UNSAFE_CASTING

允许任何投放，无论可能发生什么类型的数据丢失。