As explained in the previous section, foreign functions can be accessed as attributes of loaded shared libraries. The function objects created in this way by default accept any number of arguments, accept any ctypes data instances as arguments, and return the default result type specified by the library loader. They are instances of a private class:
Instances of foreign functions are also C compatible data types; they represent C function pointers.
This behaviour can be customized by assigning to special attributes of the foreign function object.
voida function not returning anything.
It is possible to assign a callable Python object that is not a
ctypes type, in this case the function is assumed to return a
int, and the callable will be called with this integer,
allowing to do further processing or error checking. Using this
is deprecated, for more flexible postprocessing or error checking
use a ctypes data type as restype and assign a callable to the
stdcallcalling convention can only be called with the same number of arguments as the length of this tuple; functions using the C calling convention accept additional, unspecified arguments as well.
When a foreign function is called, each actual argument is passed to the from_param class method of the items in the argtypes tuple, this method allows to adapt the actual argument to an object that the foreign function accepts. For example, a c_char_p item in the argtypes tuple will convert a unicode string passed as argument into an byte string using ctypes conversion rules.
New: It is now possible to put items in argtypes which are not ctypes types, but each item must have a from_param method which returns a value usable as argument (integer, string, ctypes instance). This allows to define adapters that can adapt custom objects as function parameters.
|result, func, arguments)|
resultis what the foreign function returns, as specified by the restype attribute.
func is the foreign function object itself, this allows to
reuse the same callable object to check or postprocess the results
of several functions.
arguments is a tuple containing the parameters originally
passed to the function call, this allows to specialize the
behaviour on the arguments used.
The object that this function returns will be returned from the foreign function call, but it can also check the result value and raise an exception if the foreign function call failed.
See About this document... for information on suggesting changes.