Undocumented
Class |
|
BagObj(obj) |
Class |
|
DataSource(destpath='.') |
Class |
|
NpzFile(fid) |
Function | fromregex |
Construct an array from a text file, using regular expression parsing. |
Function | genfromtxt |
Load data from a text file, with missing values handled as specified. |
Function | load |
Load arrays or pickled objects from .npy, .npz or pickled files. |
Function | loadtxt |
Load data from a text file. |
Function | recfromcsv |
Load ASCII data stored in a comma-separated file. |
Function | recfromtxt |
Load ASCII data from a file and return it in a record array. |
Function | save |
Save an array to a binary file in NumPy .npy format. |
Function | savetxt |
Save an array to a text file. |
Function | savez |
Save several arrays into a single file in uncompressed .npz format. |
Function | savez |
Save several arrays into a single file in compressed .npz format. |
Function | zipfile |
Create a ZipFile. |
Variable | array |
Undocumented |
Function | _check |
Undocumented |
Function | _ensure |
This is a helper function of loadtxt and genfromtxt to ensure proper minimum dimension as requested |
Function | _ensure |
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 |
Function | _genfromtxt |
Undocumented |
Function | _loadtxt |
Undocumented |
Function | _preprocess |
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). |
Function | _read |
Read a NumPy array from a text file. |
Function | _save |
Undocumented |
Function | _savetxt |
Undocumented |
Function | _savez |
Undocumented |
Function | _savez |
Undocumented |
Function | _savez |
Undocumented |
Variable | _genfromtxt |
Undocumented |
Variable | _loadtxt |
Undocumented |
Variable | _loadtxt |
Undocumented |
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.
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])
Parameters | |
file:path or file | Filename or file object to read.
Changed in version 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.
New in version 1.14.0.
|
Returns | |
ndarray | output - 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. |
@set_module(
def genfromtxt(fname, dtype=float, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars="""""".join(
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.
:param : .. versionadded:: 1.20.0
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. |
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')])
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. |
skipint , optional | The number of lines to skip at the beginning of the file. |
skipint , 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)}. |
missingvariable , optional | The set of strings corresponding to missing data. |
fillingvariable , 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. |
replacechar , optional | Character(s) used in replacement of white spaces in the variable names. By default, use a '_'. |
autostrip:bool , optional | Whether to automatically strip white spaces from the variables. |
caseFalse , '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. |
defaultfmt:str , optional | A format used to define default field names, such as "f%i" or "f_%02i". |
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. |
invalidbool , 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. |
maxint , 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.
New in version 1.10.0.
|
encoding:str , optional | Encoding used to decode the inputfile. Does not apply when
New in version 1.14.0.
|
ndmin:int , optional | Same parameter as
New in version 1.23.0.
|
like | Undocumented |
skiprows:int , optional | skiprows was removed in numpy 1.10. Please use skip_header instead. |
missing:variable , optional | missing was removed in numpy 1.10. Please use missing_values
instead. |
${ARRAY | |
Returns | |
ndarray | out - Data read from the text file. If usemask is True, this is a
masked array. |
def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=format._MAX_HEADER_SIZE): (source) ¶
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.
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])
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 | 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. |
allowbool , 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
Changed in version 1.16.3: Made default False in response to CVE-2019-6446.
|
fixbool , 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' |
maxint , 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 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 | |
array , tuple , dict , etc. | result - 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. |
@set_module(
def loadtxt(fname, dtype=float, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None, *, quotechar=None, like=None): (source) ¶
Load data from a text file.
:param : .. versionadded:: 1.20.0
See Also
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
.
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.]])
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.
Changed in version 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
Changed in version 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.
Changed in version 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
New in version 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'.
New in version 1.14.0.
|
maxint , optional | Read
New in version 1.16.0.
Changed in version 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
New in version 1.23.0.
|
like | Undocumented |
${ARRAY | |
Returns | |
ndarray | out - Data read from the text file. |
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
).
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.
Parameters | |
fname:For a description of input parameters, seegenfromtxt . | |
**kwargs:For a description of input parameters, seegenfromtxt . |
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.
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.
Parameters | |
fname:For a description of input parameters, seegenfromtxt . | |
**kwargs:For a description of input parameters, seegenfromtxt . |
def save(file, arr, allow_pickle=True, fix_imports=True): (source) ¶
Save an array to a binary file in NumPy .npy format.
Notes
For a description of the .npy format, see 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]
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. |
allowbool , 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 |
fixbool , 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. |
def savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None): (source) ¶
Save an array to a text file.
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, 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
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:str , optional | String or character separating columns. |
newline:str , optional | String or character separating lines.
New in version 1.5.0.
|
header:str , optional | String that will be written at the beginning of the file.
New in version 1.7.0.
|
footer:str , optional | String that will be written at the end of the file.
New in version 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.
New in version 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'.
New in version 1.14.0.
|
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.
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 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])
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 | Undocumented |
def savez_compressed(file, *args, **kwds): (source) ¶
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.
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
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
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 | Undocumented |
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.
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
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
Undocumented
Undocumented
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).
Read a NumPy array from a text file.
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')])
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. |
imaginarystr , 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. |
maxint , 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. |
Undocumented