help(numpy)
Help on package numpy:
NAME
numpy
FILE
c:\anaconda2\lib\site-packages\numpy\__init__.py
DESCRIPTION
NumPy
=====
Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation
How to use the documentation
----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <http://www.scipy.org>`_.
We recommend exploring the docstrings using
`IPython <http://ipython.scipy.org>`_, an advanced Python shell with
TAB-completion and introspection capabilities. See below for further
instructions.
The docstring examples assume that `numpy` has been imported as `np`::
import numpy as np
Code snippets are indicated by three greater-than signs::
x = 42
x = x + 1
Use the built-in ``help`` function to view a function's docstring::
help(np.sort)
# doctest: +SKIP
For some objects, ``np.info(obj)`` may provide additional help. This is
particularly true if you see the line "Help on ufunc object:" at the top
of the help() page. Ufuncs are implemented in C, not Python, for speed.
The native Python help() does not know how to view their help, but our
np.info() function does.
To search for documents containing a keyword, do::
np.lookfor('keyword')
# doctest: +SKIP
General-purpose documents like a glossary and help on the basic concepts
of numpy are available under the ``doc`` sub-module::
from numpy import doc
help(doc)
# doctest: +SKIP
Available subpackages
---------------------
doc
Topical documentation on broadcasting, indexing, etc.
lib
Basic functions used by several sub-packages.
random
Core Random Tools
linalg
Core Linear Algebra Tools
fft
Core FFT routines
polynomial
Polynomial tools
testing
Numpy testing tools
f2py
Fortran to Python Interface Generator.
distutils
Enhancements to distutils with support for
Fortran compilers support and more.
Utilities
---------
test
Run numpy unittests
show_config
Show numpy build configuration
dual
Overwrite certain functions with high-performance Scipy tools
matlib
Make everything matrices.
__version__
Numpy version string
Viewing documentation using IPython
-----------------------------------
Start IPython with the NumPy profile (``ipython -p numpy``), which will
import `numpy` under the alias `np`. Then, use the ``cpaste`` command to
paste examples into the shell. To see which functions are available in
`numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
down the list. To view the docstring for a function, use
``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
the source code).
Copies vs. in-place operation
-----------------------------
Most of the functions in `numpy` return a copy of the array argument
(e.g., `np.sort`). In-place versions of these functions are often
available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
Exceptions to this rule are documented.
PACKAGE CONTENTS
__config__
_import_tools
add_newdocs
compat (package)
core (package)
ctypeslib
distutils (package)
doc (package)
dual
f2py (package)
fft (package)
lib (package)
linalg (package)
ma (package)
matlib
matrixlib (package)
polynomial (package)
random (package)
setup
testing (package)
version
SUBMODULES
_mat
char
emath
rec
CLASSES
__builtin__.object
broadcast
busdaycalendar
dtype
flatiter
generic
bool_
datetime64
flexible
character
string_(__builtin__.str, character)
unicode_(__builtin__.unicode, character)
void
record
number
inexact
complexfloating
complex128(complexfloating, __builtin__.complex)
complex128
complex64
floating
float16
float32
float64(floating, __builtin__.float)
float64
integer
signedinteger
int16
int32(signedinteger, __builtin__.int)
int32(signedinteger, __builtin__.int)
int64
int8
timedelta64
unsignedinteger
uint16
uint32
uint32
uint64
uint8
object_
ndarray
recarray
numpy.core.defchararray.chararray
numpy.core.memmap.memmap
numpy.matrixlib.defmatrix.matrix
nditer
ufunc
numpy._import_tools.PackageLoader
numpy.core.getlimits.finfo
numpy.core.getlimits.iinfo
numpy.core.machar.MachAr
numpy.core.numeric.errstate
numpy.lib._datasource.DataSource
numpy.lib.function_base.vectorize
numpy.lib.index_tricks.ndenumerate
numpy.lib.index_tricks.ndindex
numpy.lib.polynomial.poly1d
__builtin__.str(__builtin__.basestring)
string_(__builtin__.str, character)
__builtin__.unicode(__builtin__.basestring)
unicode_(__builtin__.unicode, character)
exceptions.DeprecationWarning(exceptions.Warning)
ModuleDeprecationWarning
exceptions.RuntimeWarning(exceptions.Warning)
numpy.core.numeric.ComplexWarning
exceptions.UserWarning(exceptions.Warning)
VisibleDeprecationWarning
numpy.lib.polynomial.RankWarning
numpy.core.records.format_parser
class ComplexWarning(exceptions.RuntimeWarning)
| The warning raised when casting a complex dtype to a real dtype.
|
| As implemented, casting a complex number to a real discards its imaginary
| part, but this behavior may not be what the user actually wants.
|
| Method resolution order:
| ComplexWarning
| exceptions.RuntimeWarning
| exceptions.Warning
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.RuntimeWarning:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.RuntimeWarning:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class DataSource(__builtin__.object)
| DataSource(destpath='.')
|
| A generic data source file (file, http, ftp, ...).
|
| DataSources can be local files or remote files/URLs. The files may
| also be compressed or uncompressed. DataSource hides some of the
| low-level details of downloading the file, allowing you to simply pass
| in a valid file path (or URL) and obtain a file object.
|
| Parameters
| ----------
| destpath : str or None, optional
| Path to the directory where the source file gets downloaded to for
| use. If `destpath` is None, a temporary directory will be created.
| The default path is the current directory.
|
| Notes
| -----
| URLs require a scheme string (``http://``) to be used, without it they
| will fail::
|
| >>> repos = DataSource()
| >>> repos.exists('www.google.com/index.html')
| False
| >>> repos.exists('http://www.google.com/index.html')
| True
|
| Temporary directories are deleted when the DataSource is deleted.
|
| Examples
| --------
| ::
|
| >>> ds = DataSource('/home/guido')
| >>> urlname = 'http://www.google.com/index.html'
| >>> gfile = ds.open('http://www.google.com/index.html') # remote file
| >>> ds.abspath(urlname)
| '/home/guido/www.google.com/site/index.html'
|
| >>> ds = DataSource(None) # use with temporary file
| >>> ds.open('/home/guido/foobar.txt')
| <open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
| >>> ds.abspath('/home/guido/foobar.txt')
| '/tmp/tmpy4pgsP/home/guido/foobar.txt'
|
| Methods defined here:
|
| __del__(self)
|
| __init__(self, destpath='.')
| Create a DataSource with a local path at destpath.
|
| abspath(self, path)
| Return absolute path of file in the DataSource directory.
|
| If `path` is an URL, then `abspath` will return either the location
| the file exists locally or the location it would exist when opened
| using the `open` method.
|
| Parameters
| ----------
| path : str
| Can be a local file or a remote URL.
|
| Returns
| -------
| out : str
| Complete path, including the `DataSource` destination directory.
|
| Notes
| -----
| The functionality is based on `os.path.abspath`.
|
| exists(self, path)
| Test if path exists.
|
| Test if `path` exists as (and in this order):
|
| - a local file.
| - a remote URL that has been downloaded and stored locally in the
| `DataSource` directory.
| - a remote URL that has not been downloaded, but is valid and
| accessible.
|
| Parameters
| ----------
| path : str
| Can be a local file or a remote URL.
|
| Returns
| -------
| out : bool
| True if `path` exists.
|
| Notes
| -----
| When `path` is an URL, `exists` will return True if it's either
| stored locally in the `DataSource` directory, or is a valid remote
| URL. `DataSource` does not discriminate between the two, the file
| is accessible if it exists in either location.
|
| open(self, path, mode='r')
| Open and return file-like object.
|
| If `path` is an URL, it will be downloaded, stored in the
| `DataSource` directory and opened from there.
|
| Parameters
| ----------
| path : str
| Local file path or URL to open.
| mode : {'r', 'w', 'a'}, optional
| Mode to open `path`. Mode 'r' for reading, 'w' for writing,
| 'a' to append. Available modes depend on the type of object
| specified by `path`. Default is 'r'.
|
| Returns
| -------
| out : file object
| File object.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class MachAr(__builtin__.object)
| Diagnosing machine parameters.
|
| Attributes
| ----------
| ibeta : int
| Radix in which numbers are represented.
| it : int
| Number of base-`ibeta` digits in the floating point mantissa M.
| machep : int
| Exponent of the smallest (most negative) power of `ibeta` that,
| added to 1.0, gives something different from 1.0
| eps : float
| Floating-point number ``beta**machep`` (floating point precision)
| negep : int
| Exponent of the smallest power of `ibeta` that, substracted
| from 1.0, gives something different from 1.0.
| epsneg : float
| Floating-point number ``beta**negep``.
| iexp : int
| Number of bits in the exponent (including its sign and bias).
| minexp : int
| Smallest (most negative) power of `ibeta` consistent with there
| being no leading zeros in the mantissa.
| xmin : float
| Floating point number ``beta**minexp`` (the smallest [in
| magnitude] usable floating value).
| maxexp : int
| Smallest (positive) power of `ibeta` that causes overflow.
| xmax : float
| ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
| usable floating value).
| irnd : int
| In ``range(6)``, information on what kind of rounding is done
| in addition, and on how underflow is handled.
| ngrd : int
| Number of 'guard digits' used when truncating the product
| of two mantissas to fit the representation.
| epsilon : float
| Same as `eps`.
| tiny : float
| Same as `xmin`.
| huge : float
| Same as `xmax`.
| precision : float
| ``- int(-log10(eps))``
| resolution : float
| ``- 10**(-precision)``
|
| Parameters
| ----------
| float_conv : function, optional
| Function that converts an integer or integer array to a float
| or float array. Default is `float`.
| int_conv : function, optional
| Function that converts a float or float array to an integer or
| integer array. Default is `int`.
| float_to_float : function, optional
| Function that converts a float array to float. Default is `float`.
| Note that this does not seem to do anything useful in the current
| implementation.
| float_to_str : function, optional
| Function that converts a single float to a string. Default is
| ``lambda v:'%24.16e' %v``.
| title : str, optional
| Title that is printed in the string representation of `MachAr`.
|
| See Also
| --------
| finfo : Machine limits for floating point types.
| iinfo : Machine limits for integer types.
|
| References
| ----------
| .. [1] Press, Teukolsky, Vetterling and Flannery,
| "Numerical Recipes in C++," 2nd ed,
| Cambridge University Press, 2002, p. 31.
|
| Methods defined here:
|
| __init__(self, float_conv=<type 'float'>, int_conv=<type 'int'>, float_to_float=<type 'float'>, float_to_str=<function <lambda>>, title='Python floating point number')
| float_conv - convert integer to float (array)
| int_conv - convert float (array) to integer
| float_to_float - convert float array to float
| float_to_str - convert array float to str
| title - description of used floating point numbers
|
| __str__(self)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class ModuleDeprecationWarning(exceptions.DeprecationWarning)
| Module deprecation warning.
|
| The nose tester turns ordinary Deprecation warnings into test failures.
| That makes it hard to deprecate whole modules, because they get
| imported by default. So this is a special Deprecation warning that the
| nose tester will let pass without making tests fail.
|
| Method resolution order:
| ModuleDeprecationWarning
| exceptions.DeprecationWarning
| exceptions.Warning
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.DeprecationWarning:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.DeprecationWarning:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class PackageLoader(__builtin__.object)
| Methods defined here:
|
| __call__(self, *packages, **options)
| Load one or more packages into parent package top-level namespace.
|
| This function is intended to shorten the need to import many
| subpackages, say of scipy, constantly with statements such as
|
| import scipy.linalg, scipy.fftpack, scipy.etc...
|
| Instead, you can say:
|
| import scipy
| scipy.pkgload('linalg','fftpack',...)
|
| or
|
| scipy.pkgload()
|
| to load all of them in one call.
|
| If a name which doesn't exist in scipy's namespace is
| given, a warning is shown.
|
| Parameters
| ----------
| *packages : arg-tuple
| the names (one or more strings) of all the modules one
| wishes to load into the top-level namespace.
| verbose= : integer
| verbosity level [default: -1].
| verbose=-1 will suspend also warnings.
| force= : bool
| when True, force reloading loaded packages [default: False].
| postpone= : bool
| when True, don't load packages [default: False]
|
| __init__(self, verbose=False, infunc=False)
| Manages loading packages.
|
| error(self, mess)
|
| get_pkgdocs(self)
| Return documentation summary of subpackages.
|
| log(self, mess)
|
| warn(self, mess)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class RankWarning(exceptions.UserWarning)
| Issued by `polyfit` when the Vandermonde matrix is rank deficient.
|
| For more information, a way to suppress the warning, and an example of
| `RankWarning` being issued, see `polyfit`.
|
| Method resolution order:
| RankWarning
| exceptions.UserWarning
| exceptions.Warning
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.UserWarning:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.UserWarning:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class VisibleDeprecationWarning(exceptions.UserWarning)
| Visible deprecation warning.
|
| By default, python will not show deprecation warnings, so this class
| can be used when a very visible warning is helpful, for example because
| the usage is most likely a user bug.
|
| Method resolution order:
| VisibleDeprecationWarning
| exceptions.UserWarning
| exceptions.Warning
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.UserWarning:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.UserWarning:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
bool8 = class bool_(generic)
| Numpy's Boolean type. Character code: ``?``. Alias: bool8
|
| Method resolution order:
| bool_
| generic
| __builtin__.object
|
| Methods defined here:
|
| __and__(...)
| x.__and__(y) <==> x&y
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __hash__(...)
| x.__hash__() <==> hash(x)
|
| __index__(...)
| x[y:z] <==> x[y.__index__():z.__index__()]
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __nonzero__(...)
| x.__nonzero__() <==> x != 0
|
| __or__(...)
| x.__or__(y) <==> x|y
|
| __rand__(...)
| x.__rand__(y) <==> y&x
|
| __ror__(...)
| x.__ror__(y) <==> y|x
|
| __rxor__(...)
| x.__rxor__(y) <==> y^x
|
| __xor__(...)
| x.__xor__(y) <==> x^y
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from generic:
|
| __abs__(...)
| x.__abs__() <==> abs(x)
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __array__(...)
| sc.__array__(|type) return 0-dim array
|
| __array_wrap__(...)
| sc.__array_wrap__(obj) return scalar from array
|
| __copy__(...)
|
| __deepcopy__(...)
|
| __div__(...)
| x.__div__(y) <==> x/y
|
| __divmod__(...)
| x.__divmod__(y) <==> divmod(x, y)
|
| __float__(...)
| x.__float__() <==> float(x)
|
| __floordiv__(...)
| x.__floordiv__(y) <==> x//y
|
| __format__(...)
| NumPy array scalar formatter
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __hex__(...)
| x.__hex__() <==> hex(x)
|
| __int__(...)
| x.__int__() <==> int(x)
|
| __invert__(...)
| x.__invert__() <==> ~x
|
| __long__(...)
| x.__long__() <==> long(x)
|
| __lshift__(...)
| x.__lshift__(y) <==> x<<y
|
| __mod__(...)
| x.__mod__(y) <==> x%y
|
| __mul__(...)
| x.__mul__(y) <==> x*y
|
| __neg__(...)
| x.__neg__() <==> -x
|
| __oct__(...)
| x.__oct__() <==> oct(x)
|
| __pos__(...)
| x.__pos__() <==> +x
|
| __pow__(...)
| x.__pow__(y[, z]) <==> pow(x, y[, z])
|
| __radd__(...)
| x.__radd__(y) <==> y+x
|
| __rdiv__(...)
| x.__rdiv__(y) <==> y/x
|
| __rdivmod__(...)
| x.__rdivmod__(y) <==> divmod(y, x)
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __rfloordiv__(...)
| x.__rfloordiv__(y) <==> y//x
|
| __rlshift__(...)
| x.__rlshift__(y) <==> y<<x
|
| __rmod__(...)
| x.__rmod__(y) <==> y%x
|
| __rmul__(...)
| x.__rmul__(y) <==> y*x
|
| __rpow__(...)
| y.__rpow__(x[, z]) <==> pow(x, y[, z])
|
| __rrshift__(...)
| x.__rrshift__(y) <==> y>>x
|
| __rshift__(...)
| x.__rshift__(y) <==> x>>y
|
| __rsub__(...)
| x.__rsub__(y) <==> y-x
|
| __rtruediv__(...)
| x.__rtruediv__(y) <==> y/x
|
| __setstate__(...)
|
| __sizeof__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __sub__(...)
| x.__sub__(y) <==> x-y
|
| __truediv__(...)
| x.__truediv__(y) <==> x/y
|
| all(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| any(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| argmax(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| argmin(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| argsort(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| astype(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| byteswap(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class so as to
| provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| choose(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| clip(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| compress(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| conj(...)
|
| conjugate(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| copy(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| cumprod(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| cumsum(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| diagonal(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| dump(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| dumps(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| fill(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| flatten(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| getfield(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| item(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| itemset(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| max(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| mean(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| min(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| newbyteorder(...)
| newbyteorder(new_order='S')
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'L'} - little endian
| * {'>', 'B'} - big endian
| * {'=', 'N'} - native order
| * {'|', 'I'} - ignore (no change to byte order)
|
| Parameters
| ----------
| new_order : str, optional
| Byte order to force; a value from the byte order specifications
| above. The default value ('S') results in swapping the current
| byte order. The code does a case-insensitive check on the first
| letter of `new_order` for the alternatives above. For example,
| any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| prod(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| ptp(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| put(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| ravel(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| repeat(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| reshape(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| resize(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| round(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| searchsorted(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| setfield(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| setflags(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class so as to
| provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| sort(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| squeeze(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| std(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| sum(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| swapaxes(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| take(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| tobytes(...)
|
| tofile(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| tolist(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| tostring(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| trace(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| transpose(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| var(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| view(...)
| Not implemented (virtual attribute)
|
| Class generic exists solely to derive numpy scalars from, and possesses,
| albeit unimplemented, all the attributes of the ndarray class
| so as to provide a uniform API.
|
| See Also
| --------
| The corresponding attribute of the derived class of interest.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| transpose
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| base object
|
| data
| pointer to start of data
|
| dtype
| get array data-descriptor
|
| flags
| integer value of flags
|
| flat
| a 1-d view of scalar
|
| imag
| imaginary part of scalar
|
| itemsize
| length of one element in bytes
|
| nbytes
| length of item in bytes
|
| ndim
| number of array dimensions
|
| real
| real part of scalar
|
| shape
| tuple of array dimensions
|
| size
| number of elements in the gentype
|
| strides
| tuple of bytes steps in each dimension
NumPy doc （一）
最新推荐文章于 2022-02-15 10:25:34 发布
389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
