ctypes foreign function interface (numpy.ctypeslib) — NumPy v2.3.dev0 Manual (original) (raw)

numpy.ctypeslib.as_array(obj, shape=None)[source]#

Create a numpy array from a ctypes array or POINTER.

The numpy array shares the memory with the ctypes object.

The shape parameter must be given if converting from a ctypes POINTER. The shape parameter is ignored if converting from a ctypes array

Examples

Converting a ctypes integer array:

import ctypes ctypes_array = (ctypes.c_int * 5)(0, 1, 2, 3, 4) np_array = np.ctypeslib.as_array(ctypes_array) np_array array([0, 1, 2, 3, 4], dtype=int32)

Converting a ctypes POINTER:

import ctypes buffer = (ctypes.c_int * 5)(0, 1, 2, 3, 4) pointer = ctypes.cast(buffer, ctypes.POINTER(ctypes.c_int)) np_array = np.ctypeslib.as_array(pointer, (5,)) np_array array([0, 1, 2, 3, 4], dtype=int32)

numpy.ctypeslib.as_ctypes(obj)[source]#

Create and return a ctypes object from a numpy array. Actually anything that exposes the __array_interface__ is accepted.

Examples

Create ctypes object from inferred int np.array:

inferred_int_array = np.array([1, 2, 3]) c_int_array = np.ctypeslib.as_ctypes(inferred_int_array) type(c_int_array) <class 'c_long_Array_3'> c_int_array[:] [1, 2, 3]

Create ctypes object from explicit 8 bit unsigned int np.array :

exp_int_array = np.array([1, 2, 3], dtype=np.uint8) c_int_array = np.ctypeslib.as_ctypes(exp_int_array) type(c_int_array) <class 'c_ubyte_Array_3'> c_int_array[:] [1, 2, 3]

numpy.ctypeslib.as_ctypes_type(dtype)[source]#

Convert a dtype into a ctypes type.

Parameters:

dtypedtype

The dtype to convert

Returns:

ctype

A ctype scalar, union, array, or struct

Raises:

NotImplementedError

If the conversion is not possible

Notes

This function does not losslessly round-trip in either direction.

np.dtype(as_ctypes_type(dt)) will:

as_ctypes_type(np.dtype(ctype)) will:

Examples

Converting a simple dtype:

dt = np.dtype('int8') ctype = np.ctypeslib.as_ctypes_type(dt) ctype <class 'ctypes.c_byte'>

Converting a structured dtype:

dt = np.dtype([('x', 'i4'), ('y', 'f4')]) ctype = np.ctypeslib.as_ctypes_type(dt) ctype <class 'struct'>

numpy.ctypeslib.load_library(libname, loader_path)[source]#

It is possible to load a library using

lib = ctypes.cdll[]

But there are cross-platform considerations, such as library file extensions, plus the fact Windows will just load the first library it finds with that name. NumPy supplies the load_library function as a convenience.

Changed in version 1.20.0: Allow libname and loader_path to take anypath-like object.

Parameters:

libnamepath-like

Name of the library, which can have ‘lib’ as a prefix, but without an extension.

loader_pathpath-like

Where the library can be found.

Returns:

ctypes.cdll[libpath]library object

A ctypes library object

Raises:

OSError

If there is no library with the expected extension, or the library is defective and cannot be loaded.

numpy.ctypeslib.ndpointer(dtype=None, ndim=None, shape=None, flags=None)[source]#

Array-checking restype/argtypes.

An ndpointer instance is used to describe an ndarray in restypes and argtypes specifications. This approach is more flexible than using, for example, POINTER(c_double), since several restrictions can be specified, which are verified upon calling the ctypes function. These include data type, number of dimensions, shape and flags. If a given array does not satisfy the specified restrictions, a TypeError is raised.

Parameters:

dtypedata-type, optional

Array data-type.

ndimint, optional

Number of array dimensions.

shapetuple of ints, optional

Array shape.

flagsstr or tuple of str

Array flags; may be one or more of:

Returns:

klassndpointer type object

A type object, which is an _ndtpr instance containing dtype, ndim, shape and flags information.

Raises:

TypeError

If a given array does not satisfy the specified restrictions.

Examples

clib.somefunc.argtypes = [np.ctypeslib.ndpointer(dtype=np.float64, ... ndim=1, ... flags='C_CONTIGUOUS')] ... clib.somefunc(np.array([1, 2, 3], dtype=np.float64)) ...

class numpy.ctypeslib.c_intp#

A ctypes signed integer type of the same size as numpy.intp.

Depending on the platform, it can be an alias for either c_int,c_long or c_longlong.