Интерфейс массивов API

Структура массива и доступ к данным

Эти макросы все обращаются к элементам структуры PyArrayObject. Аргумент arr может быть любым PyObject * , который непосредственно интерпретируется как PyArrayObject * (любой экземпляр PyArray_Type и его подтипов).

int PyArray_NDIM(PyArrayObject *arr)

Количество измерений в массиве.

npy_intp *PyArray_DIMS(PyArrayObject *arr)

Возвращает указатель на размеры/форму массива. Количество элементов соответствует количеству измерений массива.

npy_intp *PyArray_SHAPE(PyArrayObject *arr)

Добавлена в версии 1.7.

Синоним для PyArray_DIMS, названный для соответствия использованию «shape» в Python.

void *PyArray_DATA(PyArrayObject *arr)

char *PyArray_BYTES(PyArrayObject *arr)

Эти два макроса похожи и получают указатель на буфер данных массива. Первый макрос можно (и следует) присвоить конкретному указателю, а второй предназначен для универсальной обработки. Если вы не гарантировали непрерывность и/или выравнивание массива, то убедитесь, что понимаете, как обращаться к данным в массиве, чтобы избежать проблем с памятью и/или выравниванием.

npy_intp *PyArray_STRIDES(PyArrayObject* arr)

Возвращает указатель на шаги массива. Количество элементов соответствует количеству измерений массива.

npy_intp PyArray_DIM(PyArrayObject* arr, int n)

Возвращает размер в n-м измерении.

npy_intp PyArray_STRIDE(PyArrayObject* arr, int n)

Возвращает шаг в n-м измерении.

PyObject *PyArray_BASE(PyArrayObject* arr)

Возвращает базовый объект массива. В большинстве случаев это объект, владеющий памятью, на которую указывает массив.

Если вы создаёте массив с помощью C API и указываете свою собственную память, используйте функцию PyArray_SetBaseObject для задания базового объекта, владеющего памятью.

Если установлен флаг NPY_ARRAY_UPDATEIFCOPY, он имеет другое значение, а именно базовый объект — массив, в который будет скопирован текущий массив при уничтожении. Это перегрузка свойства base для двух функций, вероятно, изменится в будущих версиях NumPy.

PyArray_Descr *PyArray_DESCR(PyArrayObject* arr)

Возвращает ссылку на свойство dtype массива.

PyArray_Descr *PyArray_DTYPE(PyArrayObject* arr)

Добавлена в версии 1.7.

Синоним для PyArray_DESCR, названный для соответствия использованию ‘dtype’ в Python.

void PyArray_ENABLEFLAGS(PyArrayObject* arr, int flags)

Добавлена в версии 1.7.

Включает указанные флаги массива. Эта функция не выполняет проверки и предполагает, что вы знаете, что делаете.

void PyArray_CLEARFLAGS(PyArrayObject* arr, int flags)

Добавлена в версии 1.7.

Сбрасывает указанные флаги массива. Эта функция не выполняет проверки и предполагает, что вы знаете, что делаете.

int PyArray_FLAGS(PyArrayObject* arr)

npy_intp PyArray_ITEMSIZE(PyArrayObject* arr)

Возвращает размер элемента для элементов этого массива.

Обратите внимание, что в старом API, который был устаревшим в версии 1.7, эта функция имела тип возвращаемого значения int.

int PyArray_TYPE(PyArrayObject* arr)

Возвращает (встроенный) тип данных для элементов этого массива.

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

Получает объект Python из ndarray, arr, в позиции, на которую указывает itemptr. Возвращает NULL в случае ошибки.

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

Преобразует obj и помещает его в ndarray, arr, в позицию, на которую указывает itemptr. Возвращает -1, если произошла ошибка, или 0 в случае успеха.

npy_intp PyArray_SIZE(PyArrayObject* arr)

Возвращает общий размер (количество элементов) массива.

npy_intp PyArray_Size(PyArrayObject* obj)

Возвращает 0, если obj не является подклассом bigndarray. В противном случае возвращает общее количество элементов в массиве. Более безопасная версия PyArray_SIZE (obj).

npy_intp PyArray_NBYTES(PyArrayObject* arr)

Возвращает общее количество байтов, занимаемых массивом.

Доступ к данным

Эти функции и макросы предоставляют удобный доступ к элементам ndarray из C. Они работают для всех массивов. Однако, при доступе к данным в массиве необходимо быть осторожными, если он не в порядке байтового порядка машины, не выровнен или не доступен для записи. Другими словами, обязательно соблюдайте состояние флагов, если вы не знаете, что делаете, или ранее не гарантировали, что массив доступен для записи, выровнен и в порядке байтового порядка машины, используя PyArray_FromAny. Если вы хотите обрабатывать все типы массивов, функция copyswap для каждого типа полезна для обработки некорректных массивов. Некоторые платформы (например, Solaris) не любят невыровненные данные и аварийно завершат работу, если вы разыменовали невыровненный указатель. Другие платформы (например, x86 Linux) просто будут работать медленнее с невыровненными данными.

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

Возвращает указатель на данные ndarray, aobj, в 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* dims, npy_intp* strides, void* data, int flags, PyObject* obj)

Эта функция заимствует ссылку на descr.

Это основная функция создания массивов. Большинство новых массивов создаются с помощью этой гибкой функции.

Возвращаемый объект — объект типа Python subtype, который должен быть подтипом PyArray_Type. Массив имеет nd измерений, описанных dims. Описание типа данных нового массива — descr.

Если subtype является подклассом массива вместо базового &PyArray_Type, то obj — объект, передаваемый методу __array_finalize__ подкласса.

Если data — NULL, то будет выделена новая память, и flags может быть ненулевым, чтобы указать на непрерывный массив в стиле Fortran. Если data не NULL, то предполагается, что он указывает на память, используемую для массива, и аргумент flags используется как новые флаги массива (за исключением того, что состояние NPY_OWNDATA и NPY_ARRAY_UPDATEIFCOPY флагов нового массива будут сброшены).

Кроме того, если data не NULL, то можно также предоставить strides. Если strides — NULL, то шаги массива вычисляются как непрерывные в стиле C (по умолчанию) или непрерывные в стиле Fortran (flags ненулевое для data = NULL или flags & NPY_ARRAY_F_CONTIGUOUS ненулевое для non-NULL data). Любые предоставленные dims и strides копируются в новые массивы размеров и шагов для нового объекта массива.

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

Добавлена в версии 1.6.

Эта функция заимствует ссылку на descr, если она не NULL.

Эта функция создания массива позволяет удобно создавать новый массив, соответствующий формам и структуре памяти существующего массива, возможно, изменяя структуру и/или тип данных.

Когда order — NPY_ANYORDER, порядок результата — NPY_FORTRANORDER, если prototype — массив Fortran, NPY_CORDER в противном случае. Когда order — NPY_KEEPORDER, порядок результата соответствует порядку prototype, даже если оси prototype не в порядке C или Fortran.

Если descr — NULL, используется тип данных prototype.

Если subok — 1, новый созданный массив будет использовать подтип prototype для создания нового массива, иначе он создаст массив базового класса.

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, размер которого в каждой из nd размерностей задаётся целочисленным массивом dims. Эта функция не может быть использована для создания массива с гибким типом (размер элемента не задан).

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

Создаёт обёртку массива вокруг data, на который указывает указанный указатель. Флаги массива будут иметь значение по умолчанию, что область данных хорошо организована и непрерывна в стиле C. Форма массива задаётся массивом dims длиной nd. Тип данных массива указан в typenum.

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

Эта функция захватывает ссылку на descr, если она не равна NULL.

Создаёт новый массив с предоставленным дескриптором типа данных 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)

Создаёт новый массив nd размерности с формой, задаваемой dims, и типом данных, задаваемым dtype. Если fortran ненулевое, создаётся массив с порядком Fortran, в противном случае — с порядком C. Заполните память нулями (или объектом 0, если dtype соответствует NPY_OBJECT).

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)

Создаёт новый nd -мерный массив с формой, задаваемой dims, и типом данных, задаваемым dtype. Если 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)

Создаёт новый одномерный массив типа данных typenum, который изменяется от start до stop (исключая) с шагом step. Эквивалентно arange (start, stop, step, dtype).

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

Создаёт новый одномерный массив типа данных, определяемого descr, который изменяется от start до stop (исключая) с шагом step. Эквивалентно arange( start, stop, step, typenum ).

int PyArray_SetBaseObject(PyArrayObject* arr, PyObject* obj)

Новое в версии 1.7.

Эта функция захватывает ссылку на obj и устанавливает её в качестве свойства base для arr.

Если вы создаёте массив, передавая свой собственный буфер памяти в качестве параметра, вам необходимо установить свойство base массива, чтобы обеспечить соответствующую продолжительность жизни буфера памяти.

Значение возврата — 0 при успехе, -1 при ошибке.

Если предоставленный объект является массивом, эта функция прослеживает цепочку указателей base таким образом, что каждый массив указывает непосредственно на владельца памяти. После установки base её нельзя изменить на другое значение.

Из других объектов

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

Это основная функция, используемая для получения массива из любого вложенного последовательности или объекта, предоставляющего интерфейс массива, op. Параметры позволяют указать требуемый dtype, минимальное (min_depth) и максимальное (max_depth) количество разрешённых измерений, а также другие требования к массиву. Аргумент dtype должен быть структурой PyArray_Descr, указывающей желаемый тип данных (включая требуемый порядок байтов). Аргумент dtype может быть NULL, что означает, что любой тип данных (и порядок байтов) приемлем. Если в flags нет FORCECAST, этот вызов сгенерирует ошибку, если тип данных нельзя безопасно получить из объекта. Если вы хотите использовать NULL для dtype и убедиться, что массив не переставлен, используйте PyArray_CheckFromAny. Значение 0 для любого из параметров глубины приводит к игнорированию параметра. Любой из следующих флагов массива может быть добавлен (например, с помощью |) для аргумента требования. Если ваш код может обрабатывать общие (например, с шагами, с переставленными байтами или невыровненные массивы), то требования могут быть 0. Кроме того, если op ещё не является массивом (или не предоставляет интерфейс массива), то будет создан новый массив (и заполнен из op с использованием протокола последовательности). Новый массив будет иметь NPY_DEFAULT в качестве своего члена флагов. Аргумент context передаётся методу __array__ объекта op и используется только в том случае, если массив создаётся таким образом. Почти всегда этот параметр равен NULL.

В версиях NumPy 1.6 и более ранних флагах не было префикса _ARRAY_ макроса. Такая форма имён констант устарела в 1.7.

NPY_ARRAY_C_CONTIGUOUS

Обеспечьте, чтобы возвращаемый массив был непрерывным в стиле C.

NPY_ARRAY_F_CONTIGUOUS

Обеспечьте, чтобы возвращаемый массив был непрерывным в стиле Fortran.

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__, для осмысления объекта требуется тип данных. Когда это необходимо, предоставьте Descr для ‘requested_dtype’, в противном случае предоставьте NULL. Эта ссылка не крадётся. Кроме того, если запрашиваемый тип данных не изменяет интерпретацию входного значения, out_dtype всё равно получит «врождённый» тип данных объекта, а не тип данных, переданный в ‘requested_dtype’.

Если требуется запись в значение в ‘op’, установите boolean ‘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 (...) за исключением того, что requirements может содержать NPY_ARRAY_NOTSWAPPED (переопределяя спецификацию в dtype) и NPY_ARRAY_ELEMENTSTRIDES, указывающее, что массив должен быть выровнен в том смысле, что шаги являются кратными размеру элемента.

В версиях NumPy 1.6 и более ранних флагах не было префикса _ARRAY_ макроса. Такая форма имён констант устарела в 1.7.

NPY_ARRAY_NOTSWAPPED

Убедитесь, что возвращаемый массив имеет описатель типа данных в машинной байтовой последовательности, переопределяя любое указание в аргументе dtype. Обычно требование к байтовой последовательности определяется аргументом dtype. Если этот флаг установлен, а аргумент dtype не указывает на описатель машинной байтовой последовательности (или равен NULL, и объект уже является массивом с описателем типа данных, который не находится в машинной байтовой последовательности), то создается новый описатель типа данных, и используется его поле байтовой последовательности, установленное в родной.

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 уже является массивом, но он должен иметь определённый тип newtype (включая байтовую последовательность) или имеет определённые требования.

PyObject* PyArray_FromStructInterface(PyObject* op)

Возвращает объект ndarray из Python-объекта, который экспонирует атрибут __array_struct__ и следует протоколу интерфейса массива. Если объект не содержит этот атрибут, возвращается заимствованная ссылка на Py_NotImplemented.

PyObject* PyArray_FromInterface(PyObject* op)

Возвращает объект ndarray из Python-объекта, который экспонирует атрибут __array_interface__ в соответствии с протоколом интерфейса массива. Если объект не содержит этот атрибут, возвращается заимствованная ссылка на Py_NotImplemented.

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

Возвращает объект ndarray из Python-объекта, который экспонирует метод __array__. Метод __array__ может принимать 0, 1 или 2 аргумента ([dtype, context]), где context используется для передачи информации о том, откуда вызывается метод __array__ (в настоящее время используется только в ufuncs).

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

Эта функция возвращает (стиль C) непрерывный и корректный массив функций из любого вложенного последовательности или объекта, экспортирующего интерфейс массива, op, типа, заданного перечислением typenum, минимальной глубины 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, типа, заданного перечислением typenum. Минимальное число измерений массива задается min_depth, а максимальное — max_depth. Это эквивалентно вызову PyArray_FromAny с требованиями, установленными на BEHAVED.

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)

Создаёт одномерный массив ndarray одного типа из двоичного или (ASCII) текстового string длиной slen. Тип данных создаваемого массива задаётся dtype. Если num равно -1, то копируется вся строка и возвращается массив соответствующего размера, иначе num является числом элементов для копирования из строки. Если sep равно NULL (или “”), то строка интерпретируется как байты двоичных данных, иначе подстроки, разделённые sep, преобразуются в элементы типа данных dtype. Некоторые типы данных могут быть нечитаемы в текстовом режиме, и ошибка будет возбуждена, если это произойдёт. Все ошибки возвращают NULL.

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

Создаёт одномерный массив ndarray одного типа из двоичного или текстового файла. Открытый указатель файла — fp, тип данных создаваемого массива задаётся dtype. Это должно соответствовать данным в файле. Если num равно -1, то считывается до конца файла и возвращается массив соответствующего размера, иначе num является числом считываемых элементов. Если sep равно NULL (или “”), то считывается из файла в двоичном режиме, иначе считывается из файла в текстовом режиме с sep, задающим разделитель элементов. Некоторые типы массивов не могут быть прочитаны в текстовом режиме, и в этом случае возбуждается ошибка.

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

Создаёт одномерный массив ndarray одного типа из объекта, buf, экспортирующего протокол буфера (или имеющего атрибут __buffer__, возвращающий объект, экспортирующий протокол буфера). Вначале будет предпринята попытка получить доступ к изменяемому буферу, а затем к только для чтения буферу. Флаг NPY_ARRAY_WRITEABLE возвращаемого массива отразит, какой из них был успешным. Данные предполагаются начинающими с offset байтов от начала памяти объекта. Тип данных в буфере будет интерпретирован в зависимости от описателя типа данных, 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 для других аргументов. Ваш код должен уметь обрабатывать любой описатель типа данных и любую комбинацию флагов данных для использования этого макроса.

PyObject* PyArray_FROM_OF(PyObject* obj, int requirements)

Аналогично PyArray_FROM_O, но может принимать аргумент requirements, указывающий свойства, которые должен иметь результирующий массив. Доступные требования, которые могут быть применены, — 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 и 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, так и flags.

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

Аналогично PyArray_FromAny, за исключением того, что тип данных задаётся с помощью номера типа. PyArray_DescrFromType (typenum) передаётся непосредственно в PyArray_FromAny. Этот макрос также добавляет NPY_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

PyArray_Check(op)

Возвращает true, если op — это объект Python, тип которого является подтипом PyArray_Type.

PyArray_CheckExact(op)

Возвращает true, если op — это объект Python с типом PyArray_Type.

PyArray_HasArrayInterface(op, out)

Если op реализует любую часть интерфейса массива, то out будет содержать новую ссылку на недавно созданный ndarray, использующий интерфейс, или out будет содержать NULL в случае ошибки при преобразовании. В противном случае out будет содержать заимствованную ссылку на Py_NotImplemented, и состояние ошибки не устанавливается.

PyArray_HasArrayInterfaceType(op, type, context, out)

Если op реализует любую часть интерфейса массива, то out будет содержать новую ссылку на недавно созданный ndarray, использующий интерфейс, или out будет содержать NULL в случае ошибки при преобразовании. В противном случае out будет содержать заимствованную ссылку на Py_NotImplemented, и состояние ошибки не устанавливается. Эта версия позволяет задавать тип и контекст в части интерфейса массива, которая ищет атрибут __array__.

PyArray_IsZeroDim(op)

Возвращает true, если op является экземпляром (подкласса) PyArray_Type и имеет 0 измерений.

PyArray_IsScalar(op, cls)

Возвращает true, если op является экземпляром Py{cls}ArrType_Type.

PyArray_CheckScalar(op)

Возвращает true, если op — это скаляр массива (экземпляр подтипа PyGenericArr_Type ), или экземпляр (подкласса) PyArray_Type с размерностью 0.

PyArray_IsPythonNumber(op)

Возвращает true, если op является экземпляром встроенного числового типа (int, float, complex, long, bool)

PyArray_IsPythonScalar(op)

Возвращает true, если op — это встроенный скалярный объект Python (int, float, complex, str, unicode, long, bool).

PyArray_IsAnyScalar(op)

Возвращает true, если op — это либо скалярный объект Python (см. PyArray_IsPythonScalar), либо скаляр массива (экземпляр подтипа PyGenericArr_Type).

PyArray_CheckAnyScalar(op)

Возвращает true, если op — это скалярный объект Python (см. PyArray_IsPythonScalar), скаляр массива (экземпляр подтипа PyGenericArr_Type) или экземпляр подтипа PyArray_Type с размерностью 0.

Проверка типа данных

Для макросов 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)

Тип представляет строковый тип данных.

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)

Возвращает true, если область данных ndarray m находится в порядке байтов машины в соответствии с описателем типа данных массива.

PyArray_ISBYTESWAPPED(m)

Возвращает true, если область данных 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)

Возвращает NPY_TRUE, если a1 и a2 являются массивами с эквивалентными типами для данной платформы.

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 эквивалентны, в то время как на машине с большим порядком байтов они не эквивалентны.

Преобразование типов данных

PyObject* PyArray_Cast(PyArrayObject* arr, int typenum)

В основном для обратной совместимости с Numeric 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, которая обрабатывает преобразование.

Преобразует элементы массива in в массив out. Выходной массив должен быть доступным для записи, иметь целое кратное число элементов в входном массиве (в выходной массив может быть помещено более одной копии), и иметь тип данных, являющийся одним из встроенных типов. Возвращает 0 при успешном выполнении и -1 при возникновении ошибки.

PyArray_VectorUnaryFunc* PyArray_GetCastFunc(PyArray_Descr* from, int totype)

Возвращает функцию низкого уровня преобразования для преобразования из данного описателя в число встроенного типа. Если функция преобразования отсутствует, возвращает NULL и устанавливает ошибку. Использование этой функции вместо прямого доступа к from ->f->cast позволит поддерживать любые пользовательские функции преобразования, добавленные в словарь преобразований описателей.

int PyArray_CanCastSafely(int fromtype, int totype)

Возвращает ненулевое значение, если массив типа данных fromtype может быть преобразован в массив типа данных totype без потери информации. Исключением является то, что 64-битные целые числа разрешается преобразовывать в 64-битные числа с плавающей точкой, даже если это может привести к потере точности для больших целых чисел, чтобы не распространять использование long double без явных запросов. Гибкие типы массивов не проверяются по их длинам с помощью этой функции.

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 (который может включать гибкие типы) в соответствии с правилом преобразования casting. Для простых типов с 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 в соответствии с правилом преобразования, указанным в casting. Если 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 представляет собой объект, который будет преобразован в массив. Возвращаемое значение — это перечисленное значение typenumber, которое представляет тип данных, которым должен обладать op.

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

Эта функция устарела и заменена PyArray_ResultType.

Эта функция работает аналогично PyArray_ObjectType (...) за исключением того, что она обрабатывает гибкие массивы. Аргумент mintype может иметь член itemsize, а аргумент outtype будет иметь член itemsize, по крайней мере, столь же большой, но, возможно, и больший, в зависимости от объекта op.

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

Функциональность, предоставляемая этой функцией, в значительной степени устарела, её заменил итератор NpyIter, представленный в версии 1.6, с флагом NPY_ITER_COMMON_DTYPE или с одинаковым параметром типа данных для всех операндов.

Преобразовать последовательность Python-объектов, содержащихся в op, в массив ndarray, каждый из которых имеет одинаковый тип данных. Тип выбирается на основе номера типа (выбирается больший номер типа по сравнению с меньшим), игнорируя объекты, являющиеся только скалярами. Длина последовательности возвращается в n, а значением возврата является массив длины n указателей на PyArrayObject (или NULL в случае ошибки). Возвращаемый массив должен быть освобождён вызывающей стороной этой функции (с помощью PyDataMem_FREE ), и все массивы в нём должны быть освобождены, иначе возникнет утечка памяти. Пример шаблона кода ниже демонстрирует типичное использование:

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, содержащую представление 0 для данного типа. Возвращаемый указатель ret обязательно нужно освободить с помощью PyDataMem_FREE (ret), когда он больше не нужен.

char* PyArray_One(PyArrayObject* arr)

Указатель на вновь созданную область памяти размером arr ->itemsize, содержащую представление 1 для данного типа. Возвращаемый указатель ret обязательно нужно освободить с помощью PyDataMem_FREE (ret), когда он больше не нужен.

int PyArray_ValidType(int typenum)

Возвращает NPY_TRUE, если typenum представляет допустимый номер типа (встроенный, пользовательский или код символа). В противном случае функция возвращает NPY_FALSE.

Новые типы данных

void PyArray_InitArrFuncs(PyArray_ArrFuncs* f)

Инициализировать все указатели на функции и члены до NULL.

int PyArray_RegisterDataType(PyArray_Descr* dtype)

Зарегистрировать тип данных в качестве нового пользовательского типа данных для массивов. Тип должен иметь заполненные большинство своих элементов. Это не всегда проверяется, и ошибки могут привести к ошибкам сегментирования. В частности, член typeobj структуры dtype должен быть заполнен Python-типом с фиксированным размером элемента, соответствующим члену elsize в dtype. Также член f должен иметь необходимые функции: nonzero, copyswap, copyswapn, getitem, setitem и cast (некоторые из функций 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)

Зарегистрировать номер типа данных totype как преобразуемый из объекта типа данных descr заданного scalar типа. Используйте scalar = NPY_NOSCALAR для регистрации возможности безопасного преобразования массива типа данных descr к типу данных с номером типа totype.

Специальные функции для NPY_OBJECT

int PyArray_INCREF(PyArrayObject* op)

Используется для массива op, содержащего любые Python-объекты. Увеличивает счётчик ссылок каждого объекта в массиве в соответствии с типом данных op. Возвращает -1 в случае ошибки, иначе 0.

void PyArray_Item_INCREF(char* ptr, PyArray_Descr* dtype)

Функция для увеличения счёта ссылок всех объектов в позиции ptr в соответствии с типом данных dtype. Если ptr является началом структурированного типа с объектом в любом смещении, то это увеличивает счётчик ссылок всех подобных объектам элементов в структурированном типе (рекурсивно).

int PyArray_XDECREF(PyArrayObject* op)

Используется для массива op, содержащего любые Python-объекты. Уменьшает счётчик ссылок каждого объекта в массиве в соответствии с типом данных op. Нормальное значение возврата — 0. Возвращает -1 в случае ошибки.

void PyArray_Item_XDECREF(char* ptr, PyArray_Descr* dtype)

Функция для уменьшения счёта ссылок всех элементов подобных объектам в позиции ptr, как записано в типе данных dtype. Это работает рекурсивно, поэтому если dtype сам содержит поля с типами данных, содержащими элементы подобные объектам, все поля подобные объектам будут уменьшать счётчик ссылок 'd.

void PyArray_FillObjectArray(PyArrayObject* arr, PyObject* obj)

Заполнить только что созданный массив одним значением obj во всех позициях структуры с типами данных объектов. Проверка не выполняется, но arr должен быть типа данных NPY_OBJECT, быть односегментным и неинициализированным (без предыдущих объектов в позиции). Используйте PyArray_DECREF (arr), если вам нужно уменьшить счётчик ссылок всех элементов массива объектов перед вызовом этой функции.

Флаги массива

Атрибут flags структуры PyArrayObject содержит важную информацию о памяти, используемой массивом (указатель на которую находится в поле data). Эта информация о флагах должна быть актуальной, иначе могут возникнуть непредсказуемые результаты и даже ошибки сегментирования.

Существует 6 (двоичных) флагов, описывающих область памяти, используемую буфером данных. Эти константы определены в arrayobject.h и определяют битовую позицию флага. Python предоставляет удобный интерфейс на основе атрибутов, а также интерфейс типа словаря для получения (и, при необходимости, установки) этих флагов.

Области памяти всех видов могут быть указаны ndarray, что требует этих флагов. Если вы получаете произвольный PyArrayObject в C-коде, вы должны знать о установленных флагах. Если вам нужно гарантировать определённый вид массива (например, NPY_ARRAY_C_CONTIGUOUS и NPY_ARRAY_BEHAVED), то передайте эти требования в функцию PyArray_FromAny.

Основные флаги массива

ndarray может иметь сегмент данных, который не является простым смежным куском корректной памяти, которую вы можете изменять. Он может не быть выровнен по границам слов (очень важно на некоторых платформах). Данные могут быть в другом порядке байтов, чем распознаёт машина. Он может быть не доступен для записи. Он может быть в порядке, согласованном с Fortran. Флаги массива используются для указания того, что можно сказать о данных, связанных с массивом.

В версиях 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 затем указывает на «некорректный» массив (который устанавливается в read_only). При освобождении массива с установленным этим флагом, он скопирует своё содержимое обратно в «некорректный» массив (с приведением типов, если необходимо) и сбросит «некорректный» массив до NPY_ARRAY_WRITEABLE. Если «некорректный» массив изначально не был NPY_ARRAY_WRITEABLE, то PyArray_FromAny вернул бы ошибку, потому что NPY_ARRAY_UPDATEIFCOPY было бы невозможно.

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 (или bigndarray), а не подклассом.

NPY_ARRAY_NOTSWAPPED

Используется только в PyArray_CheckFromAny для переопределения порядка байтов объекта типа данных, переданного в него.

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

Проверка флагов

Для всех этих макросов 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)

Возвращает true, если arr является непрерывным в стиле C.

PyArray_IS_F_CONTIGUOUS(arr)

Возвращает true, если arr является непрерывным в стиле Fortran.

PyArray_ISFORTRAN(arr)

Возвращает true, если arr является непрерывным в стиле Fortran и не является непрерывным в стиле C. PyArray_IS_F_CONTIGUOUS — правильный способ проверить непрерывность в стиле Fortran.

PyArray_ISWRITEABLE(arr)

Возвращает true, если область данных arr может быть изменена.

PyArray_ISALIGNED(arr)

Возвращает true, если область данных arr правильно выровнена на машине.

PyArray_ISBEHAVED(arr)

Возвращает true, если область данных arr выровнена, изменяема и имеет порядок байтов машины в соответствии с её описателем.

PyArray_ISBEHAVED_RO(arr)

Возвращает true, если область данных arr выровнена и имеет порядок байтов машины.

PyArray_ISCARRAY(arr)

Возвращает true, если область данных arr непрерывна в стиле C, и PyArray_ISBEHAVED (arr) равно true.

PyArray_ISFARRAY(arr)

Возвращает true, если область данных arr непрерывна в стиле Fortran, и PyArray_ISBEHAVED (arr) равно true.

PyArray_ISCARRAY_RO(arr)

Возвращает true, если область данных arr непрерывна в стиле C, выровнена и имеет порядок байтов машины.

PyArray_ISFARRAY_RO(arr)

Возвращает true, если область данных arr непрерывна в стиле Fortran, выровнена и имеет порядок байтов машины.

PyArray_ISONESEGMENT(arr)

Возвращает true, если область данных arr состоит из одного непрерывного сегмента (в стиле C или Fortran).

void PyArray_UpdateFlags(PyArrayObject* arr, int flagmask)

Флаги массива NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_ALIGNED и NPY_ARRAY_F_CONTIGUOUS могут быть «вычислены» из самого объекта массива. Эта процедура обновляет один или несколько из этих флагов arr, как указано в flagmask, выполняя необходимое вычисление.

Альтернативный API методов массивов

Преобразование

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

Эквивалентно ndarray.getfield (self, dtype, offset). Возвращает новый массив заданного типа dtype, используя данные из текущего массива в указанном смещении offset в байтах. Смещение offset плюс размер элемента нового типа массива должны быть меньше self ->descr->elsize, иначе генерируется ошибка. Используются та же форма и шаги, что и в исходном массиве. Поэтому эта функция имеет эффект возвращения поля из структурированного массива. Но её также можно использовать для выбора определённых байтов или групп байтов из любого типа массива.

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

Эквивалентно ndarray.setfield (self, val, dtype, offset ). Устанавливает поле, начиная с байта offset и имеющее заданный тип dtype, в значение val. offset плюс dtype ->elsize должно быть меньше self ->descr->elsize, иначе возникает ошибка. В противном случае аргумент val преобразуется в массив и копируется в указанное поле. При необходимости элементы val повторяются для заполнения целевого массива. Однако, количество элементов в целевом массиве должно быть целым кратным количеству элементов в val.

PyObject* PyArray_Byteswap(PyArrayObject* self, Bool inplace)

Эквивалентно ndarray.byteswap (self, inplace). Возвращает массив, в котором область данных переставлена байтами. Если inplace ненулевое, то выполняется перестановка байтов на месте и возвращается ссылка на self. В противном случае создаётся копия с переставленными байтами, и self остаётся неизменным.

PyObject* PyArray_NewCopy(PyArrayObject* old, NPY_ORDER order)

Эквивалентно ndarray.copy (self, fortran). Создаёт копию массива old. Возвращаемый массив всегда выровнен и доступен для записи с данными, интерпретируемыми так же, как и в исходном массиве. Если order равен NPY_CORDER, то возвращается непрерывный массив в стиле C. Если order равен NPY_FORTRANORDER, то возвращается непрерывный массив в стиле Fortran. Если order равен NPY_ANYORDER, то возвращаемый массив будет непрерывным в стиле Fortran только если исходный массив также непрерывный в стиле Fortran; в противном случае он будет непрерывным в стиле C.

PyObject* PyArray_ToList(PyArrayObject* self)

Эквивалентно ndarray.tolist (self). Возвращает вложенный Python-список из self.

PyObject* PyArray_ToString(PyArrayObject* self, NPY_ORDER order)

Эквивалентно ndarray.tobytes (self, order). Возвращает байты этого массива в строке Python.

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

Записывает содержимое self в указатель файла fp в непрерывном стиле C. Записывает данные как двоичные байты, если sep — это строка “” или NULL. В противном случае записывает содержимое self как текст, используя строку sep в качестве разделителя элементов. Каждый элемент будет напечатан в файл. Если строка format не NULL или “”, то это строка форматирования Python print, показывающая, как элементы должны быть записаны.

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

Записывает объект в self в данный file (строка или объект Python-файла). Если file — Python-строка, она рассматривается как имя файла, которое затем открывается в двоичном режиме. Используется указанный protocol (если protocol отрицателен, используется максимальный доступный). Это простой обертка над cPickle.dump(self, file, protocol).

PyObject* PyArray_Dumps(PyObject* self, int protocol)

Записывает объект в self в Python-строку и возвращает её. Используется предоставленный протокол protocol (или максимальный доступный, если protocol отрицателен).

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, dtype). Возвращает новый вид массива self, возможно с другим типом данных dtype и другим подклассом массива ptype.

Если dtype равен NULL, то возвращаемый массив будет иметь тот же тип данных, что и self. Новый тип данных должен быть совместим с размером self. Либо размеры элементов должны быть идентичны, либо self должен быть односегментным, и общее количество байтов должно быть одинаковым. В последнем случае размерности возвращаемого массива будут изменены в последней (или первой для массивов, непрерывных в стиле Fortran) размерности. Область данных возвращаемого массива и self точно одинаковы.

Изменение формы массива

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 — последовательность. Преобразует 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, order= fortran ). Эта функция работает только с односегментными массивами. Она изменяет форму self на месте и перераспределит память для self, если newshape имеет другое общее количество элементов, чем старая форма. Если перераспределение необходимо, то 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, permute). Меняет оси объекта ndarray self в соответствии со структурой данных permute и возвращает результат. Если permute равен NULL, то оси результирующего массива инвертируются. Например, если self имеет форму , а permute .ptr равно (0,2,1), то форма результата равна Если permute равно NULL, то форма результата равна

PyObject* PyArray_Flatten(PyArrayObject* self, NPY_ORDER order)

Эквивалентно ndarray.flatten (self, order). Возвращает одномерную копию массива. Если order равен NPY_FORTRANORDER, элементы считываются в порядке Fortran (первая размерность изменяется быстрее). Если order равен NPY_CORDER, элементы self считываются в порядке C (последняя размерность изменяется быстрее). Если order равен NPY_ANYORDER, то используется результат PyArray_ISFORTRAN (self) для определения порядка сглаживания.

PyObject* PyArray_Ravel(PyArrayObject* self, NPY_ORDER order)

Эквивалентно self.ravel(order). Имеет ту же основную функциональность, что и PyArray_Flatten (self, order), за исключением случая, когда order равен 0, а self — непрерывен в стиле C; в этом случае форма изменяется, но копия не создаётся.

Выбор и изменение элементов

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

Эквивалентно ndarray.take (self, indices, axis, ret, clipmode), за исключением того, что axis = None в Python достигается установкой axis = NPY_MAXDIMS в C. Извлекает элементы из self, указанные целочисленными indices вдоль заданной оси axis. Аргумент clipmode может быть NPY_RAISE, NPY_WRAP или NPY_CLIP для указания действий с индексами, выходящими за границы. Аргумент ret может указать массив вывода вместо создания его внутри.

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

Эквивалентно self.put(values, indices, clipmode ). Помещает values в self по соответствующим (уплощенным) indices. Если values слишком мал, он будет повторяться по мере необходимости.

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

Разместите значения values в self там, где соответствующие позиции (используя уплощенную область) в mask равны true. Массивы mask и self должны иметь одинаковое общее количество элементов. Если values недостаточно велик, он будет повторяться по мере необходимости.

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

Эквивалентно ndarray.repeat (self, op, axis). Копирует элементы self, op раз вдоль указанной оси axis. Либо op является скалярным целым числом, либо последовательностью длины self ->dimensions[ axis ], указывающей, сколько раз следует повторять каждый элемент вдоль оси.

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

Эквивалентно ndarray.choose (self, op, ret, clipmode). Создает новый массив, выбирая элементы из последовательности массивов в op на основе целых значений в self. Все массивы должны быть совместимы с одинаковой формой, а записи в self должны находиться в диапазоне от 0 до len(op). Результат помещается в ret, если это не NULL, в противном случае создается новый результат. Аргумент clipmode определяет поведение, когда записи в self находятся вне диапазона от 0 до len(op).

NPY_RAISE

вызвать ValueError;

NPY_WRAP

обернуть значения < 0, добавив len(op), и значения >=len(op), вычтя len(op), пока они не попадут в диапазон;

NPY_CLIP

все значения обрезаются до области [0, len(op)).

PyObject* PyArray_Sort(PyArrayObject* self, int axis)

Эквивалентно ndarray.sort (self, axis). Возвращает массив с элементами self, отсортированными вдоль оси axis.

PyObject* PyArray_ArgSort(PyArrayObject* self, int axis)

Эквивалентно ndarray.argsort (self, axis). Возвращает массив индексов, такой, что выбор этих индексов вдоль заданной axis вернет отсортированную версию self. Если self ->descr — тип данных с определенными полями, то self->descr->names используется для определения порядка сортировки. Сравнение, где первое поле равно, будет использовать второе поле и так далее. Чтобы изменить порядок сортировки структурированного массива, создайте новый тип данных с другим порядком имен и постройте представление массива с этим новым типом данных.

PyObject* PyArray_LexSort(PyObject* sort_keys, int axis)

Принимая последовательность массивов (sort_keys) одинаковой формы, возвращает массив индексов (аналогично PyArray_ArgSort (...)), который бы отсортировал массивы лексикографически. Лексикографическая сортировка означает, что когда два ключа оказываются равными, порядок определяется по сравнению последующих ключей. Для типов должна быть определена сортировка слиянием (не изменяющая места равных записей). Сортировка выполняется сначала по первому sort_key, затем по второму sort_key и так далее. Это эквивалентно команде Python lexsort(sort_keys, axis). Из-за того, как работает сортировка слиянием, убедитесь, что вы понимаете порядок, в котором должны находиться sort_keys (обратный порядку, который вы использовали бы при сравнении двух элементов).

Если эти массивы собраны в структурированный массив, то PyArray_Sort (...) также можно использовать для сортировки массива непосредственно.

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

Эквивалентно ndarray.searchsorted (self, values, side, perm). Предполагая, что self — одномерный массив в порядке возрастания, тогда результат — массив индексов той же формы, что и values, такой, что, если элементы в values были вставлены перед индексами, порядок self сохранялся бы. Проверка на то, что self отсортирован по возрастанию, не выполняется.

Аргумент side указывает, должен ли возвращаемый индекс быть индексом первого подходящего местоположения (если NPY_SEARCHLEFT) или последнего (если NPY_SEARCHRIGHT).

Аргумент sorter, если он не NULL, должен быть одномерным массивом целочисленных индексов той же длины, что и self, сортирующим его по возрастанию. Как правило, это результат вызова PyArray_ArgSort (...). Для поиска необходимых точек вставки используется двоичный поиск.

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

Эквивалентно ndarray.partition (self, ktharray, axis, kind). Разделяет массив так, чтобы значения элемента, индексированного ktharray, находились в тех же позициях, что и при полной сортировке массива, помещая все элементы, меньшие, чем k-й, перед ним, а все элементы, равные или большие, после него. Порядок всех элементов в разделах не определен. Если self->descr — тип данных с определенными полями, то self->descr->names используется для определения порядка сортировки. Сравнение, где первое поле равно, будет использовать второе поле и так далее. Чтобы изменить порядок сортировки структурированного массива, создайте новый тип данных с другим порядком имен и постройте представление массива с этим новым типом данных. Возвращает ноль при успехе и -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 ). Возвращает диагонали с offset 2-мерных массивов, определенных axis1 и 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, condition, axis ). Возвращает элементы вдоль axis, соответствующие элементам condition, которые равны true.

Расчет

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.

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

Эквивалентно ndarray.mean (self, axis, rtype). Возвращает среднее значение элементов вдоль заданной оси axis, используя перечисленный тип rtype как тип данных для суммирования. Поведение суммирования по умолчанию достигается с помощью NPY_NOTYPE для rtype.

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

Эквивалентно ndarray.trace (self, offset, axis1, axis2, rtype). Возвращает сумму (используя rtype в качестве типа данных для суммирования) по диагональным элементам со смещением offset 2-мерных массивов, определённых переменными axis1 и 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, decimals, out). Возвращает массив с элементами, округленными до ближайшего разряда. Разряд определяется как цифра, так что отрицательные значения decimals приводят к округлению до ближайших 10, 100 и т. д. Если out NULL, то массив вывода создаётся, в противном случае вывод помещается в out, который должен иметь правильный размер и тип.

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

Эквивалентно ndarray.std (self, axis, rtype). Возвращает стандартное отклонение, используя данные по оси axis, преобразованные к типу данных rtype.

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

Эквивалентно ndarray.sum (self, axis, rtype). Возвращает 1-мерные векторные суммы элементов в self по оси axis. Выполняет суммирование после преобразования данных к типу данных rtype.

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

Эквивалентно ndarray.cumsum (self, axis, rtype). Возвращает кумулятивные 1-мерные суммы элементов в self по оси axis. Выполняет суммирование после преобразования данных к типу данных rtype.

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

Эквивалентно ndarray.prod (self, axis, rtype). Возвращает 1-мерные произведения элементов в self по оси axis. Выполняет произведение после преобразования данных к типу данных rtype.

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

Эквивалентно ndarray.cumprod (self, axis, rtype). Возвращает 1-мерные кумулятивные произведения элементов в self по оси axis. Выполняет произведение после преобразования данных к типу данных rtype.

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

Эквивалентно ndarray.all (self, axis). Возвращает массив с элементами True для каждого 1-мерного подмассива self , определяемого axis, в котором все элементы равны True.

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

Эквивалентно ndarray.any (self, axis). Возвращает массив с элементами True для каждого 1-мерного подмассива self, определяемого axis, в котором любой из элементов равен True.

Функции

Функции для массивов

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-мерных массивов.

Параметры:

op – Адрес любого объекта Python. Этот объект Python будет заменён эквивалентным хорошо работающим, непрерывным в стиле C ndarray заданного типа данных, указанного в последних двух аргументах. Убедитесь, что использование ссылки к входному объекту таким образом оправдано. ptr – Адрес переменной (ctype* для 1-мерного, ctype** для 2-мерного или ctype*** для 3-мерного), где ctype — эквивалентный тип C для типа данных. По возвращении ptr будет доступен как 1-мерный, 2-мерный или 3-мерный массив. 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 вдоль оси axis в один массив. Если размерности или типы несовместимы, возникает ошибка.

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

Вычисляет произведение-сумму по последним измерениям obj1 и obj2. Ни один массив не сопряжён.

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

Вычисляет произведение-сумму по последнему измерению obj1 и предпоследнему измерению obj2. Для 2-мерных массивов это матричное произведение. Ни один массив не сопряжён.

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. Строка в subscripts представляет собой список индексных букв, разделённых запятыми. Количество операндов находится в nop, а op_in — массив, содержащий эти операнды. Тип данных выходных данных можно принудительно задать с помощью dtype, порядок вывода можно принудительно задать с помощью order (NPY_KEEPORDER рекомендуется), а когда dtype задан, casting указывает, насколько допускаемым должно быть преобразование данных.

См. функцию einsum для получения дополнительной информации.

PyObject* PyArray_CopyAndTranspose(PyObject * op)

Специализированная функция копирования и транспонирования, которая работает только для 2-мерных массивов. Возвращаемый массив представляет собой транспонированную копию op.

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

Вычисляет 1-мерную корреляцию 1-мерных массивов 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, которая использует обычное определение корреляции для 1-мерных массивов. Корреляция вычисляется в каждой точке вывода путём умножения 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 (condition). В противном случае, и x, и y должны быть заданы, и возвращаемый объект имеет форму, подобную condition, и содержит элементы x и y, где condition соответственно True или False.

Другие функции

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

Определите, является ли newstrides массивом шагов, согласованным с памятью nd -мерного массива с формой dims и размером элемента elsize. Массив newstrides проверяется на предмет того, будет ли переход на указанное количество байтов в каждом направлении означать переход больше, чем numbytes, который предполагается размером доступного сегмента памяти. Если numbytes равно 0, то эквивалентное значение numbytes вычисляется, предполагая, что nd, dims и elsize относятся к массиву с одним сегментом. Вернуть NPY_TRUE, если newstrides приемлемо, в противном случае вернуть 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.

Дополнительные данные с семантикой объектов

NpyAuxData

При работе с более сложными типами данных, которые состоят из других типов данных, таких как тип данных struct, для создания внутренних циклов, манипулирующих типами данных, требуется передавать дополнительные данные. NumPy поддерживает эту идею через структуру NpyAuxData, накладывая несколько соглашений, чтобы это было возможно.

Определение NpyAuxData аналогично определению класса в C++, но семантика объекта должна отслеживаться вручную, поскольку 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 auxadata */
    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;
}

NpyAuxData_FreeFunc

Тип указателя функции для функций освобождения NpyAuxData.

NpyAuxData_CloneFunc

Тип указателя функции для функций клонирования NpyAuxData. Эти функции никогда не должны устанавливать исключение Python при ошибке, так как они могут вызываться из многопотокового контекста.

NPY_AUXDATA_FREE(auxdata)

Макрос, который вызывает функцию освобождения auxdata соответствующим образом, ничего не делает, если auxdata равен NULL.

NPY_AUXDATA_CLONE(auxdata)

Макрос, который вызывает функцию клонирования auxdata соответствующим образом, возвращая глубокую копию дополнительных данных.

Итераторы массивов

Начиная с NumPy 1.6.0, эти итераторы массивов устарели и заменены новым итератором массива NpyIter.

Итератор массива — это простой способ быстро и эффективно получить доступ к элементам N-мерного массива. Раздел 2 содержит более подробное описание и примеры этого полезного подхода к циклическому перебору массива.

PyObject* PyArray_IterNew(PyObject* arr)

Возвращает объект итератора массива из массива arr. Это эквивалентно arr.flat. Объект итератора массива упрощает циклический перебор N-мерного несмежного массива в стиле непрерывности C.

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

Возвращает итератор массива, который будет итерироваться по всем осям, кроме указанной в *axis. Полученный итератор нельзя использовать с PyArray_ITER_GOTO1D. Этот итератор можно использовать для написания чего-то подобного тому, что делают ufunc, где цикл по самой большой оси выполняется отдельной подпрограммой. Если *axis отрицательный, то *axis будет установлен на ось с наименьшим шагом, и эта ось будет использована.

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

Возвращает итератор массива, который расширяется для итерации как массив формы, заданной dimensions и nd.

int PyArrayIter_Check(PyObject* op)

Возвращает истинное значение, если op является итератором массива (или экземпляром подкласса типа итератора массива).

void PyArray_ITER_RESET(PyObject* iterator)

Сбрасывает 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-массивом destination, размер которого должен быть не меньше iterator ->nd_m1+1.

PyArray_ITER_GOTO1D(PyObject* iterator, npy_intp index)

Устанавливает индекс и dataptr итератора в местоположение в массиве, указанное целым числом index, которое указывает на элемент в сплющенном массиве в стиле C.

int PyArray_ITER_NOTDONE(PyObject* iterator)

Возвращает TRUE, пока итератор не прошёл все элементы, в противном случае FALSE.

Расширение (многочисленные итераторы)

PyObject* PyArray_MultiIterNew(int num, ...)

Упрощённый интерфейс для расширения. Эта функция принимает количество массивов для расширения, а затем дополнительные аргументы (PyObject *). Эти аргументы преобразуются в массивы, и создаются итераторы. Затем вызывается PyArray_Broadcast на результирующем объекте многомерного итератора. Затем возвращается результирующий, расширенный объект многомерного итератора. Затем операция расширения может быть выполнена с помощью одного цикла и с использованием PyArray_MultiIter_NEXT (..)

void PyArray_MultiIter_RESET(PyObject* multi)

Сбрасывает все итераторы в начало в объекте многократного итератора multi.

void PyArray_MultiIter_NEXT(PyObject* multi)

Перемещает каждый итератор в объекте многократного итератора 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)

Перемещает каждый итератор в объекте многократного итератора multi в заданное -мерное destination, где — число измерений в расширенном массиве.

void PyArray_MultiIter_GOTO1D(PyObject* multi, npy_intp index)

Перемещает каждый итератор в объекте многократного итератора multi в соответствующее местоположение индекса 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, которые корректно расширяют свои входные данные, а затем вызывают однострочную версию процедуры как внутренний цикл. Эта однострочная версия обычно оптимизирована для скорости, и поэтому цикл следует выполнять по оси, которая не потребует больших скачков шага.

Итератор окружения

Итераторы окружения являются подклассами объекта итератора и могут использоваться для итерации по окружению точки. Например, вы можете итерироваться по каждому вокселю 3D изображения, а для каждого такого вокселя — по гиперкубу. Итератор окружения автоматически обрабатывает границы, что значительно упрощает написание такого кода по сравнению с ручным управлением границами, но с небольшим дополнительным временем.

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

Эта функция создаёт новый итератор окрестности из существующего итератора. Окрестность будет вычислена относительно позиции, на которую в данный момент указывает iter; границы определяют форму итератора окрестности, а аргумент mode — режим обработки границ.

Ожидается, что аргумент bounds будет массивом (2 * iter->ao->nd), например, диапазон bound[2*i]->bounds[2*i+1] определяет диапазон, в котором необходимо выполнить обход для измерения i (обе границы включены в просматриваемые координаты). Границы должны быть упорядочены для каждого измерения (bounds[2*i] <= bounds[2*i+1]).

Режим должен быть одним из следующих:

• NPY_NEIGHBORHOOD_ITER_ZERO_PADDING: заполнение нулями. Значения вне границ будут равны 0.
• NPY_NEIGHBORHOOD_ITER_ONE_PADDING: заполнение единицами. Значения вне границ будут равны 1.
• NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING: заполнение константой. Значения вне границ будут такими же, как первый элемент в fill_value.
• NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING: зеркальное заполнение. Значения вне границ будут такими, как если бы элементы массива были зеркально отображены. Например, для массива [1, 2, 3, 4], x[-2] будет 2, x[-3] будет 1, x[4] будет 4, x[5] будет 1 и т. д...
• NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING: циклическое заполнение. Значения вне границ будут такими, как если бы массив повторялся. Например, для массива [1, 2, 3, 4], x[-2] будет 3, x[-3] будет 4, x[4] будет 1, x[5] будет 2 и т. д...

Если режим заполнения константой (NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING), fill_value должен указывать на объект массива, содержащий значение заполнения (первый элемент будет значением заполнения, если массив содержит более одного элемента). В других случаях fill_value может быть NULL.

• Итератор ссылается на iter
• Возвращает NULL при ошибке (в этом случае счётчик ссылок iter не изменяется)
• Сам iter может быть итератором Neighbourhood: это может быть полезно, например, для автоматического управления границами
• Возвращаемый этим функция объект можно безопасно использовать как обычный итератор
• Если позиция iter изменена, любое последующее вызов PyArrayNeighborhoodIter_Next имеет неопределённое поведение, и необходимо вызвать PyArrayNeighborhoodIter_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)

Сбрасывает позицию итератора в первую точку окрестности. Это следует вызывать всякий раз, когда изменяется аргумент iter, переданный в PyArray_NeighborhoodIterObject (см. пример).

int PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)

После этого вызова iter->dataptr указывает на следующую точку окрестности. Вызов этой функции после посещения каждой точки окрестности имеет неопределённое поведение.

Массивные скаляры

PyObject* PyArray_Return(PyArrayObject* arr)

Эта функция крадёт ссылку на arr.

Эта функция проверяет, является ли arr массивом размерности 0, и если да, возвращает соответствующий скаляр массива. Она должна использоваться всякий раз, когда могут быть возвращены массивы размерности 0.

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

Возвращает объект скаляра массива заданного перечисленного typenum и itemsize, копируя данные из памяти, на которую указывает data. Если swap отлично от нуля, то функция переставляет байты, если это необходимо, для соответствия типу данных, так как скаляры массивов всегда имеют корректный порядок байтов машины.

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

Возвращает объект скаляра массива типа и размера элементов, указанных объектом массива arr, скопированный из памяти, на которую указывает data, и меняющий порядок байтов, если порядок байтов в arr не соответствует порядку байтов машины.

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

Возвращает массив размерности 0 типа, определяемого outcode, из scalar, который должен быть объектом скаляра массива. Если outcode равен NULL, то тип определяется из scalar.

void PyArray_ScalarAsCtype(PyObject* scalar, void* ctypeptr)

Возвращает в ctypeptr указатель на фактическое значение в скаляре массива. Проверка ошибок не выполняется, поэтому scalar должен быть объектом скаляра массива, а ctypeptr должен иметь достаточный размер для хранения корректного типа. Для типов с гибким размером указатель на данные копируется в память ctypeptr, для всех остальных типов фактические данные копируются в адрес, на который указывает ctypeptr.

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

Возвращает данные (преобразованные к типу, указанному outcode) из скаляра массива scalar в память, на которую указывает ctypeptr (размер памяти должен быть достаточным для обработки поступающей памяти).

PyObject* PyArray_TypeObjectFromType(int type)

Возвращает объект скалярного типа из номера типа type. Эквивалентно PyArray_DescrFromType (type)->typeobj, за исключением учёта ссылок и проверки ошибок. Возвращает новую ссылку на объект типа при успехе или NULL при ошибке.

NPY_SCALARKIND PyArray_ScalarKind(int typenum, PyArrayObject** arr)

См. функцию PyArray_MinScalarType для альтернативного механизма, введённого в NumPy 1.6.0.

Возвращает вид скаляра, представленного typenum и массивом в *arr (если arr не NULL ). Массив предполагается ранга 0 и используется только в том случае, если typenum представляет целое число со знаком. Если arr не NULL и первый элемент отрицательный, то возвращается NPY_INTNEG_SCALAR, в противном случае возвращается NPY_INTPOS_SCALAR. Возможные значения возврата — NPY_{kind}_SCALAR, где {kind} может быть INTPOS, INTNEG, FLOAT, COMPLEX, BOOL или OBJECT. NPY_NOSCALAR также является перечисленным значением NPY_SCALARKIND переменные могут принимать.

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

См. функцию PyArray_ResultType для получения подробностей о повышении точности типа в NumPy, обновлённого в NumPy 1.6.0.

Реализует правила приведения скаляров. Скаляры неявно приводятся только от thistype к neededtype, если эта функция возвращает ненулевое значение. Если скаляр NPY_NOSCALAR, то эта функция эквивалентна PyArray_CanCastSafely. Правило состоит в том, что скаляры одного вида могут быть приведены к массивам того же вида. Это правило означает, что скаляры высокой точности никогда не приведут к повышению точности массивов низкой точности того же вида.

Описатели типов данных

int PyArray_DescrCheck(PyObject* obj)

Оценивается как истинное, если obj является объектом типа данных ( PyArray_Descr * ).

PyArray_Descr* PyArray_DescrNew(PyArray_Descr* obj)

Возвращает новый объект типа данных, скопированный из obj (ссылки на поля просто обновляются, так что новый объект указывает на тот же словарь полей, если он есть).

PyArray_Descr* PyArray_DescrNewFromType(int typenum)

Создаёт новый объект типа данных из встроенного (или зарегистрированного пользователем) типа данных, указанного typenum. Все встроенные типы не должны иметь изменённых полей. Это создаёт новую копию структуры PyArray_Descr, чтобы вы могли заполнить её соответствующим образом. Эта функция особенно необходима для типов данных с гибким размером, которые должны иметь новый член elsize, чтобы иметь смысл в построении массива.

PyArray_Descr* PyArray_DescrNewByteorder(PyArray_Descr* obj, char newendian)

Создаёт новый объект типа данных с порядком байтов, установленным в соответствии с newendian. Все ссылки на объекты типов данных (в членах subdescr и fields объекта типа данных) также изменяются (рекурсивно). Если встречается порядок байтов NPY_IGNORE, он оставляется без изменений. Если newendian равно NPY_SWAP, то все порядки байтов меняются местами. Другие допустимые значения newendian — NPY_NATIVE, NPY_LITTLE и NPY_BIG, которые все заставляют возвращаемый описатель типа данных (и все ссылающиеся на него описатели типов данных) иметь соответствующий порядок байтов.

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

Определяет подходящий объект типа данных из объекта op (который должен быть объектом «вложенной» последовательности) и минимального описателя типа данных mintype (который может быть NULL). Поведение аналогично array(op).dtype. Не путайте эту функцию с PyArray_DescrConverter. Эта функция по существу рассматривает все объекты в (вложенной) последовательности и определяет тип данных по элементам, которые она находит.

PyArray_Descr* PyArray_DescrFromScalar(PyObject* scalar)

Возвращает объект типа данных из объекта скаляра массива. Проверка, что scalar является скаляром массива, не выполняется. Если подходящий тип данных определить невозможно, по умолчанию возвращается тип данных NPY_OBJECT.

PyArray_Descr* PyArray_DescrFromType(int typenum)

Возвращает объект типа данных, соответствующий typenum. typenum может быть одним из перечисленных типов, кодом символа для одного из перечисленных типов или пользовательским типом.

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

Преобразовать любой совместимый объект Python, obj, в объект типа данных в dtype. Большое количество объектов Python можно преобразовать в объекты типа данных. Полное описание см. в Объектах типа данных (dtype). Эта версия преобразователя преобразует объекты None в объект типа данных NPY_DEFAULT_TYPE. Эта функция может использоваться с кодом символа «O&» в PyArg_ParseTuple обработке.

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

Преобразовать любой совместимый объект Python, obj, в объект типа данных в dtype. Эта версия преобразователя преобразует объекты None таким образом, чтобы возвращаемый тип данных был NULL. Эта функция также может использоваться с символом «O&» в обработке PyArg_ParseTuple.

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. Второй аргумент — адрес типа C, в который преобразуется объект Python.

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

Преобразует любой объект Python в PyArrayObject. Если PyArray_Check (obj) истинно, то его счётчик ссылок увеличивается, и ссылка помещается в address. Если obj не является массивом, то он преобразуется в массив с помощью PyArray_FromAny. Независимо от возвращаемого значения, вы должны DECREF объект, возвращаемый этой процедурой в address, когда вы закончите с ним.

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 содержит указатель на память, которую необходимо освободить, чтобы избежать утечки памяти. Ограничение на размер памяти позволяет удобно использовать этот преобразователь для последовательностей, предназначенных для интерпретации в качестве форм массива.

int PyArray_BufferConverter(PyObject* obj, PyArray_Chunk* buf)

Преобразует любой объект Python, obj, с интерфейсом буфера (с одним сегментом) в переменную с полями, которые подробно описывают использование объекта в его блоке памяти. Переменная buf — указатель на структуру с полями base, ptr, len и flags. Структура PyArray_Chunk двоично совместима с объектом буфера Python (через поле len на 32-битных платформах и поле ptr на 64-битных платформах или в Python 2.5). При возврате поле base устанавливается в obj (или его base, если obj уже является объектом буфера, указывающим на другой объект). Если вам нужно сохранить память, убедитесь, что INCREF поля base. К блоку памяти обращается поле buf ->ptr, и его длина равна buf ->len. Поле flags в buf равно NPY_BEHAVED_RO с установленным флагом NPY_ARRAY_WRITEABLE, если obj имеет интерфейс записываемого буфера.

int PyArray_AxisConverter(PyObject * obj, int* axis)

Преобразует объект Python, obj, представляющий аргумент оси, в соответствующее значение для передачи функциям, принимающим целочисленную ось. В частности, если obj равно None, axis устанавливается в NPY_MAXDIMS, что интерпретируется правильно функциями C-API, принимающими аргументы оси.

int PyArray_BoolConverter(PyObject* obj, Bool* value)

Преобразовать любой объект Python, obj, в NPY_TRUE или NPY_FALSE и поместить результат в value.

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»).

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)

Преобразует последовательность режимов обрезки или одиночный режим обрезки в массив C значений NPY_CLIPMODE. Количество режимов обрезки 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 в целые числа размером с указатель (до maxvals) и размещение их в массиве vals. Длина списка может быть меньше maxvals, и возвращается фактическое количество преобразованных элементов.

int PyArray_TypestrConvert(int itemsize, int gentype)

Преобразование символов типа строки (с itemsize) в базовые перечисленные типы данных. Распознаются и преобразуются символы типов строковых представлений для целых чисел со знаком и без знака, чисел с плавающей точкой и комплексных чисел с плавающей точкой. Другие значения 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 (например, myextension_ARRAY_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

Вы также можете поместить две последние строки в локальный заголовок расширения, убедившись, что NO_IMPORT_ARRAY определён перед #include этого файла.

Проверка версии 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. Обнаружение несовместимости API было добавлено в numpy 1.4.0. Если вы хотите поддерживать множество разных версий numpy с одной двоичной программой расширения, вам необходимо скомпилировать ваше расширение с наименьшим возможным NPY_FEATURE_VERSION.

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, 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, должен ожидать массив в качестве аргумента и должен возвращать строку для вывода.

Управление памятью

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, то используется выделение памяти Python.

Поддержка многопоточности

Эти макросы имеют смысл только если NPY_ALLOW_THREADS истинно во время компиляции модуля расширения. В противном случае эти макросы эквивалентны пробелу. Python использует единственную глобальную блокировку интерпретатора (GIL) для каждого процесса Python, так что только один поток может выполняться одновременно (даже на многоядерных машинах). При вызове компилированной функции, которая может занимать много времени для вычисления (и не имеет побочных эффектов для других потоков, таких как обновление глобальных переменных), GIL должен быть освобождён, чтобы другие потоки Python могли выполняться, пока выполняются длительные вычисления. Это можно сделать, используя две группы макросов. Обычно, если используется один макрос из группы в блоке кода, все макросы из этой группы должны использоваться в том же блоке кода. В настоящее время NPY_ALLOW_THREADS определяется как константа Python WITH_THREADS , за исключением случаев, когда переменная окружения NPY_NOSMP установлена, в этом случае NPY_ALLOW_THREADS определяется как 0.

Группа 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 из сохраненной переменной.

NPY_BEGIN_THREADS_DESCR(PyArray_Descr *dtype)

Полезно для освобождения GIL только в том случае, если dtype не содержит произвольных объектов Python, которые могут потребовать интерпретатор Python во время выполнения цикла. Эквивалентно

NPY_END_THREADS_DESCR(PyArray_Descr *dtype)

Полезно для повторного получения GIL в ситуациях, когда он был освобожден с помощью формы BEGIN этого макроса.

NPY_BEGIN_THREADS_THRESHOLDED(int loop_size)

Полезно для освобождения GIL только в том случае, если loop_size превышает минимальный порог, который в настоящее время установлен в 500. Должен быть сопоставлен с .. c:macro::NPY_END_THREADS для повторного получения GIL.

Группа 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__ (преобразованный в двойное значение) объекта obj или def, если атрибут с таким именем не существует. Предоставляются быстрые возвраты, которые избегают поиска атрибутов для объектов типа PyArray_Type.

Буферы по умолчанию

NPY_BUFSIZE

Размер по умолчанию для настраиваемых внутренних буферов.

NPY_MIN_BUFSIZE

Минимальный размер настраиваемых внутренних буферов.

NPY_MAX_BUFSIZE

Максимальный разрешенный размер настраиваемых буферов.

Другие константы

NPY_NUM_FLOATTYPE

Количество типов с плавающей запятой.

NPY_MAXDIMS

Максимальное количество измерений, разрешенных в массивах.

NPY_VERSION

Текущая версия объекта ndarray (проверьте, определена ли эта переменная, чтобы гарантировать использование заголовка numpy/arrayobject.h).

NPY_FALSE

Определено как 0 для использования с Bool.

NPY_TRUE

Определено как 1 для использования с Bool.

NPY_FAIL

Значение возврата функций-конвертеров с ошибкой, которые вызываются с использованием синтаксиса “O&” в функциях типа PyArg_ParseTuple.

NPY_SUCCEED

Значение возврата успешных функций-конвертеров, которые вызываются с использованием синтаксиса “O&” в функциях типа PyArg_ParseTuple.

Различные макросы

PyArray_SAMESHAPE(a1, 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)

Реализует комплексные сравнения между двумя комплексными числами (структурами с членами real и imag) с использованием определения NumPy для упорядочивания, которое является лексикографическим: сравнение действительных частей сначала, а затем комплексных частей, если действительные части равны.

PyArray_REFCOUNT(PyObject* op)

Возвращает счетчик ссылок любого объекта Python.

PyArray_XDECREF_ERR(PyObject *obj)

Уменьшает счетчик ссылок объекта массива, который может иметь установленный флаг NPY_ARRAY_UPDATEIFCOPY, без копирования содержимого обратно в исходный массив. Сбрасывает флаг NPY_ARRAY_WRITEABLE в базовом объекте. Это полезно для восстановления из состояния ошибки, когда используется NPY_ARRAY_UPDATEIFCOPY.

Перечисленные типы

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

Разрешаются любые преобразования, независимо от того, какой вид потери данных может произойти.