अजगर से डीएलएल तक दो आयामी सूची पास करना

सभी को नमस्कार। मैंने पायथन से C / C ++ लेख को थोड़ा पूरक करने का निर्णय लिया।

इंट, बूल, फ्लोट आदि जैसे मानक प्रकार पास करना बहुत सरल है, लेकिन बहुत आवश्यक नहीं है। पायथन खुद इस तरह के डेटा का सामना जल्दी करेगा, और यह संभावना नहीं है कि किसी को भी इस तरह के कोड का हिस्सा C / C ++ लाइब्रेरी में ट्रांसफर करना होगा।

लेकिन बड़े डेटा सरणियों का स्थानांतरण, या इससे भी बेहतर दो आयामी डेटा सरणियों, या वस्तुओं के दो आयामी सरणियों।

यहां सब कुछ इतना स्पष्ट नहीं है, और कई चीजें हैं जो मुझे लगता है कि उन लोगों के लिए हाइलाइट किया जा सकता है जो अजगर इंटरप्रेटर के लिए कोड अनुभागों को काफी तेज करना चाहते हैं।

कट के तहत दिया गया उदाहरण उपयोग के लिए बहुत उपयोगी नहीं है, लेकिन मुझे लगता है कि इस प्रक्रिया की सभी बारीकियों को उजागर करने के लिए पर्याप्त है।

लाइब्रेरी फ़ाइलों का स्रोत कोड तुरंत दें।

py_list2c_array.h

#ifndef _PY_LIST_2_C_ARRAY_H_ #define _PY_LIST_2_C_ARRAY_H_ #include <stdio.h> typedef struct { int value; wchar_t* name; } Item; extern "C" __declspec(dllexport) int sum_diagonal(Item** field, size_t size); #endif 

py_list2c_array.cpp

यहाँ भी सब कुछ मानक है, सिवाय इसके कि मैं wprint_ (*) ​​की तरह मुद्रण लाइनों के लिए फ़ंक्शन का उपयोग नोट करता हूं।

 // py_list2c_array.cpp:      DLL. // #include "stdafx.h" #include "py_list2c_array.h" extern "C" __declspec(dllexport) int sum_diagonal(Item** field, size_t size) { int result = 0; for(size_t i=0; i<size;++i) { for(size_t j=0; j<size; ++j) { if(i == j) { result += field[i][j].value; wprintf(L"%s\n", field[i][j].name); } } } return result; } 

py_list2c_array.py

और अब सबसे महत्वपूर्ण बात। मैं महत्वपूर्ण बिंदुओं के विवरण के साथ एक पायथन स्क्रिप्ट का स्रोत कोड दूंगा।

 import ctypes class PyItem: def __init__(self, value, name): self.value = value self.name = name class CItem(ctypes.Structure): _fields_ = [ ('value', ctypes.c_int), ('name', ctypes.c_wchar_p) ] def create_list(size): return [[PyItem(int(str(i+1)+str(j+1)), 'item{}{}'.format(i+1, j+1)) for j in range(size)] for i in range(size)] def py_list2c_array(py_list, size): rowType = CItem * size resultType = ctypes.POINTER(CItem) * size result = resultType() for i in range(size): row = rowType() for j in range(size): row[j] = CItem() row[j].value = py_list[i][j].value row[j].name = ctypes.c_wchar_p(py_list[i][j].name) result[i] = ctypes.cast(row, ctypes.POINTER(CItem)) return ctypes.cast(result, ctypes.POINTER(ctypes.POINTER(CItem))) if __name__ == '__main__': sLib = ctypes.cdll.LoadLibrary('./py_list2c_array.dll') size = 4 py_list = create_list(size) c_array = py_list2c_array(py_list, size) sLib.sum_diagonal.argtypes = [ctypes.POINTER(ctypes.POINTER(CItem)), ctypes.c_size_t] sLib.sum_diagonal.restype = ctypes.c_int result = sLib.sum_diagonal(c_array, ctypes.c_size_t(size)) print(': {}'.format(result)) 

विवरण

आइए ctypes सरणियों को बनाने की कुछ विशेषताओं पर विचार करें। ऐसा करने के लिए, हम सूची को py_list2c_array में परिवर्तित करने के कार्य पर बारीकी से विचार करेंगे आपको पहले प्रकार निर्दिष्ट करने होंगे।

सरणी में प्रत्येक पंक्ति के प्रकार को तत्वों की संख्या से गुणा किए गए तत्व के प्रकार के रूप में परिभाषित किया गया है।

rowType = CItem * आकार

एक सरणी प्रकार को पंक्तियों की संख्या के प्रकार बार के प्रकार के रूप में परिभाषित किया गया है।

मैं ctypes.POINTER () के बारे में थोड़ा नीचे बता दूंगा। परिणाम = ctypes.POINTER (CItem) * आकार

इसके बाद, परिणामी सरणी बनाएँ .result = resultType ()

और लूप में हम प्रत्येक पंक्ति को एक आयामी सरणी के रूप में बनाते हैं ।row = rowType ()

इसके बाद, नेस्टेड लूप में, सरणी का प्रत्येक तत्व बनाएं और ऑब्जेक्ट python.row [j] = CItem () की सूची से संरचना को मान असाइन करें

row [j] .value = py_list [i] [j] .value
पंक्ति [j] .name = ctypes.c_wchar_p (py_list [i] [j] .name)

फिर तत्वों के साथ प्रत्येक बनाई गई रेखा को एक प्रकार के पॉइंटर को ऑब्जेक्ट्स की एक सरणी में परिवर्तित किया जाना चाहिए और परिणामी सरणी के सेल को सौंपा जाना चाहिए।

मैं ctypes.cast () फ़ंक्शन के बारे में लिखूंगा .result [i] = ctypes.cast (पंक्ति, ctypes.POINTER (CItem))
और हां, पूरे व्यूअर को पॉइंटर में बदलें। ctypes.cast (परिणाम, ctypes.POINTER (ctypes.POINTER (CItem)))

ctypes.POINTER

Ctypes में ctypes.POINTER () है - इंगित करता है कि एक सूचक का उपयोग किया जा रहा है। उदाहरण के लिए: ctypes.POINTER (CItem) इंगित करता है कि यह CItem () संरचना का सूचक है।
तदनुसार, लाइन के साथ: ctypes.POINTER (ctypes.POINTER (CItem)) हम संकेत दे सकते हैं कि यह CItem संरचना के लिए एक सूचक है, या C ++ CItem ** A में ctypes.pointer () है । यह फ़ंक्शन किसी ऑब्जेक्ट को पॉइंटर लौटाता है। उदाहरण के लिए: आइटम = CItem ()

सूचक = ctypes.pointer (आइटम)

उन्हें भ्रमित नहीं होना चाहिए, क्योंकि उनका अर्थ पूरी तरह से अलग है।

ctypes.cast ()

अब बहुत महत्वपूर्ण फ़ंक्शन पर विचार करें ctypes.cast ()। यह फ़ंक्शन C ++ से कुछ हद तक static_cast () के समान है।

यह आपको बहुत महत्वपूर्ण कलाकार बनाने की अनुमति देता है।

सरणी प्रकार बनाते समय, उदाहरण के लिए: rowType = CItem * 4

row = rowType ()

इस स्थिति में, पंक्ति CItem संरचनाओं के 4 तत्वों का एक मेमोरी क्षेत्र है।

बेशक, इस रूप में, हम इस डेटा का उपयोग नहीं कर पाएंगे। लेकिन अगर हम उन पर कास्ट फ़ंक्शन का उपयोग करते हैं: array_pointer = ctypes.cast (पंक्ति, ctypes.POINTER (CItem))

इस स्थिति में, array_pointer पहले से ही 4 CItem संरचनाओं के साथ मेमोरी क्षेत्र का एक संकेतक है।

पहला पैरामीटर एरे तत्वों के साथ बनाया गया मेमोरी क्षेत्र है, और दूसरा पैरामीटर वह प्रकार है जिसमें दिए गए क्षेत्र को परिवर्तित किया जाना चाहिए। ठीक है, यह ctypes का उपयोग करके डेटा सरणियों को स्थानांतरित करते समय मुख्य बिंदुओं को उजागर करता है।

मुझे उम्मीद है कि यह लेख आपको अधिक तेज़ी से और पूरी तरह से अद्भुत ctypes पुस्तकालय से निपटने में मदद करेगा।