NumPy 1.14

numpy.memmap




numpy

numpy.memmap

class numpy.memmap [source]

डिस्क पर बाइनरी फ़ाइल में संग्रहीत सरणी में मेमोरी-मैप बनाएं।

मेमोरी-मैप्ड फ़ाइलों का उपयोग डिस्क पर बड़ी फ़ाइलों के छोटे सेगमेंट तक पहुँचने के लिए किया जाता है, बिना पूरी फ़ाइल को मेमोरी में पढ़े। NumPy के मेममैप एरे जैसी वस्तुएं हैं। यह पायथन के mmap मॉड्यूल से अलग है, जो फ़ाइल जैसी वस्तुओं का उपयोग करता है।

Ndarray के इस उपवर्ग में कुछ संचालन के साथ कुछ अप्रिय इंटरैक्शन हैं, क्योंकि यह उपवर्ग के रूप में ठीक से फिट नहीं है। इस उपवर्ग का उपयोग करने का एक विकल्प यह है कि स्वयं mmap ऑब्जेक्ट बनाएं, फिर ndarray .__ new__ के साथ एक ndarray बनाएं, इसके 'बफर =' पैरामीटर में बनाई गई ऑब्जेक्ट को पास करते हुए।

यह वर्ग किसी बिंदु पर फैक्ट्री फ़ंक्शन में बदल सकता है जो एक दृश्य को एक एमएमएपी बफर में देता है।

मेममैप उदाहरण को बंद करने के लिए हटाएँ।

पैरामीटर:

फ़ाइल नाम : str, फ़ाइल-जैसा ऑब्जेक्ट, या pathlib.Path उदाहरण

फ़ाइल नाम या फ़ाइल ऑब्जेक्ट को सरणी डेटा बफर के रूप में उपयोग किया जाना है।

dtype : data-type, वैकल्पिक

डेटा-प्रकार का उपयोग फ़ाइल सामग्री की व्याख्या करने के लिए किया जाता है। डिफ़ॉल्ट uint8

मोड : {'r +', 'r', 'w +', 'c'}, वैकल्पिक

फ़ाइल को इस मोड में खोला गया है:

'आर' केवल पढ़ने के लिए मौजूदा फ़ाइल खोलें।
'आर +' पढ़ने और लिखने के लिए मौजूदा फ़ाइल खोलें।
'W +' पढ़ने और लिखने के लिए मौजूदा फ़ाइल बनाएँ या अधिलेखित करें।
'सी' कॉपी-ऑन-राइट: असाइनमेंट मेमोरी में डेटा को प्रभावित करते हैं, लेकिन डिस्क में परिवर्तन सहेजे नहीं जाते हैं। डिस्क पर फ़ाइल केवल-पढ़ने के लिए है।

डिफ़ॉल्ट 'r +' है।

ऑफसेट : इंट, वैकल्पिक

फ़ाइल में, सरणी डेटा इस ऑफसेट पर शुरू होता है। चूंकि offset को बाइट्स में मापा जाता है, इसलिए यह आमतौर पर dtype कई बाइट आकार का dtype । जब mode != 'r' , फ़ाइल के अंत से परे भी सकारात्मक ऑफसेट मान्य हैं; अतिरिक्त डेटा को समायोजित करने के लिए फ़ाइल को बढ़ाया जाएगा। डिफ़ॉल्ट रूप से, फ़ाइल की शुरुआत में fp.tell() != 0 शुरू हो जाएगा, भले ही filename फ़ाइल सूचक fp और fp.tell() != 0

आकार : tuple, वैकल्पिक

सरणी का वांछित आकार। यदि mode == 'r' और offset बाद बचे हुए बाइट्स की संख्या dtype का एक से अधिक बाइट नहीं है, तो आपको shape निर्दिष्ट करना होगा। डिफ़ॉल्ट रूप से, दिए गए सरणी फ़ाइल आकार और डेटा-प्रकार द्वारा निर्धारित तत्वों की संख्या के साथ 1-डी होगा।

आदेश : {'C', 'F'}, वैकल्पिक

Ndarray मेमोरी लेआउट के क्रम को निर्दिष्ट करें: row-major , C- शैली या column-major , फोरट्रान-शैली। यह केवल एक प्रभाव है अगर आकृति 1-डी से अधिक है। डिफ़ॉल्ट आदेश 'C' है।

यह भी देखें

lib.format.open_memmap
मेमोरी-मैप्ड .npy फ़ाइल बनाएं या लोड करें।

टिप्पणियाँ

मेमर्ड ऑब्जेक्ट का उपयोग कहीं भी किया जा सकता है जिसे ndarray स्वीकार किया जाता है। एक isinstance(fp, numpy.ndarray) fp , isinstance(fp, numpy.ndarray) को देखते हुए यह True

मेमोरी-मैप की गई फाइलें 32-बिट सिस्टम पर 2GB से बड़ी नहीं हो सकती हैं।

जब एक मेममैप फाइल सिस्टम में अपने वर्तमान आकार से परे एक फाइल बनाने या विस्तारित करने का कारण बनता है, तो नए भाग की सामग्री अनिर्दिष्ट होती है। POSIX फाइलसिस्टम शब्दार्थ के साथ सिस्टम पर, विस्तारित भाग को शून्य बाइट्स से भरा जाएगा।

उदाहरण

>>> data = np.arange(12, dtype='float32')
>>> data.resize((3,4))

यह उदाहरण एक अस्थायी फ़ाइल का उपयोग करता है ताकि सिद्धांत आपकी निर्देशिका में फ़ाइलें न लिखें। आप 'सामान्य' फ़ाइल नाम का उपयोग करेंगे।

>>> from tempfile import mkdtemp
>>> import os.path as path
>>> filename = path.join(mkdtemp(), 'newfile.dat')

Dtype और आकार के साथ एक मेममैप बनाएं जो हमारे डेटा से मेल खाता हो:

>>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
>>> fp
memmap([[ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.]], dtype=float32)

मेमरे सरणी में डेटा लिखें:

>>> fp[:] = data[:]
>>> fp
memmap([[  0.,   1.,   2.,   3.],
        [  4.,   5.,   6.,   7.],
        [  8.,   9.,  10.,  11.]], dtype=float32)
>>> fp.filename == path.abspath(filename)
True

ऑब्जेक्ट हटाने से पहले डिस्क में मेमोरी में परिवर्तन को हटा देता है:

>>> del fp

मेममैप लोड करें और सत्यापित करें कि डेटा संग्रहीत किया गया था:

>>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> newfp
memmap([[  0.,   1.,   2.,   3.],
        [  4.,   5.,   6.,   7.],
        [  8.,   9.,  10.,  11.]], dtype=float32)

पढ़ें-केवल मेममैप:

>>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> fpr.flags.writeable
False

कॉपी-ऑन-राइट मेममैप:

>>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
>>> fpc.flags.writeable
True

कॉपी-ऑन-राइट सरणी पर असाइन करना संभव है, लेकिन मान केवल सरणी की मेमोरी कॉपी में लिखे गए हैं, और डिस्क पर नहीं लिखे गए हैं:

>>> fpc
memmap([[  0.,   1.,   2.,   3.],
        [  4.,   5.,   6.,   7.],
        [  8.,   9.,  10.,  11.]], dtype=float32)
>>> fpc[0,:] = 0
>>> fpc
memmap([[  0.,   0.,   0.,   0.],
        [  4.,   5.,   6.,   7.],
        [  8.,   9.,  10.,  11.]], dtype=float32)

डिस्क पर फ़ाइल अपरिवर्तित है:

>>> fpr
memmap([[  0.,   1.,   2.,   3.],
        [  4.,   5.,   6.,   7.],
        [  8.,   9.,  10.,  11.]], dtype=float32)

एक मेममैप में ऑफसेट:

>>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
>>> fpo
memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)

गुण

फ़ाइल का नाम (str या pathlib.Path उदाहरण) मैप की गई फ़ाइल का पथ।
ओफ़्सेट (int) फ़ाइल में ऑफसेट स्थिति।
मोड (str) फ़ाइल मोड।

तरीके

flush () सरणी में डिस्क पर फ़ाइल में कोई भी परिवर्तन लिखें।