Your SlideShare is downloading. ×
0
C!

ctypes
extending python was never easier!
Anant Narayanan
Malaviya National Institute of Technology
So what is python?
• Dynamically typed, interpreted
language
prototyping
• Allows for fastinterpreter , thanks to
the awes...
How does python
work?
Classic implementation
• C language, also known written in the
as CPython
API to communicate
• Provi...
Python
Fundamentals
• Simple set of data types
• string, int/long, float and unicode
Every function
• an object , class or...
C fundamentals
data types
• Rich set ofpointers! , including the
infamous

•
•
•

Basic types: int, char, double, float, w...
The need for
bindings
The
• a lotpython standard library provides
of useful functionality

•

However, python’s success is...
The “good old” way
•

use functions defined by “Python.h”
to export objects:

•
•
•
•
•

PyObject *obj
PyArg_ParseTuple
Py...
The “good old” way
• Good for simple libraries
• Tends to be very monotonous
pyGTK uses code-generation instead
•
Converts...
SWIG: The Next Step
• Abstracts code-generation
defines function
• Single “interface” filethen converted
prototypes, which...
What’s wrong with
SWIG?

•

Need to learn the swig “interface”
language

• Produces computer-generated code
•
•

Ugly to r...
Enter ctypes!
An even higher layer of abstraction

•
Code generation done at memory
• level
Allows dynamic execution of
• ...
What does this
mean?
extend python with functions from C

• libraries - easy bindings written in
pure python

•

write you...
How does it work?
import
ctypes
import your library
prepare
parameters
call the (next)
function
Extending Python with ctyp...
Searching for
libraries
•

ctypes.util.find_library

•
•
•

Runs `ldconfig `, `gcc` and `objdump`
Returns filename of the ...
Importing libraries
• ctypes.CDLL (nam e, m ode, handle)
•
•

Represents a loaded shared library

•

Functions are assumed...
Importing libraries
•

preset library loaders available (just
call cdll)

• Or manually load with LibraryLoader
and LoadLi...
Accessing functions
•

All functions are exported as
attributes of the CDLL/PyDLL class

Functions
• _FuncPtr are objects ...
Type conversion
• int/ long, None, strings and unicode
objects are automatically converted
for you!

•

any types other th...
•
•

Some common
ctypes
Mutable
• c_char, c_wchar, c_byte, c_ubyte
• c_short, c_ushort
• c_int, c_uint, c_long, c_ulong, c...
Mutability for
strings
•

st = “Hello World!”
nt = c_char_p(st)
print nt
# returns c_char_p(“Hello World!”)
nt.value = “By...
Specifying
parameter types
Set the argtypes
• function object attribute for the

• This attribute is a sequence of ctypes:...
Specifying return
types
Set the restype
• function object attribute for the
This
• validattribute corresponds to any
ctype...
Using Pointers
• Use the quick and easy byref function
• Or construct a proper pointer ctype
be accessed
• Value canattrib...
Structures & Unions
structures are defined
• Allthe structure base classas children
of

•

The _fields_ attribute is a lis...
Structures & Unions
•

Similarly Unions are extended from
the union base class

Both are
• instance initialized by creatin...
Forward
declarations
The _fields_ attribute
• elements that haven't can't contain
been declared

•

However, you can alway...
Arrays
Simply multiply the base
• with a positive integer! element type
•

myArray = (c_int * 5)(, 2, 3, 4, 5)
for i in ra...
Typecasting
•

ctypes will automatically accept arrays
of a base type, where it was expecting
just the base type

• In all...
Callbacks
of the
• Function pointers arebe created by
CFUNCTYPE and can
instantiating that class

• The result type is the...
What now?
•

Clearly, wrapping libraries in ctypes is
far easier, and more maintainable

• Not much performance loss (code...
Upcoming SlideShare
Loading in...5
×

Extending Python with ctypes

697

Published on

A guide to using ctypes to add functionality from C libraries to Python.

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
697
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
17
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Transcript of "Extending Python with ctypes"

  1. 1. C! ctypes extending python was never easier! Anant Narayanan Malaviya National Institute of Technology
  2. 2. So what is python? • Dynamically typed, interpreted language prototyping • Allows for fastinterpreter , thanks to the awesome • The interpreter revolutionized how programmers attacked problems • Emphasizes simplicity Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  3. 3. How does python work? Classic implementation • C language, also known written in the as CPython API to communicate • Provides “an-Land” and “Python-Land” between C • Standard functions to convert C data types to python types and vice-versa Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  4. 4. Python Fundamentals • Simple set of data types • string, int/long, float and unicode Every function • an object , class or data type is • These objects are, in reality, wrappers over corresponding C types python functions implemented • Basichigher level functions in python in C, itself Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  5. 5. C fundamentals data types • Rich set ofpointers! , including the infamous • • • Basic types: int, char, double, float, w_char_t Arrays: char*, w_char_t*, int* Structures and Unions Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  6. 6. The need for bindings The • a lotpython standard library provides of useful functionality • However, python’s success is mainly attributed to the availability of bindings to many popular libraries • Gtk+, wxWidgets, openGL, SDL, cdrecord, Gnome etc... Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  7. 7. The “good old” way • use functions defined by “Python.h” to export objects: • • • • • PyObject *obj PyArg_ParseTuple Py_BuildValue Py_INCREF, Py_DECREF PyModule_AddObject, Py_InitModule Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  8. 8. The “good old” way • Good for simple libraries • Tends to be very monotonous pyGTK uses code-generation instead • Converts function prototypes found • in C Header files to scheme-like `def' files, which are then parsed to generated Python Module code Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  9. 9. SWIG: The Next Step • Abstracts code-generation defines function • Single “interface” filethen converted prototypes, which is to appropriate C binding code only generates code for python • Not PHP, Perl, Ruby and Java too , but • Used by Subversion and other major projects Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  10. 10. What’s wrong with SWIG? • Need to learn the swig “interface” language • Produces computer-generated code • • Ugly to read! Impossible to debug! • Additional dependency and build routine Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  11. 11. Enter ctypes! An even higher layer of abstraction • Code generation done at memory • level Allows dynamic execution of • functions in a shared library • .dll, .so and .dylib supported Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  12. 12. What does this mean? extend python with functions from C • libraries - easy bindings written in pure python • write your callback functions in python and call them from C • use python as a true “glue” language: interconnecting several libraries to create large, coherent programs Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  13. 13. How does it work? import ctypes import your library prepare parameters call the (next) function Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  14. 14. Searching for libraries • ctypes.util.find_library • • • Runs `ldconfig `, `gcc` and `objdump` Returns filename of the library OS X: Standard paths are looked in; absolute path of dylib returned Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  15. 15. Importing libraries • ctypes.CDLL (nam e, m ode, handle) • • Represents a loaded shared library • Functions are assumed to return int Functions in these libraries are called using the standard calling convention of C ctypes.PyDLL (nam e, m ode, handle) • • Python GIL is not released, hence exceptions are caught and returned. Useful for using the python C API itself! Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  16. 16. Importing libraries • preset library loaders available (just call cdll) • Or manually load with LibraryLoader and LoadLibrary instance • pythonapi represents anAPI loadedof PyDLL with the CPython • Also available: windll, oledll Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  17. 17. Accessing functions • All functions are exported as attributes of the CDLL/PyDLL class Functions • _FuncPtr are objects of type • Called just like regular python callables • But remember to first convert the parameters! Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  18. 18. Type conversion • int/ long, None, strings and unicode objects are automatically converted for you! • any types other than these must first be converted using the data types provided by ctypes • python type data type ctype Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune C
  19. 19. • • Some common ctypes Mutable • c_char, c_wchar, c_byte, c_ubyte • c_short, c_ushort • c_int, c_uint, c_long, c_ulong, c_float, c_double Immutable • c_char_p, c_wchar_p, c_void_p Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  20. 20. Mutability for strings • st = “Hello World!” nt = c_char_p(st) print nt # returns c_char_p(“Hello World!”) nt.value = “Bye Bye World!” print nt # returns c_char_p(“Bye Bye World!”) print st # returns “Hello World!” • Use • • create_string_buffer(< bytes> ) create_string_buffer(< string> ) Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  21. 21. Specifying parameter types Set the argtypes • function object attribute for the • This attribute is a sequence of ctypes: • • myfunc.argtypes = [c_char_p, c_int, c_double] Setting this attribute will ensure that function is called with the correct number and types of attributes, and will also convert where possible Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  22. 22. Specifying return types Set the restype • function object attribute for the This • validattribute corresponds to any ctype • Also possible to set it as a python callable if the actual return type is an integer In this case, will be • invoked withthe callableresult; and the the actual Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune result of the callable will appear to be
  23. 23. Using Pointers • Use the quick and easy byref function • Or construct a proper pointer ctype be accessed • Value canattribute, and by the contents also by offset you don • Use byref whenlater on 't need the pointer object Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  24. 24. Structures & Unions structures are defined • Allthe structure base classas children of • The _fields_ attribute is a list of 2tuples, containing a field name and a field type • The field name is any valid python identifier and the field type is any valid ctype. Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  25. 25. Structures & Unions • Similarly Unions are extended from the union base class Both are • instance initialized by creating an of the class • Bit fields are also possible bit-length • Pass the of each listof the field as the 3 tuple in the _fields_ rd attribute Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  26. 26. Forward declarations The _fields_ attribute • elements that haven't can't contain been declared • However, you can always define or add to the _fields_ attribute later! Be careful • before youof using your structure have finalized your _fields_, this could lead to inconsistencies Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  27. 27. Arrays Simply multiply the base • with a positive integer! element type • myArray = (c_int * 5)(, 2, 3, 4, 5) for i in range(5): print myArray[i] and object that represent • ...Or create and instantiate it your array • Arrays are proper ctypes, so you can include them in your structures and other complex types Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  28. 28. Typecasting • ctypes will automatically accept arrays of a base type, where it was expecting just the base type • In all other cases: strict type checking! cast function to typecast one • Use theanother type to • obj = (c_byte * 10)() castedObj = cast(obj, POINTER(c_int)) Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  29. 29. Callbacks of the • Function pointers arebe created by CFUNCTYPE and can instantiating that class • The result type is the first argument, followed by the arguments that your callback function must expect Connect the function pointer to the actual python callback by instantiating the object returned by CFUNCTYPE Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune •
  30. 30. What now? • Clearly, wrapping libraries in ctypes is far easier, and more maintainable • Not much performance loss (code generation at runtime) Extending Python with ctypes | Anant Narayanan | Gnunify ’07, Pune
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×