from __future__ import division, absolute_import, print_function

import io

import sys

import os

import re

import itertools

import warnings

import weakref

from operator import itemgetter, index as opindex

import numpy as np

from . import format

from ._datasource import DataSource

from numpy.core.multiarray import packbits, unpackbits

from ._iotools import (

    LineSplitter, NameValidator, StringConverter, ConverterError,

    ConverterLockError, ConversionWarning, _is_string_like,

    has_nested_fields, flatten_dtype, easy_dtype, _decode_line

    )

from numpy.compat import (

    asbytes, asstr, asunicode, asbytes_nested, bytes, basestring, unicode,

    is_pathlib_path

    )

if sys.version_info[0] >= 3:

    import pickle

else:

    import cPickle as pickle

    from future_builtins import map

loads = pickle.loads

__all__ = [

    'savetxt', 'loadtxt', 'genfromtxt', 'ndfromtxt', 'mafromtxt',

    'recfromtxt', 'recfromcsv', 'load', 'loads', 'save', 'savez',

    'savez_compressed', 'packbits', 'unpackbits', 'fromregex', 'DataSource'

    ]

class BagObj(object):

    """

    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(object):

    ...     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"

    """

    def __init__(self, obj):

        # Use weakref to make NpzFile objects collectable by refcount

        self._obj = weakref.proxy(obj)

    def __getattribute__(self, key):

        try:

            return object.__getattribute__(self, '_obj')[key]

        except KeyError:

            raise AttributeError(key)

    def __dir__(self):

        """

        Enables dir(bagobj) to list the files in an NpzFile.

        This also enables tab-completion in an interpreter or IPython.

        """

        return object.__getattribute__(self, '_obj').keys()

def zipfile_factory(file, *args, **kwargs):

    """

    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.

    """

    if is_pathlib_path(file):

        file = str(file)

    import zipfile

    kwargs['allowZip64'] = True

    return zipfile.ZipFile(file, *args, **kwargs)

class NpzFile(object):

    """

    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.14.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.

    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.io.NpzFile)

    True

    >>> npz.files

    ['y', 'x']

    >>> 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])

    """

    def __init__(self, fid, own_fid=False, allow_pickle=False,

                 pickle_kwargs=None):

        # Import is postponed to here since zipfile depends on gzip, an

        # optional component of the so-called standard library.

        _zip = zipfile_factory(fid)

        self._files = _zip.namelist()

        self.files = []

        self.allow_pickle = allow_pickle

        self.pickle_kwargs = pickle_kwargs

        for x in self._files:

            if x.endswith('.npy'):

                self.files.append(x[:-4])

            else:

                self.files.append(x)

        self.zip = _zip

        self.f = BagObj(self)

        if own_fid:

            self.fid = fid

        else:

            self.fid = None

    def __enter__(self):

        return self

    def __exit__(self, exc_type, exc_value, traceback):

        self.close()

    def close(self):

        """

        Close the file.

        """

        if self.zip is not None:

            self.zip.close()

            self.zip = None

        if self.fid is not None:

            self.fid.close()

            self.fid = None

        self.f = None  # break reference cycle

    def __del__(self):

        self.close()

    def __getitem__(self, key):

        # FIXME: This seems like it will copy strings around

        #   more than is strictly necessary.  The zipfile

        #   will read the string and then

        #   the format.read_array will copy the string

        #   to another place in memory.

        #   It would be better if the zipfile could read

        #   (or at least uncompress) the data

        #   directly into the array memory.

        member = 0

        if key in self._files:

            member = 1

        elif key in self.files:

            member = 1

            key += '.npy'

        if member:

            bytes = self.zip.open(key)

            magic = bytes.read(len(format.MAGIC_PREFIX))

            bytes.close()

            if magic == format.MAGIC_PREFIX:

                bytes = self.zip.open(key)

                return format.read_array(bytes,

                                         allow_pickle=self.allow_pickle,

                                         pickle_kwargs=self.pickle_kwargs)

            else:

                return self.zip.read(key)

        else:

            raise KeyError("%s is not a file in the archive" % key)

    def __iter__(self):

        return iter(self.files)

    def items(self):

        """

        Return a list of tuples, with each tuple (filename, array in file).

        """

        return [(f, self[f]) for f in self.files]

    def iteritems(self):

        """Generator that returns tuples (filename, array in file)."""

        for f in self.files:

            yield (f, self[f])

    def keys(self):

        """Return files in the archive with a ``.npy`` extension."""

        return self.files

    def iterkeys(self):

        """Return an iterator over the files in the archive."""

        return self.__iter__()

    def __contains__(self, key):

        return self.files.__contains__(key)

def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,

         encoding='ASCII'):

    """

    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.

    Parameters

    ----------

    file : file-like object, string, or pathlib.Path

        The file to read. File-like objects must support the

        ``seek()`` and ``read()`` methods. 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.14.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'

    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

    ------

    IOError

        If the input file does not exist or cannot be read.

    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])

    """

    own_fid = False

    if isinstance(file, basestring):

        fid = open(file, "rb")

        own_fid = True

    elif is_pathlib_path(file):

        fid = file.open("rb")

        own_fid = True

    else:

        fid = file

    if encoding not in ('ASCII', 'latin1', 'bytes'):

        # The 'encoding' value for pickle also affects what encoding

        # the serialized binary data of NumPy arrays is loaded

        # in. Pickle does not pass on the encoding information to

        # NumPy. The unpickling code in numpy.core.multiarray is

        # written to assume that unicode data appearing where binary

        # should be is in 'latin1'. 'bytes' is also safe, as is 'ASCII'.

        #

        # Other encoding values can corrupt binary data, and we

        # purposefully disallow them. For the same reason, the errors=

        # argument is not exposed, as values other than 'strict'

        # result can similarly silently corrupt numerical data.

        raise ValueError("encoding must be 'ASCII', 'latin1', or 'bytes'")

    if sys.version_info[0] >= 3:

        pickle_kwargs = dict(encoding=encoding, fix_imports=fix_imports)

    else:

        # Nothing to do on Python 2

        pickle_kwargs = {}

    try:

        # Code to distinguish from NumPy binary files and pickles.

        _ZIP_PREFIX = b'PK\x03\x04'

        N = len(format.MAGIC_PREFIX)

        magic = fid.read(N)

        # If the file size is less than N, we need to make sure not

        # to seek past the beginning of the file

        fid.seek(-min(N, len(magic)), 1)  # back-up

        if magic.startswith(_ZIP_PREFIX):

            # zip-file (assume .npz)

            # Transfer file ownership to NpzFile

            tmp = own_fid

            own_fid = False

            return NpzFile(fid, own_fid=tmp, allow_pickle=allow_pickle,

                           pickle_kwargs=pickle_kwargs)

        elif magic == format.MAGIC_PREFIX:

            # .npy file

            if mmap_mode:

                return format.open_memmap(file, mode=mmap_mode)

            else:

                return format.read_array(fid, allow_pickle=allow_pickle,

                                         pickle_kwargs=pickle_kwargs)

        else:

            # Try a pickle

            if not allow_pickle:

                raise ValueError("allow_pickle=False, but file does not contain "

                                 "non-pickled data")

            try:

                return pickle.load(fid, **pickle_kwargs)

            except Exception:

                raise IOError(

                    "Failed to interpret file %s as a pickle" % repr(file))

    finally:

        if own_fid:

            fid.close()

def save(file, arr, allow_pickle=True, fix_imports=True):

    """

    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 file name 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 the module docstring

    of `numpy.lib.format` or the NumPy Enhancement Proposal

    http://docs.scipy.org/doc/numpy/neps/npy-format.html

    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])

    """

    own_fid = False

    if isinstance(file, basestring):

        if not file.endswith('.npy'):

            file = file + '.npy'

        fid = open(file, "wb")

        own_fid = True

    elif is_pathlib_path(file):

        if not file.name.endswith('.npy'):

            file = file.parent / (file.name + '.npy')

        fid = file.open("wb")

        own_fid = True

    else:

        fid = file

    if sys.version_info[0] >= 3:

        pickle_kwargs = dict(fix_imports=fix_imports)

    else:

        # Nothing to do on Python 2

        pickle_kwargs = None

    try:

        arr = np.asanyarray(arr)

        format.write_array(fid, arr, allow_pickle=allow_pickle,

                           pickle_kwargs=pickle_kwargs)

    finally:

        if own_fid:

            fid.close()

def savez(file, *args, **kwds):

    """

    Save several arrays into a single file in uncompressed ``.npz`` format.

    If arguments are passed in with no keywords, the corresponding variable

    names, in the ``.npz`` file, are 'arr_0', 'arr_1', etc. If keyword

    arguments are given, the corresponding variable names, in the ``.npz``

    file will match the keyword names.

    Parameters

    ----------

    file : str or file

        Either the file name (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 file name if it is not

        already there.

    args : Arguments, optional

        Arrays to save to the file. Since it is not possible for Python to

        know the names of the arrays outside `savez`, the arrays will be saved

        with names "arr_0", "arr_1", and so on. These arguments can be any

        expression.

    kwds : Keyword arguments, optional

        Arrays to save to the file. Arrays will be saved in the file with the

        keyword names.

    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 `numpy.lib.format` or the

    NumPy Enhancement Proposal

    http://docs.scipy.org/doc/numpy/neps/npy-format.html

    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

    --------

    >>> 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_1', 'arr_0']

    >>> 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)

    >>> npzfile.files

    ['y', 'x']

    >>> npzfile['x']

    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    """

    _savez(file, args, kwds, False)

def savez_compressed(file, *args, **kwds):

    """

    Save several arrays into a single file in compressed ``.npz`` format.

    If keyword arguments are given, then filenames are taken from the keywords.

    If arguments are passed in with no keywords, then stored file names are

    arr_0, arr_1, etc.

    Parameters

    ----------

    file : str or file

        Either the file name (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 file name if it is not

        already there.

    args : Arguments, optional

        Arrays to save to the file. Since it is not possible for Python to

        know the names of the arrays outside `savez`, the arrays will be saved

        with names "arr_0", "arr_1", and so on. These arguments can be any

        expression.

    kwds : Keyword arguments, optional

        Arrays to save to the file. Arrays will be saved in the file with the

        keyword names.

    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

    `numpy.lib.format` or the NumPy Enhancement Proposal

    http://docs.scipy.org/doc/numpy/neps/npy-format.html

    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

    """

    _savez(file, args, kwds, True)

def _savez(file, args, kwds, compress, allow_pickle=True, pickle_kwargs=None):

    # Import is postponed to here since zipfile depends on gzip, an optional

    # component of the so-called standard library.

    import zipfile

    if isinstance(file, basestring):

        if not file.endswith('.npz'):

            file = file + '.npz'

    elif is_pathlib_path(file):

        if not file.name.endswith('.npz'):

            file = file.parent / (file.name + '.npz')

    namedict = kwds

    for i, val in enumerate(args):

        key = 'arr_%d' % i

        if key in namedict.keys():

            raise ValueError(

                "Cannot use un-named variables and keyword %s" % key)

        namedict[key] = val

    if compress:

        compression = zipfile.ZIP_DEFLATED

    else:

        compression = zipfile.ZIP_STORED

    zipf = zipfile_factory(file, mode="w", compression=compression)

    if sys.version_info >= (3, 6):

        # Since Python 3.6 it is possible to write directly to a ZIP file.

        for key, val in namedict.items():

            fname = key + '.npy'

            val = np.asanyarray(val)

            force_zip64 = val.nbytes >= 2**30

            with zipf.open(fname, 'w', force_zip64=force_zip64) as fid:

                format.write_array(fid, val,

                                   allow_pickle=allow_pickle,

                                   pickle_kwargs=pickle_kwargs)

    else:

        # Stage arrays in a temporary file on disk, before writing to zip.

        # Import deferred for startup time improvement

        import tempfile

        # Since target file might be big enough to exceed capacity of a global

        # temporary directory, create temp file side-by-side with the target file.

        file_dir, file_prefix = os.path.split(file) if _is_string_like(file) else (None, 'tmp')

        fd, tmpfile = tempfile.mkstemp(prefix=file_prefix, dir=file_dir, suffix='-numpy.npy')

        os.close(fd)

        try:

            for key, val in namedict.items():

                fname = key + '.npy'

                fid = open(tmpfile, 'wb')

                try:

                    format.write_array(fid, np.asanyarray(val),

                                       allow_pickle=allow_pickle,

                                       pickle_kwargs=pickle_kwargs)

                    fid.close()

                    fid = None

                    zipf.write(tmpfile, arcname=fname)

                except IOError as exc:

                    raise IOError("Failed to write to %s: %s" % (tmpfile, exc))

                finally:

                    if fid:

                        fid.close()

        finally:

            os.remove(tmpfile)

    zipf.close()

def _getconv(dtype):

    """ Find the correct dtype converter. Adapted from matplotlib """

    def floatconv(x):

        x.lower()

        if '0x' in x:

            return float.fromhex(x)

        return float(x)

    typ = dtype.type

    if issubclass(typ, np.bool_):

        return lambda x: bool(int(x))

    if issubclass(typ, np.uint64):

        return np.uint64

    if issubclass(typ, np.int64):

        return np.int64

    if issubclass(typ, np.integer):

        return lambda x: int(float(x))

    elif issubclass(typ, np.longdouble):

        return np.longdouble

    elif issubclass(typ, np.floating):

        return floatconv

    elif issubclass(typ, complex):

        return lambda x: complex(asstr(x))

    elif issubclass(typ, np.bytes_):

        return asbytes

    elif issubclass(typ, np.unicode_):

        return asunicode

    else:

        return asstr

# amount of lines loadtxt reads in one chunk, can be overriden for testing

_loadtxt_chunksize = 50000

def loadtxt(fname, dtype=float, comments='#', delimiter=None,

            converters=None, skiprows=0, usecols=None, unpack=False,

            ndmin=0, encoding='bytes'):

    """

    Load data from a text file.

    Each row in the text file must have the same number of values.

    Parameters

    ----------

    fname : file, str, or pathlib.Path

        File, filename, or generator to read.  If the filename extension is

        ``.gz`` or ``.bz2``, the file is first decompressed. Note that

        generators should return byte strings for Python 3k.

    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, optional

        The characters or list of characters used to indicate the start of a

        comment. For backwards compatibility, byte strings will be decoded as

        'latin1'. The default is '#'.

    delimiter : str, optional

        The string used to separate values. For backwards compatibility, byte

        strings will be decoded as 'latin1'. The default is whitespace.

    converters : dict, optional

        A dictionary mapping column number to a function that will convert

        that column to a float.  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 (but see also `genfromtxt`):

        ``converters = {3: lambda s: float(s.strip() or 0)}``.  Default: None.

    skiprows : int, optional

        Skip the first `skiprows` lines; 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

    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.

    .. 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([('M', 21, 72.0), ('F', 35, 58.0)],

          dtype=[('gender', '|S1'), ('age', '

    >>> 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.])

    """

    # Type conversions for Py3 convenience