सी

Question

से पाइथन कक्षा को परिभाषित करें मैंने पाइथन के लिए कुछ सी कोड लपेट लिया है और यह काम करता है। सी मॉड्यूल एक हैंडल बनाता है, जिसे मैं पाइथन को PyCapsule के रूप में पास करता हूं। एपीआई जो मैं चाहता हूं उसे पाइथन में बनाया जा सकता है जैसे:

import wrapped 

class Test(object): 
    def __init__(self, loc): 
     self.handle = wrapped.new(loc) 

    def foo(self, data): 
     return wrapped.foo(self.handle, data) 

तो प्रश्न अधिक कॉस्मेटिक मुद्दा है। क्या मुझे रैपर लपेटना है, या क्या मैं कोड को सी कोड में ऊपर दिखाए गए कोड को स्थानांतरित कर सकता हूं, यानी कार्यों के समूह के बजाय कक्षा को निर्यात कर सकता हूं?

Answer 1

हो सकता है कि यह आपका प्रश्न उत्तर न हो। लेकिन यह सहायक हो सकता है।

#include "boost/python.hpp" 

using namespace boost::python; 

int main() 
{ 
    Py_Initialize(); 
    object pyFunPlxMsgWrapper = import("your_module").attr("PlxMsgWrapper"); 
    pyFunPlxMsgWrapper(2, "string", "data"); 
    return 0; 
} 

Answer 2

हाँ, आप सी एपीआई से सी में अपने स्वयं के वर्ग प्रकार बना सकते हैं एक अजगर प्रकार/वर्ग अपने प्रकार के लिए उचित रूप से भरे गए PyTypeObject संरचना का एक उदाहरण है। ऐसा करने के लिए पूरी प्रक्रिया का पालन ट्यूटोरियल में अच्छी तरह से उल्लिखित है:

https://docs.python.org/2/extending/newtypes.html

यह प्रारंभिक कोर प्रकार को परिभाषित करने और फिर टाइप/वर्ग के लिए डेटा और विधियां जोड़ने के बारे में बताएंगे। सबसे पहले यह सी में लागू कक्षा प्राप्त करने के लिए बहुत ही भयानक काम की तरह प्रतीत हो सकता है, लेकिन एक बार जब आप इसे कुछ बार करते हैं और इसके साथ सहज महसूस करते हैं, तो यह वास्तव में इतना बुरा नहीं है।

यहां आपके प्रश्न में परिभाषित टेस्ट क्लास का एक नंगे हड्डियों का कार्यान्वयन है।

#include <Python.h> 
#include "structmember.h" 

typedef struct { 
    PyObject_HEAD 
    /* Your internal 'loc' data. */ 
    int loc; 
} Test; 

static void 
MyTest_dealloc(Test* self) 
{ 
    self->ob_type->tp_free((PyObject*)self); 
} 

static PyObject * 
Test_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 
{ 
    Test *self; 

    self = (Test *)type->tp_alloc(type, 0); 
    self->loc = 0; 

    return (PyObject *)self; 
} 

static int 
Test_init(Test *self, PyObject *args, PyObject *kwds) 
{ 
    if (! PyArg_ParseTuple(args, "i", &self->loc)) 
     return -1; 

    return 0; 
} 

static PyMemberDef Test_members[] = { 
    {"loc", T_INT, offsetof(Test, loc), 0, "mytestobj loc"}, 
    {NULL} /* Sentinel */ 
}; 

static PyObject * 
Test_foo(Test* self, PyObject *args) 
{ 
    int data; 
    PyObject *result; 

    if (! PyArg_ParseTuple(args, "i", &data)) { 
     return NULL; 
    } 

    /* We'll just return data + loc as our result. */ 
    result = Py_BuildValue("i", data + self->loc); 

    return result; 
} 
static PyMethodDef Test_methods[] = { 
    {"foo", (PyCFunction)Test_foo, METH_VARARGS, 
    "Return input parameter added to 'loc' argument from init.", 
    }, 
    {NULL} /* Sentinel */ 
}; 

static PyTypeObject mytest_MyTestType = { 
    PyObject_HEAD_INIT(NULL) 
    0,       /*ob_size*/ 
    "mytest.MyTest",    /*tp_name*/ 
    sizeof(Test), /*tp_basicsize*/ 
    0,       /*tp_itemsize*/ 
    (destructor)MyTest_dealloc,/*tp_dealloc*/ 
    0,       /*tp_print*/ 
    0,       /*tp_getattr*/ 
    0,       /*tp_setattr*/ 
    0,       /*tp_compare*/ 
    0,       /*tp_repr*/ 
    0,       /*tp_as_number*/ 
    0,       /*tp_as_sequence*/ 
    0,       /*tp_as_mapping*/ 
    0,       /*tp_hash */ 
    0,       /*tp_call*/ 
    0,       /*tp_str*/ 
    0,       /*tp_getattro*/ 
    0,       /*tp_setattro*/ 
    0,       /*tp_as_buffer*/ 
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/ 
    "MyTest objects",   /* tp_doc */ 
    0,       /* tp_traverse */ 
    0,       /* tp_clear */ 
    0,       /* tp_richcompare */ 
    0,       /* tp_weaklistoffset */ 
    0,       /* tp_iter */ 
    0,       /* tp_iternext */ 
    Test_methods,  /* tp_methods */ 
    Test_members,  /* tp_members */ 
    0,       /* tp_getset */ 
    0,       /* tp_base */ 
    0,       /* tp_dict */ 
    0,       /* tp_descr_get */ 
    0,       /* tp_descr_set */ 
    0,       /* tp_dictoffset */ 
    (initproc)Test_init,/* tp_init */ 
    0,       /* tp_alloc */ 
    Test_new,     /* tp_new */ 
}; 

static PyMethodDef mytest_methods[] = { 
    {NULL} /* Sentinel */ 
}; 

#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ 
#define PyMODINIT_FUNC void 
#endif 
PyMODINIT_FUNC 
initmytest(void) 
{ 
    PyObject* m; 

    if (PyType_Ready(&mytest_MyTestType) < 0) 
     return; 

    m = Py_InitModule3("mytest", mytest_methods, 
         "Example module that creates an extension type."); 

    Py_INCREF(&mytest_MyTestType); 
    PyModule_AddObject(m, "Test", (PyObject *)&mytest_MyTestType); 
} 

और अजगर दुभाषिया से इसके उपयोग:

>>> from mytest import Test 
>>> t = Test(5) 
>>> t.foo(10) 
15