Python Academy · पाठ

Python C एक्सटेंशन मॉड्यूल लिखना

Python/C API का उपयोग करके एक सरल .so एक्सटेंशन बनाएँ।

पाठ 4, कुल 4 में से13 चरण

Python C एक्सटेंशन मॉड्यूल लिखना, CoddyKit पर Python Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Python Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Python Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

C एक्सटेंशन की संरचना

एक न्यूनतम C एक्सटेंशन में ये चीज़ें होती हैं: विधि फ़ंक्शन, एक विधि तालिका, मॉड्यूल-परिभाषा स्ट्रक्चर और एक PyInit_ प्रवेश-बिंदु।

// myext.c skeleton
#include <Python.h>

static PyObject* say_hello(PyObject* self, PyObject* args) {
    Py_RETURN_NONE;
}

static PyMethodDef methods[] = {
    {"say_hello", say_hello, METH_NOARGS, "Print hello"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef module = {
    PyModuleDef_HEAD_INIT, "myext", NULL, -1, methods
};

PyMODINIT_FUNC PyInit_myext(void) {
    return PyModule_Create(&module);
}

आर्ग्युमेंट पार्स करना

PyArg_ParseTuple(args, "ii", &a, &b) Python आर्ग्युमेंट को C चरों में पार्स करता है। फ़ॉर्मेट कोड: i=int, d=double, s=char*, O=PyObject*।

static PyObject* add(PyObject* self, PyObject* args) {
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b))
        return NULL;
    return PyLong_FromLong(a + b);
}

मान लौटाना

इनका उपयोग करके Python के लौटाए जाने वाले मान बनाएँ: PyLong_FromLong, PyFloat_FromDouble, PyUnicode_FromString, Py_BuildValue।

// Return a Python tuple (int, float)
static PyObject* stats(PyObject* self, PyObject* args) {
    int n = 10;
    double avg = 5.0;
    return Py_BuildValue("(id)", n, avg);
    // Py_BuildValue format: i=int d=double s=str
}

संदर्भ संख्या

हर PyObject* की एक संदर्भ संख्या होती है। Py_INCREF/Py_DECREF का सावधानी से उपयोग करें। C फ़ंक्शन से लौटाए गए मान कॉलर को स्वामित्व देते हैं (चुराए गए संदर्भ)।

static PyObject* make_list(PyObject* self, PyObject* args) {
    PyObject* lst = PyList_New(3);
    for (int i = 0; i < 3; i++) {
        // PyList_SET_ITEM steals the reference:
        PyList_SET_ITEM(lst, i, PyLong_FromLong(i));
    }
    return lst;   // caller owns the list
}

अपवाद उठाना

C से Python अपवाद उठाने के लिए PyErr_SetString(PyExc_ValueError, "msg") का उपयोग करें, फिर NULL लौटाएँ।

static PyObject* safe_div(PyObject* self, PyObject* args) {
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b)) return NULL;
    if (b == 0) {
        PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");
        return NULL;
    }
    return PyLong_FromLong(a / b);
}

C एक्सटेंशन के लिए setup.py

C स्रोत फ़ाइलों को घोषित करने के लिए setuptools.Extension का उपयोग करें। python setup.py build_ext --inplace से निर्माण करें।

# setup.py
from setuptools import setup, Extension

setup(
    name="myext",
    ext_modules=[
        Extension(
            "myext",
            sources=["myext.c"],
            extra_compile_args=["-O2"],
        )
    ]
)
# python setup.py build_ext --inplace
# import myext; myext.add(3, 4)

निर्मित एक्सटेंशन का उपयोग करना

निर्माण के बाद एक्सटेंशन को किसी भी Python मॉड्यूल की तरह इम्पोर्ट करें। Python myext.so (या Windows पर .pyd) को खोजकर इसे ढूँढता है।

# After: python setup.py build_ext --inplace
import myext
print(myext.add(3, 4))        # 7
print(myext.safe_div(10, 2))  # 5
# myext.safe_div(1, 0)         # ZeroDivisionError

कीवर्ड आर्ग्युमेंट

C फ़ंक्शन में कीवर्ड आर्ग्युमेंट का समर्थन करने के लिए कीवर्ड सूची के साथ PyArg_ParseTupleAndKeywords का उपयोग करें।

static char* kwargs[] = {"x", "y", NULL};

static PyObject* hypot_c(PyObject* self,
                          PyObject* args,
                          PyObject* kw) {
    double x, y;
    if (!PyArg_ParseTupleAndKeywords(args, kw, "dd",
                                     kwargs, &x, &y))
        return NULL;
    return PyFloat_FromDouble(sqrt(x*x + y*y));
}

मॉड्यूल-स्तरीय स्थिरांक

PyModule_AddIntConstant का उपयोग करके PyInit_ में मॉड्यूल में पूर्णांक या स्ट्रिंग स्थिरांक जोड़ें।

PyMODINIT_FUNC PyInit_myext(void) {
    PyObject* m = PyModule_Create(&module);
    if (!m) return NULL;
    PyModule_AddIntConstant(m, "VERSION", 1);
    PyModule_AddStringConstant(m, "AUTHOR", "Alice");
    return m;
}

GIL रिलीज़ करना

अन्य Python थ्रेड को C कोड के चलने के दौरान कार्य करने देने के लिए शुद्ध C कार्य को Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS के बीच रखें।

static PyObject* heavy(PyObject* self, PyObject* args) {
    long n;
    if (!PyArg_ParseTuple(args, "l", &n)) return NULL;
    long result;
    Py_BEGIN_ALLOW_THREADS
        result = slow_c_computation(n);  // GIL released
    Py_END_ALLOW_THREADS
    return PyLong_FromLong(result);
}

एक्सटेंशन का परीक्षण

pytest का उपयोग करके C एक्सटेंशन का उनके Python इंटरफ़ेस के माध्यम से परीक्षण करें। किसी विशेष C परीक्षण टूल की आवश्यकता नहीं है।

# test_myext.py
import pytest
import myext

def test_add(): assert myext.add(3, 4) == 7
def test_zero_div():
    with pytest.raises(ZeroDivisionError):
        myext.safe_div(1, 0)

त्वरित जाँच

Python अपवाद सेट हो जाने का संकेत देने के लिए C एक्सटेंशन फ़ंक्शन को क्या लौटाना चाहिए?

पुनरावलोकन

C एक्सटेंशन के लिए आवश्यक हैं: विधि फ़ंक्शन (आर्ग्युमेंट पार्स करना और PyObject* लौटाना), एक विधि तालिका, एक मॉड्यूल-परिभाषा स्ट्रक्चर और PyInit_name()। PyErr_SetString से अपवाद सेट करके और NULL लौटाकर अपवाद उठाएँ। शुद्ध C कार्य के लिए GIL रिलीज़ करें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
76
पाठ
320

अक्सर पूछे जाने वाले प्रश्न

क्या “Python C एक्सटेंशन मॉड्यूल लिखना” पाठ निःशुल्क है?

हाँ—“Python C एक्सटेंशन मॉड्यूल लिखना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Python Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Python Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Python C एक्सटेंशन मॉड्यूल लिखना” में मैं क्या सीखूँगा?

Python/C API का उपयोग करके एक सरल .so एक्सटेंशन बनाएँ। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Python Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Python Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Python Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“Python C एक्सटेंशन मॉड्यूल लिखना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Python Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Python Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. C एक्सटेंशन क्यों? उपयोग और समझौते
  2. ctypes: Python से C लाइब्रेरी कॉल करना
  3. cffi: C फ़ॉरेन फ़ंक्शन इंटरफ़ेस
  4. Python C एक्सटेंशन मॉड्यूल लिखना
← Python Academy पर वापस जाएँ