# C-Types foreign function interface (`numpy.ctypeslib`)

numpy.ctypeslib.as_array(obj, shape=None)

  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

numpy.ctypeslib.as_ctypes(obj)

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

numpy.ctypeslib.as_ctypes_type(dtype)

  Convert a dtype into a ctypes type.

  Parameters:
    dtype dtype

      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:

  > - insert padding fields

  > - reorder fields to be sorted by offset

  > - discard field titles

  `as_ctypes_type(np.dtype(ctype))` will:

  > - discard the class names of `ctypes.Structure`s and `ctypes.Union`s

  > - convert single-element `ctypes.Union`s into single-element `ctypes.Structure`s

  > - insert padding fields

numpy.ctypeslib.load_library(libname, loader_path)

  It is possible to load a library using

      >>> lib = ctypes.cdll[<full_path_name>]

  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 any path-like object.

  Parameters:
    libname path-like

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

    loader_path path-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)

  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:
    dtype data-type, optional

      Array data-type.

    ndim int, optional

      Number of array dimensions.

    shape tuple of ints, optional

      Array shape.

    flags str or tuple of str

      Array flags; may be one or more of:

      > - C_CONTIGUOUS / C / CONTIGUOUS

      > - F_CONTIGUOUS / F / FORTRAN

      > - OWNDATA / O

      > - WRITEABLE / W

      > - ALIGNED / A

      > - WRITEBACKIFCOPY / X

  Returns:
    klass ndpointer 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`.