U
|
O ±dù. ã @ s d dl mZ d dlZddlmZmZmZ d dlm Z m
|
Z
|
d dl m Z dgZ eZdd d
|
d gZd
|
d gZdd d
|
d d Ze d G dd deZdS )é )Ú nullcontextNé )Úuint8ÚndarrayÚdtype)Ú os_fspathÚis_pathlib_path)Ú
|
set_moduleÚmemmapÚrÚcúr+úw+)ÚreadonlyZ copyonwriteZ readwriteÚwriteÚnumpyc sV e Zd ZdZdZeddddfddZd d
|
Zd d Zd fd d Z fddZ
|
Z S )r
|
a? Create a memory-map to an array stored in a *binary* file on disk.
|
|
Memory-mapped files are used for accessing small segments of large files
|
on disk, without reading the entire file into memory. NumPy's
|
memmap's are array-like objects. This differs from Python's ``mmap``
|
module, which uses file-like objects.
|
|
This subclass of ndarray has some unpleasant interactions with
|
some operations, because it doesn't quite fit properly as a subclass.
|
An alternative to using this subclass is to create the ``mmap``
|
object yourself, then create an ndarray with ndarray.__new__ directly,
|
passing the object created in its 'buffer=' parameter.
|
|
This class may at some point be turned into a factory function
|
which returns a view into an mmap buffer.
|
|
Flush the memmap instance to write the changes to the file. Currently there
|
is no API to close the underlying ``mmap``. It is tricky to ensure the
|
resource is actually closed, since it may be shared between different
|
memmap instances.
|
|
|
Parameters
|
----------
|
filename : str, file-like object, or pathlib.Path instance
|
The file name or file object to be used as the array data buffer.
|
dtype : data-type, optional
|
The data-type used to interpret the file contents.
|
Default is `uint8`.
|
mode : {'r+', 'r', 'w+', 'c'}, optional
|
The file is opened in this mode:
|
|
+------+-------------------------------------------------------------+
|
| 'r' | Open existing file for reading only. |
|
+------+-------------------------------------------------------------+
|
| 'r+' | Open existing file for reading and writing. |
|
+------+-------------------------------------------------------------+
|
| 'w+' | Create or overwrite existing file for reading and writing. |
|
+------+-------------------------------------------------------------+
|
| 'c' | Copy-on-write: assignments affect data in memory, but |
|
| | changes are not saved to disk. The file on disk is |
|
| | read-only. |
|
+------+-------------------------------------------------------------+
|
|
Default is 'r+'.
|
offset : int, optional
|
In the file, array data starts at this offset. Since `offset` is
|
measured in bytes, it should normally be a multiple of the byte-size
|
of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of
|
file are valid; The file will be extended to accommodate the
|
additional data. By default, ``memmap`` will start at the beginning of
|
the file, even if ``filename`` is a file pointer ``fp`` and
|
``fp.tell() != 0``.
|
shape : tuple, optional
|
The desired shape of the array. If ``mode == 'r'`` and the number
|
of remaining bytes after `offset` is not a multiple of the byte-size
|
of `dtype`, you must specify `shape`. By default, the returned array
|
will be 1-D with the number of elements determined by file size
|
and data-type.
|
order : {'C', 'F'}, optional
|
Specify the order of the ndarray memory layout:
|
:term:`row-major`, C-style or :term:`column-major`,
|
Fortran-style. This only has an effect if the shape is
|
greater than 1-D. The default order is 'C'.
|
|
Attributes
|
----------
|
filename : str or pathlib.Path instance
|
Path to the mapped file.
|
offset : int
|
Offset position in the file.
|
mode : str
|
File mode.
|
|
Methods
|
-------
|
flush
|
Flush any changes in memory to file on disk.
|
When you delete a memmap object, flush is called first to write
|
changes to disk.
|
|
|
See also
|
--------
|
lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
|
|
Notes
|
-----
|
The memmap object can be used anywhere an ndarray is accepted.
|
Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
|
``True``.
|
|
Memory-mapped files cannot be larger than 2GB on 32-bit systems.
|
|
When a memmap causes a file to be created or extended beyond its
|
current size in the filesystem, the contents of the new part are
|
unspecified. On systems with POSIX filesystem semantics, the extended
|
part will be filled with zero bytes.
|
|
Examples
|
--------
|
>>> data = np.arange(12, dtype='float32')
|
>>> data.resize((3,4))
|
|
This example uses a temporary file so that doctest doesn't write
|
files to your directory. You would use a 'normal' filename.
|
|
>>> from tempfile import mkdtemp
|
>>> import os.path as path
|
>>> filename = path.join(mkdtemp(), 'newfile.dat')
|
|
Create a memmap with dtype and shape that matches our data:
|
|
>>> 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)
|
|
Write data to memmap array:
|
|
>>> fp[:] = data[:]
|
>>> fp
|
memmap([[ 0., 1., 2., 3.],
|
[ 4., 5., 6., 7.],
|
[ 8., 9., 10., 11.]], dtype=float32)
|
|
>>> fp.filename == path.abspath(filename)
|
True
|
|
Flushes memory changes to disk in order to read them back
|
|
>>> fp.flush()
|
|
Load the memmap and verify data was stored:
|
|
>>> 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)
|
|
Read-only memmap:
|
|
>>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
|
>>> fpr.flags.writeable
|
False
|
|
Copy-on-write memmap:
|
|
>>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
|
>>> fpc.flags.writeable
|
True
|
|
It's possible to assign to copy-on-write array, but values are only
|
written into the memory copy of the array, and not written to disk:
|
|
>>> 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)
|
|
File on disk is unchanged:
|
|
>>> fpr
|
memmap([[ 0., 1., 2., 3.],
|
[ 4., 5., 6., 7.],
|
[ 8., 9., 10., 11.]], dtype=float32)
|
|
Offset into a memmap:
|
|
>>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
|
>>> fpo
|
memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32)
|
|
g YÀr r NÚCc
|
C s^ dd l }dd l}z t| }W nH tk
|
rd } z*|tkrTtd ttt ¡ |¡d W 5 d } ~ X Y nX |dkr~|d kr~tdt |drt
|
|}
|
n t t ||dkr¦dn|d }
|
|
|
} | dd ¡ | ¡ } t|} | j}|d kr | | }|| rütd
|
|| }|f}n0t|ts |f}t d ¡}|D ]}||9 }q,t||| }|d kr| |k r| |d d¡ | d ¡ | ¡ |dkr|j}n|dkr¦|j}n|j}|||j }||8 }|| }|j | ¡ |||d}t j | || |||d}||_ ||_ ||_!t"|r | #¡ |_$n2t | drJt| j%t&rJ|j' (| j%¡|_$nd |_$W 5 Q R X |S )Nr z#mode must be one of {!r} (got {!r})r zshape must be givenÚreadr r Úbé z?Size of available data is not a multiple of the data-type size.r )r r ó )ÚaccessÚoffset)r Úbufferr ÚorderÚname))ÚmmapÚos.pathÚmode_equivalentsÚKeyErrorÚvalid_filemodesÚ
|
ValueErrorÚformatÚlistÚkeysÚhasattrr Úopenr ÚseekÚtellÚ
|
dtypedescrÚitemsizeÚ
|
isinstanceÚtupleÚnpZintpÚintr ÚflushZ ACCESS_COPYZ ACCESS_READZ ACCESS_WRITEZALLOCATIONGRANULARITYÚfilenor Ú__new__Ú_mmapr Úmoder ÚresolveÚfilenamer ÚstrÚpathÚabspath)Úsubtyper5 r r3 r Úshaper r ÚosÚeZf_ctxZfidZflenÚdescrZ_dbytesÚbytesÚsizeÚkÚaccÚstartZ array_offsetÚmmÚself© rE úHd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/memmap.pyr1 Ð s| ÿÿý
|
|
|
|
|
|
|
ÿ
|
zmemmap.__new__c C sT t |dr8t | |¡r8|j| _|j| _|j| _|j| _nd | _d | _d | _d | _d S )Nr2 )r% r- Zmay_share_memoryr2 r5 r r3 )rD ÚobjrE rE rF Ú__array_finalize__ s
|
zmemmap.__array_finalize__c C s$ | j dk r t| j dr | j ¡ dS )zÜ
|
Write any changes in the array to the file on disk.
|
|
For further information, see `memmap`.
|
|
Parameters
|
----------
|
None
|
|
See Also
|
--------
|
memmap
|
|
Nr/ )Úbaser% r/ )rD rE rE rF r/ , s z memmap.flushc sD t ||¡}| |ks"t| tk r&|S |jdkr8|d S | tj¡S )NrE )ÚsuperÚ__array_wrap__Útyper
|
r: Úviewr- r )rD ZarrÚcontext©Ú __class__rE rF rK > s
|
zmemmap.__array_wrap__c s2 t |¡}t|tkr.|jd kr.|jtdS |S )N)rL )rJ Ú __getitem__rL r
|
r2 rM r )rD ÚindexÚresrO rE rF rQ M s zmemmap.__getitem__)N) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Z__array_priority__r r1 rH r/ rK rQ Ú __classcell__rE rE rO rF r
|
s 7 ÿ
|
P )Ú
|
contextlibr r r- Únumericr r r Z numpy.compatr r Znumpy.core.overridesr Ú__all__r) r Zwriteable_filemodesr r
|
rE rE rE rF Ú<module> s ü
|
