Ñò
[ÐKc @ s d g Z d d k Z d d k l Z l Z l Z d d k Z e Z d d d d g Z d d g Z h d d 6d d 6d d
6d d 6Z
d e f d „ ƒ YZ d S(
t memmapiÿÿÿÿN( t uint8t ndarrayt dtypet rt cs r+s w+t readonlyt copyonwritet readwritet writec B sb e Z d Z d Z e d d d d d „ Z d „ Z d „ Z d „ Z d „ Z
d
„ Z d „ Z RS(
s'
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.
Parameters
----------
filename : str or file-like object
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 be a multiple of the byte-size of
`dtype`. Requires ``shape=None``. The default is 0.
shape : tuple, optional
The desired shape of the array. 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: C (row-major) or
Fortran (column-major). This only has an effect if the shape is
greater than 1-D. The default order is 'C'.
Methods
-------
close
Close the memmap file.
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 before removing the object.
Notes
-----
The memmap object can be used anywhere an ndarray is accepted.
Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
``True``.
Memory-mapped arrays use the Python memory-map object which
(prior to Python 2.5) does not allow files to be larger than a
certain size depending on the platform. This size is always < 2GB
even on 64-bit systems.
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)
Deletion flushes memory changes to disk before removing the object:
>>> del fp
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Às r+i t Cc C så d d k } y t | } Wn> t j
o2 | t j o t d t t i ƒ ƒ ‚ q[ n Xt | d ƒ o
| } n( t | | d j o d p | d ƒ } | d j o | d j o
t d ‚ n | i d d
ƒ | i
ƒ } t | ƒ }
|
i } | d j oC | | } | | o | i
ƒ t d ‚ n | | }
|
f } n? t | t ƒ p
| f } n d }
x | D] } |
| 9}
qnWt | |
| ƒ } | d j p | d
j oB | | j o5 | i | d d ƒ | i t d ƒ ƒ | i ƒ n | d j o
| i } n$ | d j o
| i } n
| i } t i d
d j oM | | | i } | | 8} | | 8} | i | i ƒ | d | d | ƒ} n | i | i ƒ | d | ƒ} t i | | d |
d | d | d | ƒ} | | _ | S( Niÿÿÿÿs mode must be one of %st readR R t bs w+s shape must be giveni i s; Size of available data is not a multiple of data-type size.i s r+i t accesst offsetR t buffert order( i i ( t mmapt mode_equivalentst KeyErrort valid_filemodest
ValueErrort keyst hasattrt filet Nonet seekt tellt
dtypedescrt itemsizet closet
isinstancet tuplet longR t chrt flusht ACCESS_COPYt ACCESS_READt ACCESS_WRITEt syst version_infot ALLOCATIONGRANULARITYt filenoR t __new__t _mmap( t subtypet filenameR t modeR t shapeR R t fidt flent descrt _dbytest bytest sizet kt acct startt mmt self( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyR+ £ sb
'
'
( c C s- t | d ƒ o | i | _ n
d | _ d S( NR, ( R R, R ( R; t obj( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyt __array_finalize__æ s c C s% | i d j o | i i ƒ n d S( sÜ
Write any changes in the array to the file on disk.
For further information, see `memmap`.
Parameters
----------
None
See Also
--------
memmap
N( R, R R# ( R; ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyR# ì s c C s t i d t ƒ | i ƒ d S( s' This method is deprecated, use `flush`.s Use ``flush``.N( t warningst warnt DeprecationWarningR# ( R; ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyt syncþ s c C s> | i | i j o' | i i ƒ | i i ƒ d | _ n d S( s> Close the memmap file. Only do this when deleting the object.N( t baseR, R# R R ( R; ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyt _close s
c C s t i d t ƒ d S( s$ Close the memmap file. Does nothing.s2 ``close`` is deprecated on memmap arrays. Use delN( R> R? R@ ( R; ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyR s c C sL | i | i j o5 y | i i ƒ Wn t j
o qH X| i ƒ n d S( N( R, RB R R RC ( R; ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyt __del__ s N(
t __name__t
__module__t __doc__t __array_priority__R R R+ R= R# RA RC R RD ( ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyR s Ž B ( t __all__R> t numericR R R R' R R t writeable_filemodesR R ( ( ( s7 /usr/lib64/python2.6/site-packages/numpy/core/memmap.pyt s