Ë
|
KñúhÖ2 ã ó d dl Z d dlmZ d dlZd dlmZ ddlmZm Z m
|
Z
|
dgZ eZ g d¢Z dd gZd
|
d dd d Z ed « G d de « « Zy)é N)Ú nullcontext)Ú
|
set_moduleé )ÚdtypeÚndarrayÚuint8Úmemmap)ÚrÚcúr+úw+r r r
|
r )ÚreadonlyÚ copyonwriteÚ readwriteÚwriteÚnumpyc óP e Zd ZdZdZeddddfdZd Zd Zd fd
|
Z fd Z
|
xZ S ) r aY 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. |
|
| | If ``mode == 'w+'`` then `shape` must also be specified. |
|
+------+-------------------------------------------------------------+
|
| '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 : int or sequence of ints, 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.
|
|
.. versionchanged:: 2.0
|
The shape parameter can now be any integer sequence type, previously
|
types were limited to tuple and int.
|
|
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
|
--------
|
>>> import numpy as np
|
>>> 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 óv dd l }dd l} t | }|dk( r | t d« t |d« r t |« } n%t |j |« |dk( rd n|d
|
z « } | 5 } | j dd « | j « } t |« }|j }| | |z
|
}||z r t d « ||z }|f}nYt! |t" t
|
f« s t% j& |« g}t# |« }t+ j, d « }|D ] }||z } t/ |||z z « }|dv rGt1 |d « }| |k r6| j |d z
|
d« | j3 d« | j5 « |dk( r |j6 }n |d k( r |j8 }n |j: }|||j< z z
|
}||z }|dk( r#|dkD r ||j< z }||j< z }||z
|
}|j | j? « |||¬« }tA jB | |||||¬« }||_" ||_# ||_$ t! ||jJ « r|jM « |_' nXt | d« rEt! | jP tR « r+|jT jW | jP « |_' nd |_' d d d « |S # t $ rJ} |t vr7t t t j « « z }
|
t d|
|
d|d« d Y d } ~ d } ~ ww xY w# t( $ r Y ?w xY w# 1 sw Y S xY w)Nr zmode must be one of z (got ú)r z#shape must be given if mode == 'w+'Ú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ÚlistÚkeysÚ
|
ValueErrorÚhasattrr ÚopenÚfspathÚseekÚtellÚ
|
dtypedescrÚitemsizeÚ
|
isinstanceÚtupleÚoperatorÚindexÚ TypeErrorÚnpÚintpÚintÚmaxr ÚflushÚ ACCESS_COPYÚ ACCESS_READÚ ACCESS_WRITEÚALLOCATIONGRANULARITYÚfilenor Ú__new__Ú_mmapr ÚmodeÚPathLikeÚresolveÚfilenamer ÚstrÚpathÚabspath)ÚsubtyperC r r@ r Úshaper r ÚosÚeÚ all_modesÚf_ctxÚfidÚflenÚdescrÚ_dbytesÚbytesÚsizeÚkÚaccÚstartÚ array_offsetÚmmÚselfs úEH:\Change_password\venv_build\Lib\site-packages\numpy/_core/memmap.pyr> zmemmap.__new__Ø s? ó Ûð Ü# DÑ)Dð 4<EMÜ Ð BÓCÐ Cä 8VÔ $Ü Ó)EäØ (Ó#Ø ¨°Ñ4óEð
|
ð C %cØ HHQNØ88:DÜ uÓ%EØnnGà}Ø v Ø7?Ü$ð &>ó ?ð ?à Ñ'Ø ä! %¬%´¨ Ô7ð Ü!)§ ¡ °Ó!6Ð 7ô e ÜwwqzØ ò AØAIDð ô ¨¡ Ñ/Ó0Eà|Ñ#ô E 1 Ø%<ØHHU QY¨Ô*ØIIeÔ$ØIIKàs{Ø×&Ñ&ØØ×&Ñ&à×'Ñ'àV d×&@Ñ&@Ñ @Ñ@EØ UNEð ze aiØ×3Ñ3Ñ3Ø×3Ñ3Ñ3Ø! E>LØ3::<¨°sÀ5ÓIBä?? 7¨E¸ÀrØ*6¸eôEDàDJØ DKØ DIä( B§K¡KÔ0ð !)× 0Ñ 0Ó 2 ÜfÔ%¬*°S·X±X¼sÔ*Cà "§¡§¡°·±Ó 9 ð !% ÷GC %ðJ øôo ò Ø?Ñ*Ü +¬dÔ3C×3HÑ3HÓ3JÓ.KÑ K Ü Ø*¨9¨-°v¸d¸XÀQÐGóàð õ +ûð ûôF %ò Ú ð ú÷#C %ðJ úsI K Á$A0L.ÃL Ã+GL.Ë LË?LÌLÌ L+Ì'L.Ì*L+Ì+L.Ì.L8c ó
|
t |d« r[t j | |« rE|j | _ |j | _ |j
|
| _ |j | _ y d | _ d | _ d | _ d | _ y )Nr? )r( r4 Úmay_share_memoryr? rC r r@ )rX Úobjs rY Ú__array_finalize__zmemmap.__array_finalize__8 sc Ü 3Ô ¤R×%8Ñ%8¸¸sÔ%CØ DJØ LLDMØ **DKØDIà DJØ DMØ DKØ DIó c ó | j 2t | j d« r| j j « yyy)zÜ
|
Write any changes in the array to the file on disk.
|
|
For further information, see `memmap`.
|
|
Parameters
|
----------
|
None
|
|
See Also
|
--------
|
memmap
|
|
Nr8 )Úbaser( r8 )rX s rY r8 z memmap.flushD s2 ð 99Ð ¤W¨T¯Y©Y¸Ô%@Ø IIOOÕ ð &AÐ r^ c ó t | ||« }| |u st | « t ur|S |r|d S |j t
|
j « S )N© )ÚsuperÚ__array_wrap__Útyper Úviewr4 r )rX ÚarrÚcontextÚ return_scalarÚ __class__s rY rd zmemmap.__array_wrap__V sP ø ÜgÑ$ S¨'Ó2ð
|
3;$t*¬FÑ2ØJñ Ør7Nð xx
|
|
Ó#Ð#r^ c ó t | |« }t |« t u r"|j |j t ¬« S |S )N)re )rc Ú __getitem__re r r? rf r )rX r2 Úresrj s rY rl zmemmap.__getitem__g s= ø ÜgÑ! %Ó(Ü 9Ñ 3§9¡9Ð#4Ø88¤8Ó)Ð )Ø
|
r^ )NF) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__array_priority__r r> r] r8 rd rl Ú __classcell__)rj s @rY r r s> ø ñ{ðz Ðà).°TÀ!Ø #ó^ò@
|
ò õ$$÷"ð r^ )r1 Ú
|
contextlibr r r4 Ú numpy._utilsr Únumericr r r Ú__all__r- r$ Úwriteable_filemodesr" r rb r^ rY ú<module>ry sk ðÛ Ý "ã Ý #ç *Ñ *à *à
|
Ú(ØTlÐ ð ØØØ ñ Ð ñ GÓôSWó Só ñSr^
|
