U
|
P ±d§ ã @ s2 d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlmZm Z
|
m Z d dl m Z d dlZddlmZ ddlmZ d dlmZ d dlmZmZ d d lmZ d d
|
lm Z m Z dd l m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) d d l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0 d ddddddddddddg Z1ej2ej3ddZ3G d d d Z4d d Z5G d d! d!e Z6e dd\ej7d%d&dZ8d]d'd(Z9e3e9d^d)dZ:d*d+ Z;e3e;d,d Z<d-d. Z=e3e=d/d Z>d_d0d1Z?d2d3 Z@eAd4d5d6ZBd7ZCd`dd8d9d:ZDdad<d=ZEd>d? ZFd7ZCd@dAdBdCdd dddd"ejGdDdE dFdGZHe e deIdAddd dd"d dDdf
|
dddHdIdZJe3eDd#dJeJZKdbdKdLZLe3eLdcdRd ZMe ddddSdZNdedddTdUdVZOe e deIdAdd d dddddddP PeQe jR¡dWd"d#dXdd"d#d#ddDfd ddTdYdZSe3eOd#dJeSZTdZd ZUd[d ZVdS )fé N)Ú
|
itemgetterÚindexÚ methodcaller)ÚMappingé )Úformat)Ú
|
DataSource)Ú overrides)ÚpackbitsÚ
|
unpackbits)Ú_load_from_filelike)Úset_array_function_like_docÚ
|
set_module) Ú LineSplitterÚ NameValidatorÚStringConverterÚConverterErrorÚConverterLockErrorÚConversionWarningÚ_is_string_likeÚhas_nested_fieldsÚ flatten_dtypeÚ
|
easy_dtypeÚ _decode_line)ÚasbytesÚasstrÚ asunicodeÚ os_fspathÚ os_PathLikeÚpickleÚsavetxtÚloadtxtÚ
|
genfromtxtÚ
|
recfromtxtÚ
|
recfromcsvÚloadÚsaveÚsavezÚsavez_compressedr
|
r Ú fromregexr Únumpy)Úmodulec @ s( e Zd ZdZdd Zdd Zdd ZdS ) ÚBagObjam
|
BagObj(obj)
|
|
Convert attribute look-ups to getitems on the object passed in.
|
|
Parameters
|
----------
|
obj : class instance
|
Object on which attribute look-up is performed.
|
|
Examples
|
--------
|
>>> from numpy.lib.npyio import BagObj as BO
|
>>> class BagDemo:
|
... def __getitem__(self, key): # An instance of BagObj(BagDemo)
|
... # will call this method when any
|
... # attribute look-up is required
|
... result = "Doesn't matter what you want, "
|
... return result + "you're gonna get this"
|
...
|
>>> demo_obj = BagDemo()
|
>>> bagobj = BO(demo_obj)
|
>>> bagobj.hello_there
|
"Doesn't matter what you want, you're gonna get this"
|
>>> bagobj.I_can_be_anything
|
"Doesn't matter what you want, you're gonna get this"
|
|
c C s t |¡| _d S ©N)ÚweakrefÚproxyÚ_obj)ÚselfÚobj© r3 úFd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/npyio.pyÚ__init__H s zBagObj.__init__c C s6 zt | d¡| W S tk
|
r0 t|d Y nX d S )Nr0 )ÚobjectÚ__getattribute__ÚKeyErrorÚAttributeError)r1 Úkeyr3 r3 r4 r7 L s zBagObj.__getattribute__c C s t t | d¡ ¡ S )z
|
Enables dir(bagobj) to list the files in an NpzFile.
|
|
This also enables tab-completion in an interpreter or IPython.
|
r0 )Úlistr6 r7 Úkeys©r1 r3 r3 r4 Ú__dir__R s zBagObj.__dir__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r5 r7 r> r3 r3 r3 r4 r, * s r, c O s4 t | dst| } ddl}d|d< |j| f||S )zÄ
|
Create a ZipFile.
|
|
Allows for Zip64, and the `file` argument can accept file, str, or
|
pathlib.Path objects. `args` and `kwargs` are passed to the zipfile.ZipFile
|
constructor.
|
Úreadr NTÚ
|
allowZip64)Úhasattrr ÚzipfileÚZipFile)ÚfileÚargsÚkwargsrF r3 r3 r4 Úzipfile_factory[ s
|
|
rK c @ sb e Zd ZdZdZdZdejdddZdd Z d d
|
Z
|
d d Z d d Z dd Z dd Zdd ZdS )ÚNpzFileaü
|
NpzFile(fid)
|
|
A dictionary-like object with lazy-loading of files in the zipped
|
archive provided on construction.
|
|
`NpzFile` is used to load files in the NumPy ``.npz`` data archive
|
format. It assumes that files in the archive have a ``.npy`` extension,
|
other files are ignored.
|
|
The arrays and file strings are lazily loaded on either
|
getitem access using ``obj['key']`` or attribute lookup using
|
``obj.f.key``. A list of all files (without ``.npy`` extensions) can
|
be obtained with ``obj.files`` and the ZipFile object itself using
|
``obj.zip``.
|
|
Attributes
|
----------
|
files : list of str
|
List of all files in the archive with a ``.npy`` extension.
|
zip : ZipFile instance
|
The ZipFile object initialized with the zipped archive.
|
f : BagObj instance
|
An object on which attribute can be performed as an alternative
|
to getitem access on the `NpzFile` instance itself.
|
allow_pickle : bool, optional
|
Allow loading pickled data. Default: False
|
|
.. versionchanged:: 1.16.3
|
Made default False in response to CVE-2019-6446.
|
|
pickle_kwargs : dict, optional
|
Additional keyword arguments to pass on to pickle.load.
|
These are only useful when loading object arrays saved on
|
Python 2 when using Python 3.
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
This option is ignored when `allow_pickle` is passed. In that case
|
the file is by definition trusted and the limit is unnecessary.
|
|
Parameters
|
----------
|
fid : file or str
|
The zipped archive to open. This is either a file-like object
|
or a string containing the path to the archive.
|
own_fid : bool, optional
|
Whether NpzFile should close the file handle.
|
Requires that `fid` is a file-like object.
|
|
Examples
|
--------
|
>>> from tempfile import TemporaryFile
|
>>> outfile = TemporaryFile()
|
>>> x = np.arange(10)
|
>>> y = np.sin(x)
|
>>> np.savez(outfile, x=x, y=y)
|
>>> _ = outfile.seek(0)
|
|
>>> npz = np.load(outfile)
|
>>> isinstance(npz, np.lib.npyio.NpzFile)
|
True
|
>>> sorted(npz.files)
|
['x', 'y']
|
>>> npz['x'] # getitem access
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
>>> npz.f.x # attribute lookup
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
|
NF©Úmax_header_sizec C s t |}| ¡ | _g | _|| _|| _|| _| jD ]0}| d¡rT| j |d d
¡ q0| j |¡ q0|| _ t
|
| | _ |r||| _ d S )Nú.npyéüÿÿÿ) rK ÚnamelistÚ_filesÚfilesÚ allow_picklerN Ú pickle_kwargsÚendswithÚappendÚzipr, ÚfÚfid)r1 rZ Úown_fidrT rU rN Ú_zipÚxr3 r3 r4 r5 ¶ s
|
|
|
|
zNpzFile.__init__c C s | S r- r3 r= r3 r3 r4 Ú __enter__Ë s zNpzFile.__enter__c C s | ¡ d S r- ©Úclose)r1 Úexc_typeÚ exc_valueÚ tracebackr3 r3 r4 Ú__exit__Î s zNpzFile.__exit__c C s> | j dk r| j ¡ d| _ | jdk r4| j ¡ d| _d| _dS )z"
|
Close the file.
|
|
N)rX r` rZ rY r= r3 r3 r4 r` Ñ s
|
|
|
|
z NpzFile.closec C s | ¡ d S r- r_ r= r3 r3 r4 Ú__del__Þ s zNpzFile.__del__c C s
|
t | jS r- )ÚiterrS r= r3 r3 r4 Ú__iter__â s zNpzFile.__iter__c C s
|
t | jS r- )ÚlenrS r= r3 r3 r4 Ú__len__å s zNpzFile.__len__c C s d}|| j krd}n|| jkr*d}|d7 }|r| j |¡}| ttj¡}| ¡ |tjkr| j |¡}tj || j
|
| j | j dS | j |¡S n t d| d S )NFTrO ©rT rU rN z %s is not a file in the archive)rR rS rX ÚopenrC rh r Ú MAGIC_PREFIXr` Ú
|
read_arrayrT rU rN r8 )r1 r: ÚmemberÚbytesÚmagicr3 r3 r4 Ú __getitem__è s&
|
|
|
ýzNpzFile.__getitem__)FFN)r? r@ rA rB rX rZ r Ú_MAX_HEADER_SIZEr5 r^ rd r` re rg ri rq r3 r3 r3 r4 rL j s H ÿþ rL FTÚASCIIrM c C s |dkrt dt||d}t ¡ \}t| dr<| }d} n| tt| d¡}d} d}
|
d } tt j
|
} | | ¡} | t | t| d
|
¡ | |
|
¡s| | ¡rÆ| ¡ t|| |||d }|W 5 Q R £ S | t j
|
kr|rú|rÞd }t j| ||d W 5 Q R £ S t j||||dW 5 Q R £ S nd|s(t dz tj|f|W W 5 Q R £ S tk
|
r| } zt d| d¡|W 5 d}~X Y nX W 5 Q R X dS )a°
|
Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
|
|
.. warning:: Loading files that contain object arrays uses the ``pickle``
|
module, which is not secure against erroneous or maliciously
|
constructed data. Consider passing ``allow_pickle=False`` to
|
load data that is known not to contain object arrays for the
|
safer handling of untrusted sources.
|
|
Parameters
|
----------
|
file : file-like object, string, or pathlib.Path
|
The file to read. File-like objects must support the
|
``seek()`` and ``read()`` methods and must always
|
be opened in binary mode. Pickled files require that the
|
file-like object support the ``readline()`` method as well.
|
mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
|
If not None, then memory-map the file, using the given mode (see
|
`numpy.memmap` for a detailed description of the modes). A
|
memory-mapped array is kept on disk. However, it can be accessed
|
and sliced like any ndarray. Memory mapping is especially useful
|
for accessing small fragments of large files without reading the
|
entire file into memory.
|
allow_pickle : bool, optional
|
Allow loading pickled object arrays stored in npy files. Reasons for
|
disallowing pickles include security, as loading pickled data can
|
execute arbitrary code. If pickles are disallowed, loading object
|
arrays will fail. Default: False
|
|
.. versionchanged:: 1.16.3
|
Made default False in response to CVE-2019-6446.
|
|
fix_imports : bool, optional
|
Only useful when loading Python 2 generated pickled files on Python 3,
|
which includes npy/npz files containing object arrays. If `fix_imports`
|
is True, pickle will try to map the old Python 2 names to the new names
|
used in Python 3.
|
encoding : str, optional
|
What encoding to use when reading Python 2 strings. Only useful when
|
loading Python 2 generated pickled files in Python 3, which includes
|
npy/npz files containing object arrays. Values other than 'latin1',
|
'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
|
data. Default: 'ASCII'
|
max_header_size : int, optional
|
Maximum allowed size of the header. Large headers may not be safe
|
to load securely and thus require explicitly passing a larger value.
|
See :py:meth:`ast.literal_eval()` for details.
|
This option is ignored when `allow_pickle` is passed. In that case
|
the file is by definition trusted and the limit is unnecessary.
|
|
Returns
|
-------
|
result : array, tuple, dict, etc.
|
Data stored in the file. For ``.npz`` files, the returned instance
|
of NpzFile class must be closed to avoid leaking file descriptors.
|
|
Raises
|
------
|
OSError
|
If the input file does not exist or cannot be read.
|
UnpicklingError
|
If ``allow_pickle=True``, but the file cannot be loaded as a pickle.
|
ValueError
|
The file contains an object array, but ``allow_pickle=False`` given.
|
|
See Also
|
--------
|
save, savez, savez_compressed, loadtxt
|
memmap : Create a memory-map to an array stored in a file on disk.
|
lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
|
|
Notes
|
-----
|
- If the file contains pickle data, then whatever object is stored
|
in the pickle is returned.
|
- If the file is a ``.npy`` file, then a single array is returned.
|
- If the file is a ``.npz`` file, then a dictionary-like object is
|
returned, containing ``{filename: array}`` key-value pairs, one for
|
each file in the archive.
|
- If the file is a ``.npz`` file, the returned value supports the
|
context manager protocol in a similar fashion to the open function::
|
|
with load('foo.npz') as data:
|
a = data['a']
|
|
The underlying file descriptor is closed when exiting the 'with'
|
block.
|
|
Examples
|
--------
|
Store data to disk, and load it again:
|
|
>>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
|
>>> np.load('/tmp/123.npy')
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
Store compressed data to disk, and load it again:
|
|
>>> a=np.array([[1, 2, 3], [4, 5, 6]])
|
>>> b=np.array([1, 2])
|
>>> np.savez('/tmp/123.npz', a=a, b=b)
|
>>> data = np.load('/tmp/123.npz')
|
>>> data['a']
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
>>> data['b']
|
array([1, 2])
|
>>> data.close()
|
|
Mem-map the stored array, and then access the second row
|
directly from disk:
|
|
>>> X = np.load('/tmp/123.npy', mmap_mode='r')
|
>>> X[1, :]
|
memmap([4, 5, 6])
|
|
)rs Úlatin1ro z.encoding must be 'ASCII', 'latin1', or 'bytes')ÚencodingÚ fix_importsrC FÚrbTs PKs PKr )r[ rT rU rN l )ÚmoderN rj z@Cannot load file containing pickled data when allow_pickle=FalsezFailed to interpret file z as a pickleN)Ú
|
ValueErrorÚdictÚ
|
contextlibÚ ExitStackrE Ú enter_contextrk r rh r rl rC ÚseekÚminÚ
|
startswithÚpop_allrL Z open_memmaprm r r% Ú ExceptionÚUnpicklingError)rH Z mmap_moderT rv ru rN rU ÚstackrZ r[ Z _ZIP_PREFIXZ _ZIP_SUFFIXÚNrp ÚretÚer3 r3 r4 r% sT y
|
|
|
þ ÿþ
|
ÿÿc C s |fS r- r3 )rH ÚarrrT rv r3 r3 r4 Ú_save_dispatcher¿ s r c C sp t | drt | ¡}n$t| } | d¡s0| d } t| d}|(}t |¡}tj |||t
|
|dd W 5 Q R X dS )a<
|
Save an array to a binary file in NumPy ``.npy`` format.
|
|
Parameters
|
----------
|
file : file, str, or pathlib.Path
|
File or filename to which the data is saved. If file is a file-object,
|
then the filename is unchanged. If file is a string or Path, a ``.npy``
|
extension will be appended to the filename if it does not already
|
have one.
|
arr : array_like
|
Array data to be saved.
|
allow_pickle : bool, optional
|
Allow saving object arrays using Python pickles. Reasons for disallowing
|
pickles include security (loading pickled data can execute arbitrary
|
code) and portability (pickled objects may not be loadable on different
|
Python installations, for example if the stored objects require libraries
|
that are not available, and not all pickled data is compatible between
|
Python 2 and Python 3).
|
Default: True
|
fix_imports : bool, optional
|
Only useful in forcing objects in object arrays on Python 3 to be
|
pickled in a Python 2 compatible way. If `fix_imports` is True, pickle
|
will try to map the new Python 3 names to the old module names used in
|
Python 2, so that the pickle data stream is readable with Python 2.
|
|
See Also
|
--------
|
savez : Save several arrays into a ``.npz`` archive
|
savetxt, load
|
|
Notes
|
-----
|
For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
|
|
Any data saved to the file is appended to the end of the file.
|
|
Examples
|
--------
|
>>> from tempfile import TemporaryFile
|
>>> outfile = TemporaryFile()
|
|
>>> x = np.arange(10)
|
>>> np.save(outfile, x)
|
|
>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
|
>>> np.load(outfile)
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
|
|
>>> with open('test.npy', 'wb') as f:
|
... np.save(f, np.array([1, 2]))
|
... np.save(f, np.array([1, 3]))
|
>>> with open('test.npy', 'rb') as f:
|
... a = np.load(f)
|
... b = np.load(f)
|
>>> print(a, b)
|
# [1 2] [1 3]
|
ÚwriterO Úwb)rv ©rT rU N) rE r{ Ú nullcontextr rV rk ÚnpÚ
|
asanyarrayr Ú write_arrayrz )rH r rT rv Zfile_ctxrZ r3 r3 r4 r& Ã s =
|
|
|
|
|
ÿc o s |E d H | ¡ E d H d S r- ©Úvalues©rH rI Úkwdsr3 r3 r4 Ú_savez_dispatcher s
|
r c O s t | ||d dS )aÄ Save several arrays into a single file in uncompressed ``.npz`` format.
|
|
Provide arrays as keyword arguments to store them under the
|
corresponding name in the output file: ``savez(fn, x=x, y=y)``.
|
|
If arrays are specified as positional arguments, i.e., ``savez(fn,
|
x, y)``, their names will be `arr_0`, `arr_1`, etc.
|
|
Parameters
|
----------
|
file : str or file
|
Either the filename (string) or an open file (file-like object)
|
where the data will be saved. If file is a string or a Path, the
|
``.npz`` extension will be appended to the filename if it is not
|
already there.
|
args : Arguments, optional
|
Arrays to save to the file. Please use keyword arguments (see
|
`kwds` below) to assign names to arrays. Arrays specified as
|
args will be named "arr_0", "arr_1", and so on.
|
kwds : Keyword arguments, optional
|
Arrays to save to the file. Each array will be saved to the
|
output file with its corresponding keyword name.
|
|
Returns
|
-------
|
None
|
|
See Also
|
--------
|
save : Save a single array to a binary file in NumPy format.
|
savetxt : Save an array to a file as plain text.
|
savez_compressed : Save several arrays into a compressed ``.npz`` archive
|
|
Notes
|
-----
|
The ``.npz`` file format is a zipped archive of files named after the
|
variables they contain. The archive is not compressed and each file
|
in the archive contains one variable in ``.npy`` format. For a
|
description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
|
|
When opening the saved ``.npz`` file with `load` a `NpzFile` object is
|
returned. This is a dictionary-like object which can be queried for
|
its list of arrays (with the ``.files`` attribute), and for the arrays
|
themselves.
|
|
Keys passed in `kwds` are used as filenames inside the ZIP archive.
|
Therefore, keys should be valid filenames; e.g., avoid keys that begin with
|
``/`` or contain ``.``.
|
|
When naming variables with keyword arguments, it is not possible to name a
|
variable ``file``, as this would cause the ``file`` argument to be defined
|
twice in the call to ``savez``.
|
|
Examples
|
--------
|
>>> from tempfile import TemporaryFile
|
>>> outfile = TemporaryFile()
|
>>> x = np.arange(10)
|
>>> y = np.sin(x)
|
|
Using `savez` with \*args, the arrays are saved with default names.
|
|
>>> np.savez(outfile, x, y)
|
>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
|
>>> npzfile = np.load(outfile)
|
>>> npzfile.files
|
['arr_0', 'arr_1']
|
>>> npzfile['arr_0']
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
|
Using `savez` with \**kwds, the arrays are saved with the keyword names.
|
|
>>> outfile = TemporaryFile()
|
>>> np.savez(outfile, x=x, y=y)
|
>>> _ = outfile.seek(0)
|
>>> npzfile = np.load(outfile)
|
>>> sorted(npzfile.files)
|
['x', 'y']
|
>>> npzfile['x']
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
|
FN©Ú_savezr r3 r3 r4 r' s Tc o s |E d H | ¡ E d H d S r- r r r3 r3 r4 Ú _savez_compressed_dispatcherj s
|
r c O s t | ||d dS )aì
|
Save several arrays into a single file in compressed ``.npz`` format.
|
|
Provide arrays as keyword arguments to store them under the
|
corresponding name in the output file: ``savez(fn, x=x, y=y)``.
|
|
If arrays are specified as positional arguments, i.e., ``savez(fn,
|
x, y)``, their names will be `arr_0`, `arr_1`, etc.
|
|
Parameters
|
----------
|
file : str or file
|
Either the filename (string) or an open file (file-like object)
|
where the data will be saved. If file is a string or a Path, the
|
``.npz`` extension will be appended to the filename if it is not
|
already there.
|
args : Arguments, optional
|
Arrays to save to the file. Please use keyword arguments (see
|
`kwds` below) to assign names to arrays. Arrays specified as
|
args will be named "arr_0", "arr_1", and so on.
|
kwds : Keyword arguments, optional
|
Arrays to save to the file. Each array will be saved to the
|
output file with its corresponding keyword name.
|
|
Returns
|
-------
|
None
|
|
See Also
|
--------
|
numpy.save : Save a single array to a binary file in NumPy format.
|
numpy.savetxt : Save an array to a file as plain text.
|
numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
|
numpy.load : Load the files created by savez_compressed.
|
|
Notes
|
-----
|
The ``.npz`` file format is a zipped archive of files named after the
|
variables they contain. The archive is compressed with
|
``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
|
in ``.npy`` format. For a description of the ``.npy`` format, see
|
:py:mod:`numpy.lib.format`.
|
|
|
When opening the saved ``.npz`` file with `load` a `NpzFile` object is
|
returned. This is a dictionary-like object which can be queried for
|
its list of arrays (with the ``.files`` attribute), and for the arrays
|
themselves.
|
|
Examples
|
--------
|
>>> test_array = np.random.rand(3, 2)
|
>>> test_vector = np.random.rand(4)
|
>>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
|
>>> loaded = np.load('/tmp/123.npz')
|
>>> print(np.array_equal(test_array, loaded['a']))
|
True
|
>>> print(np.array_equal(test_vector, loaded['b']))
|
True
|
|
TNr r r3 r3 r4 r( o s ?c
|
C sè dd l }t| ds,t| } | d¡s,| d } |}t|D ]0\}} d| }
|
|
|
| ¡ kr`td|
|
| ||
|
< q8|rv|j} n|j} t | d| d} |
|
¡ D ]H\}
|
} |
|
d } t | ¡} | j | dd d
|
}tj|| ||d W 5 Q R X q| ¡ d S ) Nr r z.npzzarr_%dz,Cannot use un-named variables and keyword %sÚw)rx Ú compressionrO T)Ú force_zip64r )rF rE r rV Ú enumerater< ry Ú ZIP_DEFLATEDÚ
|
ZIP_STOREDrK Úitemsr r rk r r r` )rH rI r ÚcompressrT rU rF ZnamedictÚiÚvalr: r ZzipfÚfnamerZ r3 r3 r4 r ± s4
|
|
ÿ
|
|
þr c C s | dkrt d| dS )zÈJust checks if the param ndmin is supported on
|
_ensure_ndmin_ndarray. It is intended to be used as
|
verification before running anything expensive.
|
e.g. loadtxt, genfromtxt
|
)r r é z Illegal value of ndmin keyword: N)ry ©Úndminr3 r3 r4 Ú!_ensure_ndmin_ndarray_check_paramÖ s r§ r¥ c C sJ | j |krt | ¡} | j |k rF|dkr2t | ¡} n|dkrFt | ¡j} | S )a This is a helper function of loadtxt and genfromtxt to ensure
|
proper minimum dimension as requested
|
|
ndim : int. Supported values 1, 2, 3
|
^^ whenever this changes, keep in sync with
|
_ensure_ndmin_ndarray_check_param
|
r r¤ )Úndimr ZsqueezeZ
|
atleast_1dÚ
|
atleast_2dÚT)Úar¦ r3 r3 r4 Ú_ensure_ndmin_ndarrayà s
|
|
|
|
r¬ iPÃ )Úlikec C s | fS r- r3 ) r£ ÚdtypeÚcommentsÚ delimiterÚ
|
convertersÚskiprowsÚusecolsÚunpackr¦ ru Úmax_rowsr r3 r3 r4 Ú_loadtxt_dispatcherû s r¶ Úargumentc C sN zt | ¡ W n$ tk
|
r2 t| dd Y nX | dk rJt| dd S )Nz must be an integerr z must be nonnegative)Úoperatorr Ú TypeErrorry )ÚvalueÚnamer3 r3 r4 Ú_check_nonneg_int s r¼ c c sB | D ]8}t |tr | |¡}|D ]}| |d¡d }q |V qdS )a
|
Generator that consumes a line iterated iterable and strips out the
|
multiple (or multi-character) comments from lines.
|
This is a pre-processing step to achieve feature parity with loadtxt
|
(we assume that this feature is a nieche feature).
|
r r N)Ú
|
isinstancero ÚdecodeÚsplit)Úiterabler¯ ru ÚlineÚcr3 r3 r4 Ú_preprocess_comments s
|
|
rà ú,ú#ú"Újro ) r° ÚcommentÚquoteÚimaginary_unitr³ Ú skiplinesrµ r± r¦ r´ r® ru c s. d} | dkrd} d} | dkr$t dt | ¡} d}| jdkrj| dks\| dks\| d ks\| d
|
krj| }t t¡} |dk rz t|}W n t k
|
r |g}Y nX t| |dkr°d}nd |krÀtd t|}d}t |d krÞd}n^t |dkr t
|
|d t r<t |d dkr<|d }d}n ||kr<t d| d| d|dk rX|dk rXtdt |dkrntdt | |dk rt | nd}t ¡ }d}zt
|
| tjr´t | ¡} t
|
| t rþtjjj| d| d}| dkrêt|dd} t |¡}|}d}n | dkrt| dd} t| }W n: t k
|
rX } ztdt| d|W 5 d}~X Y nX |P |dk r|r~t|}d}t||| }|dkr¸t|||||||||| | || d nô|rÆt|}d}|d krØd}g }|d kr`|d k röt}n
|
t t|}t|||||||||| | || |d }| | |¡¡ d }|d krJ||8 }t ||k rÜq`qÜt |dkrt |d d kr|d= t |dkr|d ntj |d d W 5 Q R X t | d j!rò j!d d kròt"j#d | d!t$d"d# |
|
r& j}|j%dk r fd$d%|j%D S j&S n S dS )&a¬
|
Read a NumPy array from a text file.
|
|
Parameters
|
----------
|
fname : str or file object
|
The filename or the file to be read.
|
delimiter : str, optional
|
Field delimiter of the fields in line of the file.
|
Default is a comma, ','. If None any sequence of whitespace is
|
considered a delimiter.
|
comment : str or sequence of str or None, optional
|
Character that begins a comment. All text from the comment
|
character to the end of the line is ignored.
|
Multiple comments or multiple-character comment strings are supported,
|
but may be slower and `quote` must be empty if used.
|
Use None to disable all use of comments.
|
quote : str or None, optional
|
Character that is used to quote string fields. Default is '"'
|
(a double quote). Use None to disable quote support.
|
imaginary_unit : str, optional
|
Character that represent the imaginay unit `sqrt(-1)`.
|
Default is 'j'.
|
usecols : array_like, optional
|
A one-dimensional array of integer column numbers. These are the
|
columns from the file to be included in the array. If this value
|
is not given, all the columns are used.
|
skiplines : int, optional
|
Number of lines to skip before interpreting the data in the file.
|
max_rows : int, optional
|
Maximum number of rows of data to read. Default is to read the
|
entire file.
|
converters : dict or callable, optional
|
A function to parse all columns strings into the desired value, or
|
a dictionary mapping column number to a parser function.
|
E.g. if column 0 is a date string: ``converters = {0: datestr2num}``.
|
Converters can also be used to provide a default value for missing
|
data, e.g. ``converters = lambda s: float(s.strip() or 0)`` will
|
convert empty fields to 0.
|
Default: None
|
ndmin : int, optional
|
Minimum dimension of the array returned.
|
Allowed values are 0, 1 or 2. Default is 0.
|
unpack : bool, optional
|
If True, the returned array is transposed, so that arguments may be
|
unpacked using ``x, y, z = read(...)``. When used with a structured
|
data-type, arrays are returned for each field. Default is False.
|
dtype : numpy data type
|
A NumPy dtype instance, can be a structured dtype to map to the
|
columns of the file.
|
encoding : str, optional
|
Encoding used to decode the inputfile. The special value 'bytes'
|
(the default) enables backwards-compatible behavior for `converters`,
|
ensuring that inputs to the converter functions are encoded
|
bytes objects. The special value 'bytes' has no additional effect if
|
``converters=None``. If encoding is ``'bytes'`` or ``None``, the
|
default system encoding is used.
|
|
Returns
|
-------
|
ndarray
|
NumPy array.
|
|
Examples
|
--------
|
First we create a file for the example.
|
|
>>> s1 = '1.0,2.0,3.0\n4.0,5.0,6.0\n'
|
>>> with open('example1.csv', 'w') as f:
|
... f.write(s1)
|
>>> a1 = read_from_filename('example1.csv')
|
>>> a1
|
array([[1., 2., 3.],
|
[4., 5., 6.]])
|
|
The second example has columns with different data types, so a
|
one-dimensional array with a structured data type is returned.
|
The tab character is used as the field delimiter.
|
|
>>> s2 = '1.0\t10\talpha\n2.3\t25\tbeta\n4.5\t16\tgamma\n'
|
>>> with open('example2.tsv', 'w') as f:
|
... f.write(s2)
|
>>> a2 = read_from_filename('example2.tsv', delimiter='\t')
|
>>> a2
|
array([(1. , 10, b'alpha'), (2.3, 25, b'beta'), (4.5, 16, b'gamma')],
|
dtype=[('f0', '<f8'), ('f1', 'u1'), ('f2', 'S5')])
|
Fro NTza dtype must be provided.ZSUMZS0ZU0ZM8Zm8Ú zJcomments cannot be an empty string. Use comments=None to disable comments.r r zComment characters 'z ' cannot include the delimiter 'ú'zwhen multiple comments or a multi-character comment is given, quotes are not supported. In this case quotechar must be set to None.z len(imaginary_unit) must be 1.éÿÿÿÿÚrt©ru ru rt zGfname must be a string, filehandle, list of strings,
|
or generator. Got ú instead.) r° rÈ rÉ rÊ r³ rË rµ r± r® ru ÚfilelikeÚbyte_convertersÚS) r° rÈ rÉ rÊ r³ rË rµ r± r® ru rÒ rÓ Úc_byte_converters)Zaxisr¥ z#loadtxt: input contained no data: "rÆ é )ÚcategoryÚ
|
stacklevelc s g | ] } | qS r3 r3 ©Ú.0Úfield©r r3 r4 Ú
|
<listcomp>2 s z_read.<locals>.<listcomp>)'r¹ r r® Úkindr6 r; r§ ry Útuplerh r½ Ústrr¼ r{ r ÚosÚPathLikeÚfspathÚlibÚ _datasourcerk ÚgetattrÚclosingrf Útyperà r Ú_loadtxt_chunksizer rW ZastypeZ concatenater¬ ÚshapeÚwarningsÚwarnÚ UserWarningÚnamesrª )r£ r° rÈ rÉ rÊ r³ rË rµ r± r¦ r´ r® ru rÓ Z read_dtype_via_object_chunksr¯ Zfh_closing_ctxrÒ ÚfhÚdatar rÕ ÚchunksÚ
|
chunk_sizeZnext_arrr² Údtr3 rÜ r4 Ú_read! s( \
|
|
ÿÿÿÿ
|
ÿ "
|
ÿ
|
|
ÿ
|
|
|
|
|
|
ÿþ
|
|
ú
|
|
|
|
ù
|
|
|
ý rô )Ú quotecharr c C s° | dk r(t | ||||||||| |
|
| d S t|tr<| d¡ |dkrJtj}|} | dk rxt| ttfrj| g} dd | D } t|tr| d¡}t| || ||||||| |
|
| d }|S )a '
|
Load data from a text file.
|
|
Parameters
|
----------
|
fname : file, str, pathlib.Path, list of str, generator
|
File, filename, list, or generator to read. If the filename
|
extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
|
that generators must return bytes or strings. The strings
|
in a list or produced by a generator are treated as lines.
|
dtype : data-type, optional
|
Data-type of the resulting array; default: float. If this is a
|
structured data-type, the resulting array will be 1-dimensional, and
|
each row will be interpreted as an element of the array. In this
|
case, the number of columns used must match the number of fields in
|
the data-type.
|
comments : str or sequence of str or None, optional
|
The characters or list of characters used to indicate the start of a
|
comment. None implies no comments. For backwards compatibility, byte
|
strings will be decoded as 'latin1'. The default is '#'.
|
delimiter : str, optional
|
The character used to separate the values. For backwards compatibility,
|
byte strings will be decoded as 'latin1'. The default is whitespace.
|
|
.. versionchanged:: 1.23.0
|
Only single character delimiters are supported. Newline characters
|
cannot be used as the delimiter.
|
|
converters : dict or callable, optional
|
Converter functions to customize value parsing. If `converters` is
|
callable, the function is applied to all columns, else it must be a
|
dict that maps column number to a parser function.
|
See examples for further details.
|
Default: None.
|
|
.. versionchanged:: 1.23.0
|
The ability to pass a single callable to be applied to all columns
|
was added.
|
|
skiprows : int, optional
|
Skip the first `skiprows` lines, including comments; default: 0.
|
usecols : int or sequence, optional
|
Which columns to read, with 0 being the first. For example,
|
``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
|
The default, None, results in all columns being read.
|
|
.. versionchanged:: 1.11.0
|
When a single column has to be read it is possible to use
|
an integer instead of a tuple. E.g ``usecols = 3`` reads the
|
fourth column the same way as ``usecols = (3,)`` would.
|
unpack : bool, optional
|
If True, the returned array is transposed, so that arguments may be
|
unpacked using ``x, y, z = loadtxt(...)``. When used with a
|
structured data-type, arrays are returned for each field.
|
Default is False.
|
ndmin : int, optional
|
The returned array will have at least `ndmin` dimensions.
|
Otherwise mono-dimensional axes will be squeezed.
|
Legal values: 0 (default), 1 or 2.
|
|
.. versionadded:: 1.6.0
|
encoding : str, optional
|
Encoding used to decode the inputfile. Does not apply to input streams.
|
The special value 'bytes' enables backward compatibility workarounds
|
that ensures you receive byte arrays as results if possible and passes
|
'latin1' encoded strings to converters. Override this value to receive
|
unicode arrays and pass strings as input to converters. If set to None
|
the system default is used. The default value is 'bytes'.
|
|
.. versionadded:: 1.14.0
|
max_rows : int, optional
|
Read `max_rows` rows of content after `skiprows` lines. The default is
|
to read all the rows. Note that empty rows containing no data such as
|
empty lines and comment lines are not counted towards `max_rows`,
|
while such lines are counted in `skiprows`.
|
|
.. versionadded:: 1.16.0
|
|
.. versionchanged:: 1.23.0
|
Lines containing no data, including comment lines (e.g., lines
|
starting with '#' or as specified via `comments`) are not counted
|
towards `max_rows`.
|
quotechar : unicode character or None, optional
|
The character used to denote the start and end of a quoted item.
|
Occurrences of the delimiter or comment characters are ignored within
|
a quoted item. The default value is ``quotechar=None``, which means
|
quoting support is disabled.
|
|
If two consecutive instances of `quotechar` are found within a quoted
|
field, the first is treated as an escape character. See examples.
|
|
.. versionadded:: 1.23.0
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
out : ndarray
|
Data read from the text file.
|
|
See Also
|
--------
|
load, fromstring, fromregex
|
genfromtxt : Load data with missing values handled as specified.
|
scipy.io.loadmat : reads MATLAB data files
|
|
Notes
|
-----
|
This function aims to be a fast reader for simply formatted files. The
|
`genfromtxt` function provides more sophisticated handling of, e.g.,
|
lines with missing values.
|
|
Each row in the input text file must have the same number of values to be
|
able to read all values. If all rows do not have same number of values, a
|
subset of up to n columns (where n is the least number of values present
|
in all rows) can be read by specifying the columns via `usecols`.
|
|
.. versionadded:: 1.10.0
|
|
The strings produced by the Python float.hex method can be used as
|
input for floats.
|
|
Examples
|
--------
|
>>> from io import StringIO # StringIO behaves like a file object
|
>>> c = StringIO("0 1\n2 3")
|
>>> np.loadtxt(c)
|
array([[0., 1.],
|
[2., 3.]])
|
|
>>> d = StringIO("M 21 72\nF 35 58")
|
>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
|
... 'formats': ('S1', 'i4', 'f4')})
|
array([(b'M', 21, 72.), (b'F', 35, 58.)],
|
dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])
|
|
>>> c = StringIO("1,0,2\n3,0,4")
|
>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
|
>>> x
|
array([1., 3.])
|
>>> y
|
array([2., 4.])
|
|
The `converters` argument is used to specify functions to preprocess the
|
text prior to parsing. `converters` can be a dictionary that maps
|
preprocessing functions to each column:
|
|
>>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
|
>>> conv = {
|
... 0: lambda x: np.floor(float(x)), # conversion fn for column 0
|
... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1
|
... }
|
>>> np.loadtxt(s, delimiter=",", converters=conv)
|
array([[1., 3.],
|
[3., 5.]])
|
|
`converters` can be a callable instead of a dictionary, in which case it
|
is applied to all columns:
|
|
>>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
|
>>> import functools
|
>>> conv = functools.partial(int, base=16)
|
>>> np.loadtxt(s, converters=conv)
|
array([[222., 173.],
|
[192., 222.]])
|
|
This example shows how `converters` can be used to convert a field
|
with a trailing minus sign into a negative number.
|
|
>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
|
>>> def conv(fld):
|
... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
|
...
|
>>> np.loadtxt(s, converters=conv)
|
array([[ 10.01, -31.25],
|
[ 19.22, 64.31],
|
[-17.57, 63.94]])
|
|
Using a callable as the converter can be particularly useful for handling
|
values with different formatting, e.g. floats with underscores:
|
|
>>> s = StringIO("1 2.7 100_000")
|
>>> np.loadtxt(s, converters=float)
|
array([1.e+00, 2.7e+00, 1.e+05])
|
|
This idea can be extended to automatically handle values specified in
|
many different formats:
|
|
>>> def conv(val):
|
... try:
|
... return float(val)
|
... except ValueError:
|
... return float.fromhex(val)
|
>>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
|
>>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None)
|
array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])
|
|
Note that with the default ``encoding="bytes"``, the inputs to the
|
converter function are latin-1 encoded byte strings. To deactivate the
|
implicit encoding prior to conversion, use ``encoding=None``
|
|
>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
|
>>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)
|
>>> np.loadtxt(s, converters=conv, encoding=None)
|
array([[ 10.01, -31.25],
|
[ 19.22, 64.31],
|
[-17.57, 63.94]])
|
|
Support for quoted fields is enabled with the `quotechar` parameter.
|
Comment and delimiter characters are ignored when they appear within a
|
quoted item delineated by `quotechar`:
|
|
>>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
|
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
|
>>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
|
array([('alpha, #42', 10.), ('beta, #64', 2.)],
|
dtype=[('label', '<U12'), ('value', '<f8')])
|
|
Quoted fields can be separated by multiple whitespace characters:
|
|
>>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n')
|
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
|
>>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
|
array([('alpha, #42', 10.), ('beta, #64', 2.)],
|
dtype=[('label', '<U12'), ('value', '<f8')])
|
|
Two consecutive quote characters within a quoted field are treated as a
|
single escaped character:
|
|
>>> s = StringIO('"Hello, my name is ""Monty""!"')
|
>>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
|
array('Hello, my name is "Monty"!', dtype='<U26')
|
|
Read subset of columns when all rows do not contain equal number of values:
|
|
>>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
|
>>> np.loadtxt(d, usecols=(0, 1))
|
array([[ 1., 2.],
|
[ 2., 4.],
|
[ 3., 9.],
|
[ 4., 16.]])
|
|
N) r® r¯ r° r± r² r³ r´ r¦ ru rµ r rt c S s$ g | ] }t |tr | d ¡n|qS )rt )r½ ro r¾ )rÚ r] r3 r3 r4 rÝ G s zloadtxt.<locals>.<listcomp>) r® rÈ r° r± rË r³ r´ r¦ ru rµ rÉ )Ú_loadtxt_with_liker½ ro r¾ r Úfloat64rà rô )r£ r® r¯ r° r± r² r³ r´ r¦ ru rµ rõ r rÈ r r3 r3 r4 r! 9 sP | ü
|
|
ÿ
|
|
|
ý)Zuse_likec C s |fS r- r3 ) r£ ÚXÚfmtr° ÚnewlineÚheaderÚfooterr¯ ru r3 r3 r4 Ú_savetxt_dispatcherY s rý ú%.18eú Ú
|
rÌ ú# c C s0 t |trt|}t|}G dd d} d}
|
t | tr>t| } t| rnt| d ¡ tj j
|
j| d|d} d}
|
n"t | dr| | |pd} nt d zt |¡}|jd
|
ks²|jd krÂt d |j n@|jd krø|jjdkrêt |¡j}d } n t|jj} n
|
|jd } t |¡} t|ttfkrRt|| kr<tdt| t| t t|¡}n t |trä| d¡}t d| }|d kr®| rd||f g| }n
|
|g| }| |¡}n4| rÈ|d | krÈ|n| sÞ|| krÞ|n|}nt d|f t|d
|
kr"| dd| ¡}| || | ¡ | r|D ]P}g }|D ] }| |j!¡ | |j"¡ q8|t| | }| | dd¡¡ q,nh|D ]b}z|t| | }W n< t#k
|
rØ } z t#dt|j|f |W 5 d}~X Y nX | |¡ qt|d
|
kr| dd| ¡}| || | ¡ W 5 |
|
r*| ¡ X dS )aÛ
|
Save an array to a text file.
|
|
Parameters
|
----------
|
fname : filename or file handle
|
If the filename ends in ``.gz``, the file is automatically saved in
|
compressed gzip format. `loadtxt` understands gzipped files
|
transparently.
|
X : 1D or 2D array_like
|
Data to be saved to a text file.
|
fmt : str or sequence of strs, optional
|
A single format (%10.5f), a sequence of formats, or a
|
multi-format string, e.g. 'Iteration %d -- %10.5f', in which
|
case `delimiter` is ignored. For complex `X`, the legal options
|
for `fmt` are:
|
|
* a single specifier, `fmt='%.4e'`, resulting in numbers formatted
|
like `' (%s+%sj)' % (fmt, fmt)`
|
* a full string specifying every real and imaginary part, e.g.
|
`' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
|
* a list of specifiers, one per column - in this case, the real
|
and imaginary part must have separate specifiers,
|
e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
|
delimiter : str, optional
|
String or character separating columns.
|
newline : str, optional
|
String or character separating lines.
|
|
.. versionadded:: 1.5.0
|
header : str, optional
|
String that will be written at the beginning of the file.
|
|
.. versionadded:: 1.7.0
|
footer : str, optional
|
String that will be written at the end of the file.
|
|
.. versionadded:: 1.7.0
|
comments : str, optional
|
String that will be prepended to the ``header`` and ``footer`` strings,
|
to mark them as comments. Default: '# ', as expected by e.g.
|
``numpy.loadtxt``.
|
|
.. versionadded:: 1.7.0
|
encoding : {None, str}, optional
|
Encoding used to encode the outputfile. Does not apply to output
|
streams. If the encoding is something other than 'bytes' or 'latin1'
|
you will not be able to load the file in NumPy versions < 1.14. Default
|
is 'latin1'.
|
|
.. versionadded:: 1.14.0
|
|
|
See Also
|
--------
|
save : Save an array to a binary file in NumPy ``.npy`` format
|
savez : Save several arrays into an uncompressed ``.npz`` archive
|
savez_compressed : Save several arrays into a compressed ``.npz`` archive
|
|
Notes
|
-----
|
Further explanation of the `fmt` parameter
|
(``%[flag]width[.precision]specifier``):
|
|
flags:
|
``-`` : left justify
|
|
``+`` : Forces to precede result with + or -.
|
|
``0`` : Left pad the number with zeros instead of space (see width).
|
|
width:
|
Minimum number of characters to be printed. The value is not truncated
|
if it has more characters.
|
|
precision:
|
- For integer specifiers (eg. ``d,i,o,x``), the minimum number of
|
digits.
|
- For ``e, E`` and ``f`` specifiers, the number of digits to print
|
after the decimal point.
|
- For ``g`` and ``G``, the maximum number of significant digits.
|
- For ``s``, the maximum number of characters.
|
|
specifiers:
|
``c`` : character
|
|
``d`` or ``i`` : signed decimal integer
|
|
``e`` or ``E`` : scientific notation with ``e`` or ``E``.
|
|
``f`` : decimal floating point
|
|
``g,G`` : use the shorter of ``e,E`` or ``f``
|
|
``o`` : signed octal
|
|
``s`` : string of characters
|
|
``u`` : unsigned decimal integer
|
|
``x,X`` : unsigned hexadecimal integer
|
|
This explanation of ``fmt`` is not complete, for an exhaustive
|
specification see [1]_.
|
|
References
|
----------
|
.. [1] `Format Specification Mini-Language
|
<https://docs.python.org/library/string.html#format-specification-mini-language>`_,
|
Python Documentation.
|
|
Examples
|
--------
|
>>> x = y = z = np.arange(0.0,5.0,1.0)
|
>>> np.savetxt('test.out', x, delimiter=',') # X is an array
|
>>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays
|
>>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation
|
|
c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dS )zsavetxt.<locals>.WriteWrapz0Convert to bytes on bytestream inputs.
|
|
c S s || _ || _| j| _d S r- )rï ru Ú first_writeÚdo_write)r1 rï ru r3 r3 r4 r5 ã s z#savetxt.<locals>.WriteWrap.__init__c S s | j ¡ d S r- )rï r` r= r3 r3 r4 r` è s z savetxt.<locals>.WriteWrap.closec S s | |¡ d S r- )r ©r1 Úvr3 r3 r4 r ë s z savetxt.<locals>.WriteWrap.writec S s0 t |tr| j |¡ n| j | | j¡¡ d S r- )r½ ro rï r Úencoderu r r3 r3 r4 Ú write_bytesî s
|
z&savetxt.<locals>.WriteWrap.write_bytesc S s | j t|¡ d S r- )rï r r r r3 r3 r4 Ú write_normalô s z'savetxt.<locals>.WriteWrap.write_normalc S sB z| |¡ | j | _W n& tk
|
r< | |¡ | j| _Y nX d S r- )r r r¹ r r r3 r3 r4 r ÷ s
|
|
z&savetxt.<locals>.WriteWrap.first_writeN)
|
r? r@ rA rB r5 r` r r r r r3 r3 r3 r4 Ú WriteWrapß s r FÚwtrÐ Tr rt z%fname must be a string or file handler r¤ z.Expected 1D or 2D array, got %dD array insteadr Nzfmt has wrong shape. %sú%z'fmt has wrong number of %% formats: %sz (%s+%sj)zinvalid fmt: %rr z+-ú-z?Mismatch between array dtype ('%s') and format specifier ('%s'))$r½ ro r r r r rk r` r rä rå rE ry Zasarrayr¨ r® rî r© rª rh rê Z iscomplexobjrè r; rß r9 rà ÚjoinÚmapÚcountÚreplacer rW ÚrealÚimagr¹ )r£ rø rù r° rú rû rü r¯ ru r Úown_fhrï ZncolZ iscomplex_Xr Z n_fmt_charsÚerrorÚrowZrow2ÚnumberÚsr r r3 r3 r4 r _ s |
|
!
|
|
|
ÿ
|
|
|
|
|
|
þþc C s d}t | ds0t | ¡} tjjj| d|d} d}zÚt|tj sHt |¡}|j
|
dkrZt d| ¡ }t|t rt|trt|}n t|trt|t rt|}t |ds°t |¡}| |¡}|röt|d tsöt ||j
|
d ¡}tj||d
|
}||_ ntj||d
|
}|W ¢S |r| ¡ X dS ) aq
|
Construct an array from a text file, using regular expression parsing.
|
|
The returned array is always a structured array, and is constructed from
|
all matches of the regular expression in the file. Groups in the regular
|
expression are converted to fields of the structured array.
|
|
Parameters
|
----------
|
file : path or file
|
Filename or file object to read.
|
|
.. versionchanged:: 1.22.0
|
Now accepts `os.PathLike` implementations.
|
regexp : str or regexp
|
Regular expression used to parse the file.
|
Groups in the regular expression correspond to fields in the dtype.
|
dtype : dtype or list of dtypes
|
Dtype for the structured array; must be a structured datatype.
|
encoding : str, optional
|
Encoding used to decode the inputfile. Does not apply to input streams.
|
|
.. versionadded:: 1.14.0
|
|
Returns
|
-------
|
output : ndarray
|
The output array, containing the part of the content of `file` that
|
was matched by `regexp`. `output` is always a structured array.
|
|
Raises
|
------
|
TypeError
|
When `dtype` is not a valid dtype for a structured array.
|
|
See Also
|
--------
|
fromstring, loadtxt
|
|
Notes
|
-----
|
Dtypes for structured arrays can be specified in several forms, but all
|
forms specify at least the data type and field name. For details see
|
`basics.rec`.
|
|
Examples
|
--------
|
>>> from io import StringIO
|
>>> text = StringIO("1312 foo\n1534 bar\n444 qux")
|
|
>>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything]
|
>>> output = np.fromregex(text, regexp,
|
... [('num', np.int64), ('key', 'S3')])
|
>>> output
|
array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
|
dtype=[('num', '<i8'), ('key', 'S3')])
|
>>> output['num']
|
array([1312, 1534, 444])
|
|
FrC rÏ rÐ TNz$dtype must be a structured datatype.Úmatchr ©r® )rE rá rã r rä rå rk r` r½ r® rî r¹ rC ro rà r r ÚreÚcompileÚfindallrß Úarray) rH Úregexpr® ru r ÚcontentÚseqZnewdtypeÚoutputr3 r3 r4 r) W s4 >
|
|
|
|
|
|
|
|
)r¦ r c C s |fS r- r3 )r£ r® r¯ r° Ú skip_headerÚ skip_footerr± Úmissing_valuesÚfilling_valuesr³ rî Ú excludelistÚ deletecharsÚ replace_spaceÚ autostripÚcase_sensitiveÚ
|
defaultfmtr´ ÚusemaskÚlooseÚ invalid_raiserµ ru r¦ r r3 r3 r4 Ú_genfromtxt_dispatcher¿ s r/ Ú_zf%ic S sd |dk rBt | ||
|
||||| | | | ||||||||||dS t| |dk rn|r^td|dk rntd|rddlm}m} |pi }t|ts¤tdt | |d kr¶d}d
|
} nd } t| t
|
rÌt | } t| t röt jjj| d |d } t | ¡} n| } t | ¡} z t| } W n: tk
|
rJ } ztdt | d| W 5 d} ~ X Y nX | ò t||||d}!t| | || d}"zvt
|
D ]t| q~d}#|#sètt| |}$d
|
krÜ|dk rÜ||$krÜd |$ |¡dd
¡}$|!|$}#qW n0 t k
|
r d}$g }#t j d| dd Y nX d
|
krL|#d ¡ }%|dk rL|%|krL|#d= | dk r°zdd | d¡D } W n@ t k
|
r® z t!| } W n tk
|
r¨ | g} Y nX Y nX t"| pº|#}&d
|
krà|"dd |#D d}$n2t#r|"dd d¡D nr|"dk r2t$| | || ddk rDt!| r t%| D ]>\}'t#|'rt &|'¡| < n|'dk rR|'t"|# | < qRdk rÔt"|&krÔj't (fd d| D ¡t!j)n*dk r t"|&kr fd d| D n dk r dk r t!j)|p&d }(t|(t*r>|( +d ¡}(d d t|&D }t|(tr.|( ,¡ D ]Æ\})}*t#|)r¢z &|)¡})W n tk
|
r Y qdY nX | rÎz| &|)¡})W n tk
|
rÌ Y nX t|*t!t-frîd!d |*D }*n
|
t |*g}*|)dkr|D ]}+|+ .|*¡ qn||) .|*¡ qdnt|(t!t-frrt/|(|D ]&\},}-t |,},|,|-krH|- 0|,¡ qHnJt|(t r |( d¡}.|D ]}-|- .|.¡ qn |D ]}-|- .t |(g¡ q¤|}/|/dkrÎg }/dg|& }t|/trd|/ ,¡ D ]t\})}*t#|)r*z &|)¡})W n tk
|
r( Y qìY nX | rVz| &|)¡})W n tk
|
rT Y nX |*||)< qìnHt|/t!t-fr¢t"|/}0|0|&kr|/|d|0
< n |/d|&
}n
|
|/g|& }dkrÌd"d t/||D }nRt1d
|
d#}1t"|1dkrt/|1||}2d$d |2D }n t/||}2fd%d|2D }g }3| ,¡ D ]ö\}4 t#|4rnz &|4¡}4|4W n tk
|
rj Y q*Y nX n8| r¢z| &|4¡W n tk
|
r Y q*Y nX n|4t"|$rº|#|4 }5nd}5 t*krÎt2}6n"| rìd&d' }7t3j4|7 d(}6n }6| j5|6d
|
|5| | d) |3 0|6f¡ q*| 5|3¡ g j0}8|rFg }9|9j0}:g };|;j0}<t%t6 7|$g| ¡D ]Ü\}=|!|= t" }>|>dkrqb| rØz fd*d| D W n0 t8k
|
rÔ |<
|
d |>f Y qbY nX n"|>|&krú|<
|
d |>f qb|8t- | r(|:t-d+d t/ |D t" |krb q@qbW 5 Q R X dk
|
rt%|D ]º\}?fd,d D }@z|? 9|@¡ W n t:k
|
|
r d- }At;t< }@t%|@D ]X\}4},z|? =|,¡ W n> t>tfk
|
|
r |Ad.7 }A|A|4d
|
|,f; }At>|AY nX q´Y nX q\t"|;}B|Bdk
|
rÎt" |B | d/|& |dk
|
r|t"
|
fd0d|;D }C|;d|B|C
};||C8 } fd1d|;D }At"|A
|
rÎ|A ?dd2¡ d3 |A¡}A|
|
r¾t|Ant j |At@dd |dk
|
rú d|
|
|
rú|9d|
}9| r t!t/ fd4dt%|D n t!t/ fd5dt%|D }Ddk rêd6d |D }Ed7d t%|ED | rÚ rÚt j d8t jAdd fd9d:zfd;d|DD }DW n tBk
|
r Y nX D ]t jC|E< qÈ|Edd
}Ft%|ED ]<\}Gt D|Gt jE¡ rîtFfd<d=|DD }H|G|Hf|F< qîdk rd>d? t/||ED }It"|Idk rj|I\}J|JtG }K}Ln2fd@dt%|FD }K| rÄfdAdt%|FD }Ln&t!t/|F}Kt!t/tGgt"|F }Lt jH|D|KdB|rt jH|9|LdB}Mn° rj)dk r_)t"|1dk r¢dCdDd= |1D k rHtI r8tJdEnt jH|DdBn"t jH|DdFd |1D dB K¡|rt jH|9t (dGd |1D ¡dB}N|}L|N K|L¡}Mnø|rXd
|
}Og t%dHd |D D ]j\}P|kr |O|Pj kM }Ot D|Pt jE¡r |PtFfdId=|DD f}P 0d|Pf¡ n 0df¡ qÂ|OsXt"dkrNt (¡n
|
t (|P¡t H|D¡|rj)dk rdJd j)D }LntG}Lt jH|9|LdB}Mj(j)|rürüt/|D ]B\}Q fdKd jLD }|D ] }R|M|Q |Q |RkO < qØq¸|r K|¡|M_MtN|dL|r`dkr4jOS t"dkrNd S fdMdD S S )Na
|
Load data from a text file, with missing values handled as specified.
|
|
Each line past the first `skip_header` lines is split at the `delimiter`
|
character, and characters following the `comments` character are discarded.
|
|
Parameters
|
----------
|
fname : file, str, pathlib.Path, list of str, generator
|
File, filename, list, or generator to read. If the filename
|
extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
|
that generators must return bytes or strings. The strings
|
in a list or produced by a generator are treated as lines.
|
dtype : dtype, optional
|
Data type of the resulting array.
|
If None, the dtypes will be determined by the contents of each
|
column, individually.
|
comments : str, optional
|
The character used to indicate the start of a comment.
|
All the characters occurring on a line after a comment are discarded.
|
delimiter : str, int, or sequence, optional
|
The string used to separate values. By default, any consecutive
|
whitespaces act as delimiter. An integer or sequence of integers
|
can also be provided as width(s) of each field.
|
skiprows : int, optional
|
`skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
|
skip_header : int, optional
|
The number of lines to skip at the beginning of the file.
|
skip_footer : int, optional
|
The number of lines to skip at the end of the file.
|
converters : variable, optional
|
The set of functions that convert the data of a column to a value.
|
The converters can also be used to provide a default value
|
for missing data: ``converters = {3: lambda s: float(s or 0)}``.
|
missing : variable, optional
|
`missing` was removed in numpy 1.10. Please use `missing_values`
|
instead.
|
missing_values : variable, optional
|
The set of strings corresponding to missing data.
|
filling_values : variable, optional
|
The set of values to be used as default when the data are missing.
|
usecols : sequence, optional
|
Which columns to read, with 0 being the first. For example,
|
``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
|
names : {None, True, str, sequence}, optional
|
If `names` is True, the field names are read from the first line after
|
the first `skip_header` lines. This line can optionally be preceded
|
by a comment delimiter. If `names` is a sequence or a single-string of
|
comma-separated names, the names will be used to define the field names
|
in a structured dtype. If `names` is None, the names of the dtype
|
fields will be used, if any.
|
excludelist : sequence, optional
|
A list of names to exclude. This list is appended to the default list
|
['return','file','print']. Excluded names are appended with an
|
underscore: for example, `file` would become `file_`.
|
deletechars : str, optional
|
A string combining invalid characters that must be deleted from the
|
names.
|
defaultfmt : str, optional
|
A format used to define default field names, such as "f%i" or "f_%02i".
|
autostrip : bool, optional
|
Whether to automatically strip white spaces from the variables.
|
replace_space : char, optional
|
Character(s) used in replacement of white spaces in the variable
|
names. By default, use a '_'.
|
case_sensitive : {True, False, 'upper', 'lower'}, optional
|
If True, field names are case sensitive.
|
If False or 'upper', field names are converted to upper case.
|
If 'lower', field names are converted to lower case.
|
unpack : bool, optional
|
If True, the returned array is transposed, so that arguments may be
|
unpacked using ``x, y, z = genfromtxt(...)``. When used with a
|
structured data-type, arrays are returned for each field.
|
Default is False.
|
usemask : bool, optional
|
If True, return a masked array.
|
If False, return a regular array.
|
loose : bool, optional
|
If True, do not raise errors for invalid values.
|
invalid_raise : bool, optional
|
If True, an exception is raised if an inconsistency is detected in the
|
number of columns.
|
If False, a warning is emitted and the offending lines are skipped.
|
max_rows : int, optional
|
The maximum number of rows to read. Must not be used with skip_footer
|
at the same time. If given, the value must be at least 1. Default is
|
to read the entire file.
|
|
.. versionadded:: 1.10.0
|
encoding : str, optional
|
Encoding used to decode the inputfile. Does not apply when `fname` is
|
a file object. The special value 'bytes' enables backward compatibility
|
workarounds that ensure that you receive byte arrays when possible
|
and passes latin1 encoded strings to converters. Override this value to
|
receive unicode arrays and pass strings as input to converters. If set
|
to None the system default is used. The default value is 'bytes'.
|
|
.. versionadded:: 1.14.0
|
ndmin : int, optional
|
Same parameter as `loadtxt`
|
|
.. versionadded:: 1.23.0
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
out : ndarray
|
Data read from the text file. If `usemask` is True, this is a
|
masked array.
|
|
See Also
|
--------
|
numpy.loadtxt : equivalent function when no data is missing.
|
|
Notes
|
-----
|
* When spaces are used as delimiters, or when no delimiter has been given
|
as input, there should not be any missing data between two fields.
|
* When the variables are named (either by a flexible dtype or with `names`),
|
there must not be any header in the file (else a ValueError
|
exception is raised).
|
* Individual values are not stripped of spaces by default.
|
When using a custom converter, make sure the function does remove spaces.
|
|
References
|
----------
|
.. [1] NumPy User Guide, section `I/O with NumPy
|
<https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.
|
|
Examples
|
--------
|
>>> from io import StringIO
|
>>> import numpy as np
|
|
Comma delimited file with mixed dtype
|
|
>>> s = StringIO(u"1,1.3,abcde")
|
>>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
|
... ('mystring','S5')], delimiter=",")
|
>>> data
|
array((1, 1.3, b'abcde'),
|
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
|
|
Using dtype = None
|
|
>>> _ = s.seek(0) # needed for StringIO example only
|
>>> data = np.genfromtxt(s, dtype=None,
|
... names = ['myint','myfloat','mystring'], delimiter=",")
|
>>> data
|
array((1, 1.3, b'abcde'),
|
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
|
|
Specifying dtype and names
|
|
>>> _ = s.seek(0)
|
>>> data = np.genfromtxt(s, dtype="i8,f8,S5",
|
... names=['myint','myfloat','mystring'], delimiter=",")
|
>>> data
|
array((1, 1.3, b'abcde'),
|
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
|
|
An example with fixed-width columns
|
|
>>> s = StringIO(u"11.3abcde")
|
>>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
|
... delimiter=[1,3,5])
|
>>> data
|
array((1, 1.3, b'abcde'),
|
dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])
|
|
An example to show comments
|
|
>>> f = StringIO('''
|
... text,# of chars
|
... hello world,11
|
... numpy,5''')
|
>>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
|
array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
|
dtype=[('f0', 'S12'), ('f1', 'S12')])
|
|
N)r® r¯ r° r" r# r± r$ r% r³ rî r& r' r( r) r* r+ r´ r, r- r. rµ ru r¦ r zPThe keywords 'skip_footer' and 'max_rows' can not be specified at the same time.r z 'max_rows' must be at least 1.r )Ú MaskedArrayÚmake_mask_descrzNThe input argument 'converter' should be a valid dictionary (got '%s' instead)ro TFrÏ rÐ z\fname must be a string, a filehandle, a sequence of strings,
|
or an iterator of strings. Got rÑ )r° r¯ r) ru )r& r' r* r( rÌ z"genfromtxt: Empty input file: "%s"r¤ )rØ c S s g | ] }| ¡ qS r3 ©Ústrip©rÚ r0 r3 r3 r4 rÝ ì s z genfromtxt.<locals>.<listcomp>rÄ c S s g | ]}t | ¡ qS r3 )rà r4 r5 r3 r3 r4 rÝ ö s c S s g | ] }| ¡ qS r3 r3 r5 r3 r3 r4 rÝ ù s )r+ rî r& r' r* r( c s g | ] } | qS r3 r3 r5 )Údescrr3 r4 rÝ s c s g | ] } | qS r3 r3 r5 )rî r3 r4 rÝ s r3 rt c S s g | ]}t d gqS ©rÌ )r; r5 r3 r3 r4 rÝ s c S s g | ] }t |qS r3 )rà r5 r3 r3 r4 rÝ 6 s c S s g | ]\}}t d ||dqS )N)r$ Údefault©r ©rÚ ÚmissÚfillr3 r3 r4 rÝ x s ÿ)Z flatten_basec S s" g | ]\}}}t |d ||dqS ©T)Úlockedr$ r8 r9 )rÚ ró r; r< r3 r3 r4 rÝ s
|
þ ÿc s g | ]\}}t d ||dqS r= r9 r: r r3 r4 rÝ s
|
þ ÿc S s" t | tkr|| S || d¡S ©Nrt )rè ro r )r] Úconvr3 r3 r4 Ú tobytes_first¥ s z!genfromtxt.<locals>.tobytes_first©r@ )r> Ú testing_valuer8 r$ c s g | ] } | qS r3 r3 r5 r r3 r4 rÝ Í s c S s g | ]\}}| ¡ |kqS r3 r3 )rÚ r Úmr3 r3 r4 rÝ × s ÿc s g | ]}t |qS r3 )r )rÚ Ú_m©r¡ r3 r4 rÝ à s z0Converter #%i is locked and cannot be upgraded: z"(occurred line #%i for value '%s')z- Line #%%i (got %%i columns instead of %i)c s g | ]}|d kr|qS )r r3 r5 )Únbrowsr" r3 r4 rÝ õ s ÿc s g | ]\}} ||f qS r3 r3 )rÚ r¡ Únb)Útemplater3 r4 rÝ þ s ÿzSome errors were detected !r c s, g | ]$\} fd dt t|D qS )c s g | ]} |¡qS r3 )Z _loose_call©rÚ Ú_rrB r3 r4 rÝ s ú)genfromtxt.<locals>.<listcomp>.<listcomp>©r r ©rÚ r¡ ©ÚrowsrB r4 rÝ s ÿc s, g | ]$\} fd dt t|D qS )c s g | ]} |¡qS r3 )Z _strict_callrJ rB r3 r4 rÝ s rL rM rN rO rB r4 rÝ s ÿc S s g | ]
|
}|j qS r3 ©rè ©rÚ r@ r3 r3 r4 rÝ s c S s g | ]\}}|t jkr|qS r3 )r Zunicode_)rÚ r¡ r r3 r3 r4 rÝ ! s
|
ÿzReading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.c s, t | } D ]}|| d¡||< q t|S r? )r; r rß )Zrow_tupr r¡ )Ú strcolidxr3 r4 Úencode_unicode_cols+ s z'genfromtxt.<locals>.encode_unicode_colsc s g | ] } |qS r3 r3 )rÚ Úr)rT r3 r4 rÝ 2 s c 3 s | ]}t | V qd S r- ©rh ©rÚ r rF r3 r4 Ú <genexpr>= s z genfromtxt.<locals>.<genexpr>c S s h | ]\}}|j r|qS r3 )Z_checked)rÚ r Zc_typer3 r3 r4 Ú <setcomp>B s þz genfromtxt.<locals>.<setcomp>c s g | ]\}} | |fqS r3 r3 ©rÚ r¡ ró ©r+ r3 r4 rÝ J s ÿc s g | ]\}} | t fqS r3 ©ÚboolrZ r[ r3 r4 rÝ M s ÿr ÚOc s s | ] }|j V qd S r- )Úcharr5 r3 r3 r4 rX _ s z4Nested fields involving objects are not supported...c S s g | ] }d |fqS r7 r3 r5 r3 r3 r4 rÝ f s c S s g | ] }d t fqS r7 r\ )rÚ Útr3 r3 r4 rÝ k s c S s g | ]
|
}|j qS r3 rQ rR r3 r3 r4 rÝ u s c 3 s | ]}t | V qd S r- rV rW rF r3 r4 rX z s c S s g | ] }|t fqS r3 r\ r5 r3 r3 r4 rÝ s c s g | ]}|d kr |qS r7 r3 r5 rB r3 r4 rÝ s ÿr¥ c s g | ] } | qS r3 r3 rÙ )r! r3 r4 rÝ ¦ s )PÚ_genfromtxt_with_liker§ ry Znumpy.mar1 r2 r½ rz r¹ rè r r rà r rä rå rk r{ rç r rf r r ÚrangeÚnextr r r¿ Ú StopIterationrë rì r4 r9 r; rh r r r r r6 r® rî ro r¾ r rß ÚextendrX rW r r Ú functoolsÚpartialÚupdateÚ itertoolsÚchainÚ
|
IndexErrorZ iterupgrader r r Úupgrader Úinsertr ZVisibleDeprecationWarningÚUnicodeEncodeErrorÚbytes_Z
|
issubdtypeÚ characterÚmaxr] r r ÚNotImplementedErrorÚviewr$ Z_maskr¬ rª )Sr£ r® r¯ r° r" r# r± r$ r% r³ rî r& r' r( r) r* r+ r´ r, r- r. rµ ru r¦ r r1 r2 Zuser_convertersrÓ rZ Zfid_ctxZfhdr Z
|
split_lineZvalidate_namesZ first_valuesÚ
|
first_lineZfvalZnbcolsÚcurrentZuser_missing_valuesr: r¢ r; rº ÚentryZ
|
user_valueZuser_filling_valuesÚnZ
|
dtype_flatZzipitZ uc_updaterÇ rC Z user_convrA Zappend_to_rowsÚmasksZappend_to_masksÚinvalidZappend_to_invalidrÁ ZnbvaluesÚ converterZcurrent_columnÚerrmsgZ nbinvalidZnbinvalid_skippedrð Z column_typesZsized_column_typesZcol_typeZn_charsÚbaseZ uniform_typeZddtypeZmdtypeZ
|
outputmaskZrowmasksZ ishomogeneousÚttyper» Zmvalr3 )r@ r+ r6 r® rT r¡ rî rG r! rP r" rS rI r r4 r" Ê s0 D õÿ
|
ÿÿ
|
|
|
ÿý ÿý
|
ÿ
|
|
|
|
|
|
|
ü
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ÿ þ
|
|
þ
|
|
|
|
|
ý
|
|
|
|
ÿÿ
|
|
|
|
|
ÿ
|
|
|
|
ÿÿ ÿÿ
|
ü
|
þ
|
ÿ
|
ÿ
|
ÿ
|
ÿ
|
|
|
|
c K sP | dd¡ | dd¡}t| f|}|r@ddlm} | |¡}n | tj¡}|S )aý
|
Load ASCII data from a file and return it in a record array.
|
|
If ``usemask=False`` a standard `recarray` is returned,
|
if ``usemask=True`` a MaskedRecords array is returned.
|
|
Parameters
|
----------
|
fname, kwargs : For a description of input parameters, see `genfromtxt`.
|
|
See Also
|
--------
|
numpy.genfromtxt : generic function
|
|
Notes
|
-----
|
By default, `dtype` is None, which means that the data-type of the output
|
array will be determined from the data.
|
|
r® Nr, Fr ©Ú MaskedRecords)Ú
|
setdefaultÚgetr" Únumpy.ma.mrecordsr rs r Úrecarray)r£ rJ r, r! r r3 r3 r4 r# ¯ s c K st | dd¡ | dd¡ | dd¡ | dd¡ t| f|}| d d
|
¡}|rdd d lm} | |¡}n | tj¡}|S ) a8
|
Load ASCII data stored in a comma-separated file.
|
|
The returned array is a record array (if ``usemask=False``, see
|
`recarray`) or a masked record array (if ``usemask=True``,
|
see `ma.mrecords.MaskedRecords`).
|
|
Parameters
|
----------
|
fname, kwargs : For a description of input parameters, see `genfromtxt`.
|
|
See Also
|
--------
|
numpy.genfromtxt : generic function to load ASCII data.
|
|
Notes
|
-----
|
By default, `dtype` is None, which means that the data-type of the output
|
array will be determined from the data.
|
|
r* Úlowerrî Tr° rÄ r® Nr, Fr r~ )r r" r r r rs r r )r£ rJ r! r, r r3 r3 r4 r$ Ï s )NFTrs )NN)TT)TN)
|
NNNNNNNNNN)r· )NNNNNNN)rþ rÿ r rÌ rÌ r N)N)NNNNNNNNNNNNNNNNNNNNNN)Wrá r rf ri rë r. r{ r¸ r r Zopindexr Úcollections.abcr r* r rÌ r rå r Z
|
numpy.corer Znumpy.core.multiarrayr
|
r Z numpy.core._multiarray_umathr Znumpy.core.overridesr r Z_iotoolsr r r r r r r r r r r Z numpy.compatr r r r r r Ú__all__rg Zarray_function_dispatchr, rK rL rr r% r r& r r' r r( r r§ Úintr¬ ré r¶ r¼ rà r÷ rô Úfloatr! rö rý r r) r/ r ÚsortedZdefaultdeletecharsr" ra r# r$ r3 r3 r3 r4 Ú<module> sz 4 ý ÿ1 ÿÿ 8
|
J
|
V
|
A
|
%
|
ýý
|
ý þý ÿþ þ
|
ÿ x g ú ù ù ø c ÿþ
|
