गैर-संगत स्मृति स्थान के लिए मेमोरीव्यू कैसे बनाएं?

Question

मेरे पास स्मृति में एक खंडित संरचना है और मैं इसे एक समान दिखने वाली स्मृतिदृश्य के रूप में एक्सेस करना चाहता हूं। क्या ऐसा करने का कोई आसान तरीका है या क्या मुझे अपना समाधान लागू करना चाहिए?

उदाहरण के लिए, एक फ़ाइल स्वरूप पर विचार करें जिसमें रिकॉर्ड्स शामिल हैं। प्रत्येक रिकॉर्ड में एक निश्चित लंबाई हैडर होता है, जो रिकॉर्ड की सामग्री की लंबाई निर्दिष्ट करता है। एक उच्च स्तर की तार्किक संरचना कई रिकॉर्डों में फैल सकती है। यह उच्च स्तरीय संरचना को कार्यान्वित करने में आसान होगा अगर यह बाइट्स की एक साधारण संगत सरणी के रूप में स्वयं का खंडित स्मृति स्थान देख सके।

अद्यतन:

ऐसा लगता है अजगर इस 'खंडित किया' बफर आंतरिक रूप से लिखते हैं, तो कम से कम this part of the documentation के आधार पर समर्थन करता है। लेकिन यह केवल सी एपीआई है।

Update2:

जहां तक ​​मैं देख रहा हूँ, संदर्भित सी एपीआई - कहा जाता है पुरानी शैली बफ़र्स - मैं क्या जरूरत है, लेकिन यह अब पदावनत और अजगर के नए संस्करण में उपलब्ध नहीं है (3.X) । नया बफर प्रोटोकॉल - PEP 3118 में निर्दिष्ट - बफर का प्रतिनिधित्व करने का एक नया तरीका प्रदान करता है। यह एपीआई अधिकांश उपयोग मामलों में अधिक उपयोग योग्य है (उनमें से, उन मामलों का उपयोग करें जहां प्रतिनिधित्व बफर स्मृति में संगत नहीं है), लेकिन इस विशिष्ट एक का समर्थन नहीं करता है, जहां एक आयामी सरणी पूरी तरह से स्वतंत्र रूप से रखी जा सकती है (कई अलग-अलग आकार में) आकार में।

Answer 1

पहला - मुझे लगता है कि आप इसे सी एक्सटेंशन के बजाय शुद्ध पायथन में करने की कोशिश कर रहे हैं। इसलिए मुझे लगता है कि आपने विभिन्न रिकॉर्डों में लोड किया है जिन्हें आप पाइथन ऑब्जेक्ट्स के सेट में रुचि रखते हैं और आपकी समस्या यह है कि आप इन ऑब्जेक्ट्स में फैले उच्च स्तर की संरचना को देखना चाहते हैं, जिसमें ऑब्जेक्ट्स के आसपास और वहां बिट्स हैं।

तो क्या आप बस प्रत्येक रिकॉर्ड को बाइट एरे प्रकार में लोड नहीं कर सकते? फिर आप एक नई सरणी बनाने के लिए सरणी के पायथन टुकड़े का उपयोग कर सकते हैं जिसमें आपके पास रुचि रखने वाली उच्च स्तरीय संरचना के लिए डेटा है। उसके बाद आपके पास रुचि रखने वाले डेटा के साथ एक बाइट सरणी होगी और इसे प्रिंट कर सकते हैं या इसे किसी भी तरह से कुशल बनाना चाहते हैं।

तो कुछ की तरह:

a = bytearray(b"Hello World") # put your records into byte arrays like this 
b = bytearray(b"Stack Overflow") 
complexStructure = bytearray(a[0:6]+b[0:]) # Slice and join arrays to form 
              # new array with just data from your 
              # high level entity 
print complexStructure 

बेशक आप अभी भी नेड जाएगा पता करने के लिए जहां रिकॉर्ड के भीतर अपने उच्च स्तर संरचना सही ढंग से सरणियों काट करने के लिए है, लेकिन आप फिर भी इस में पता करने की आवश्यकता होगी।

संपादित:

नोट एक सूची का एक टुकड़ा लेने सूची में डेटा की प्रतिलिपि नहीं है यह सिर्फ डेटा तो के लिए संदर्भ का एक नया सेट बनाता है: करने के लिए

>>> a = [1,2,3] 
>>> b = a[1:3] 
>>> id(a[1]) 
140268972083088 
>>> id(b[0]) 
140268972083088 

हालांकि परिवर्तन सूची बी एक नहीं बदलेगी क्योंकि बी एक नई सूची है। परिवर्तनों को मूल सूची में स्वचालित रूप से बदलने के लिए आपको एक और जटिल ऑब्जेक्ट बनाना होगा जिसमें सूचियों को मूल रिकॉर्ड में शामिल किया गया था और उन्हें इस तरह से छुपाया जा सके कि यह निर्धारित करने में सक्षम हो कि कौन सी सूची और सूची का कौन सा तत्व बदलना है या देखें कि कोई उपयोगकर्ता जटिल संरचना को संशोधित/देखने के लिए कब देखता है। तो कुछ इस तरह:

class ComplexStructure(): 
    def add_records(self,record): 
     self.listofrecords.append(record) 

    def get_value(self,position): 
     listnum,posinlist = ... # formula to figure out which list and where in 
           # list element of complex structure is 
     return self.listofrecords[listnum][record] 

    def set_value(self,position,value): 
     listnum,posinlist = ... # formula to figure out which list and where in 
           # list element of complex structure is 
     self.listofrecords[listnum][record] = value 

दी इस चीजें आप के लिए उम्मीद कर रहे थे करने का आसान तरीका नहीं है बल्कि यह है कि तुम क्या जरूरत है क्या करना चाहिए।