Python Language
लेखन विस्तार

सी एक्सटेंशन के साथ हैलो वर्ल्ड

निम्न C स्रोत फ़ाइल (जिसे हम प्रदर्शन उद्देश्यों के लिए hello.c कहेंगे) एक hello नाम का एक विस्तार मॉड्यूल तैयार करती है जिसमें एक ही फ़ंक्शन 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

फ़ाइल को gcc संकलक के साथ संकलित करने के लिए, अपने पसंदीदा टर्मिनल में निम्न कमांड चलाएँ:

gcc /path/to/your/file/hello.c -o /path/to/your/file/hello

हमारे द्वारा पहले लिखे गए greet() फ़ंक्शन को निष्पादित करने के greet() , उसी निर्देशिका में एक फ़ाइल बनाएं और इसे hello.py

import hello          # imports the compiled library
hello.greet("Hello!") # runs the greet() function with "Hello!" as an argument

C एक्सटेंशन के लिए एक खुली फ़ाइल पास करना

पायथन से सी एक्सटेंशन कोड तक एक खुली फ़ाइल ऑब्जेक्ट पास करें।

आप PyObject_AsFileDescriptor फ़ंक्शन का उपयोग करके फ़ाइल को एक पूर्णांक फ़ाइल विवरणक में PyObject_AsFileDescriptor हैं:

PyObject *fobj;
int fd = PyObject_AsFileDescriptor(fobj);
if (fd < 0){
    return NULL;
}

एक पूर्णांक फ़ाइल डिस्क्रिप्टर को वापस अजगर ऑब्जेक्ट में बदलने के लिए, PyFile_FromFd उपयोग PyFile_FromFd ।

int fd; /* Existing file descriptor */
PyObject *fobj = PyFile_FromFd(fd, "filename","r",-1,NULL,NULL,NULL,1);

C ++ और Boost का उपयोग करके C एक्सटेंशन

यह C ++ और Boost का उपयोग करके C एक्सटेंशन का एक मूल उदाहरण है।

C ++ कोड

C ++ का कोड 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)
      ;   
}

एक अजगर मॉड्यूल में इसे संकलित करने के लिए आपको अजगर हेडर और बूस्ट लाइब्रेरी की आवश्यकता होगी। इस उदाहरण को Ubuntu 12.04 पर अजगर 3.4 और gcc का उपयोग करके बनाया गया था। कई प्लेटफार्मों पर बूस्ट का समर्थन किया जाता है। उबंटू के मामले में आवश्यक पैकेज का उपयोग करके स्थापित किया गया था:

sudo apt-get install gcc libboost-dev libpython3.4-dev

स्रोत फ़ाइल को एक .so-फ़ाइल में संकलित करना, जिसे बाद में एक मॉड्यूल के रूप में आयात किया जा सकता है बशर्ते वह अजगर पथ पर हो:

gcc -shared -o hello.so -fPIC -I/usr/include/python3.4 hello.cpp -lboost_python-py34 -lboost_system -l:libpython3.4m.so

फ़ाइल उदाहरण python में कोड:

import hello

print(hello.get_hello())

h = hello.Hello("World hello!")
print(h.as_list(3))

तब python3 example.py निम्नलिखित आउटपुट देगा:

Hello world!
['World hello!', 'World hello!', 'World hello!']