Python Language
Extensiones de escritura
Buscar..
Hola mundo con extensión C
El siguiente archivo fuente de C (que llamaremos hello.c
para propósitos de demostración) produce un módulo de extensión llamado hello
que contiene una función simple greet()
:
#include <Python.h>
#include <stdio.h>
#if PY_MAJOR_VERSION >= 3
#define IS_PY3K
#endif
static PyObject *hello_greet(PyObject *self, PyObject *args)
{
const char *input;
if (!PyArg_ParseTuple(args, "s", &input)) {
return NULL;
}
printf("%s", input);
Py_RETURN_NONE;
}
static PyMethodDef HelloMethods[] = {
{ "greet", hello_greet, METH_VARARGS, "Greet the user" },
{ NULL, NULL, 0, NULL }
};
#ifdef IS_PY3K
static struct PyModuleDef hellomodule = {
PyModuleDef_HEAD_INIT, "hello", NULL, -1, HelloMethods
};
PyMODINIT_FUNC PyInit_hello(void)
{
return PyModule_Create(&hellomodule);
}
#else
PyMODINIT_FUNC inithello(void)
{
(void) Py_InitModule("hello", HelloMethods);
}
#endif
Para compilar el archivo con el compilador gcc
, ejecute el siguiente comando en su terminal favorito:
gcc /path/to/your/file/hello.c -o /path/to/your/file/hello
Para ejecutar la función greet()
que escribimos anteriormente, cree un archivo en el mismo directorio y hello.py
import hello # imports the compiled library
hello.greet("Hello!") # runs the greet() function with "Hello!" as an argument
Pasando un archivo abierto a C Extensions
Pase un objeto de archivo abierto de Python a código de extensión C.
Puede convertir el archivo a un descriptor de archivo entero usando la función PyObject_AsFileDescriptor
:
PyObject *fobj;
int fd = PyObject_AsFileDescriptor(fobj);
if (fd < 0){
return NULL;
}
Para convertir un descriptor de archivo entero de nuevo en un objeto de Python, use PyFile_FromFd
.
int fd; /* Existing file descriptor */
PyObject *fobj = PyFile_FromFd(fd, "filename","r",-1,NULL,NULL,NULL,1);
Extensión C usando c ++ y Boost
Este es un ejemplo básico de una extensión C que usa C ++ y Boost .
Código C ++
Código C ++ puesto en hello.cpp:
#include <boost/python/module.hpp>
#include <boost/python/list.hpp>
#include <boost/python/class.hpp>
#include <boost/python/def.hpp>
// Return a hello world string.
std::string get_hello_function()
{
return "Hello world!";
}
// hello class that can return a list of count hello world strings.
class hello_class
{
public:
// Taking the greeting message in the constructor.
hello_class(std::string message) : _message(message) {}
// Returns the message count times in a python list.
boost::python::list as_list(int count)
{
boost::python::list res;
for (int i = 0; i < count; ++i) {
res.append(_message);
}
return res;
}
private:
std::string _message;
};
// Defining a python module naming it to "hello".
BOOST_PYTHON_MODULE(hello)
{
// Here you declare what functions and classes that should be exposed on the module.
// The get_hello_function exposed to python as a function.
boost::python::def("get_hello", get_hello_function);
// The hello_class exposed to python as a class.
boost::python::class_<hello_class>("Hello", boost::python::init<std::string>())
.def("as_list", &hello_class::as_list)
;
}
Para compilar esto en un módulo de python, necesitarás los encabezados de python y las bibliotecas boost. Este ejemplo se hizo en Ubuntu 12.04 usando python 3.4 y gcc. Boost es compatible con muchas plataformas. En el caso de Ubuntu, los paquetes necesarios se instalaron usando:
sudo apt-get install gcc libboost-dev libpython3.4-dev
Compilando el archivo fuente en un archivo .so que luego se puede importar como un módulo siempre que esté en la ruta de acceso de python:
gcc -shared -o hello.so -fPIC -I/usr/include/python3.4 hello.cpp -lboost_python-py34 -lboost_system -l:libpython3.4m.so
El código de python en el archivo example.py:
import hello
print(hello.get_hello())
h = hello.Hello("World hello!")
print(h.as_list(3))
Entonces python3 example.py
dará el siguiente resultado:
Hello world!
['World hello!', 'World hello!', 'World hello!']