| |
- object
-
- broadcast
- dtype
- flatiter
- generic
-
- bool_
- bool_
- flexible
-
- character
-
- string_(str, character)
- string_(str, character)
- string_(str, character)
- unicode_(unicode, character)
- unicode_(unicode, character)
- void
- void
- number
-
- inexact
-
- complexfloating
-
- complex128(complexfloating, complex)
- complex128(complexfloating, complex)
- complex128(complexfloating, complex)
- complex128(complexfloating, complex)
- complex256
- complex256
- complex256
- complex256
- complex64
- complex64
- complex64
- floating
-
- float128
- float128
- float128
- float32
- float32
- float64(floating, float)
- float64(floating, float)
- float64(floating, float)
- integer
-
- signedinteger
-
- int16
- int16
- int32
- int32
- int64(signedinteger, int)
- int64(signedinteger, int)
- int64(signedinteger, int)
- int64(signedinteger, int)
- int64(signedinteger, int)
- int8
- int8
- unsignedinteger
-
- uint16
- uint16
- uint32
- uint32
- uint64
- uint64
- uint64
- uint64
- uint64
- uint8
- uint8
- object_
- object_
- ndarray
- ufunc
- str(basestring)
-
- string_(str, character)
- string_(str, character)
- string_(str, character)
- unicode(basestring)
-
- unicode_(unicode, character)
- unicode_(unicode, character)
bool8 = class bool_(generic) |
|
Boolean. Character code ``?``. |
|
- Method resolution order:
- bool_
- generic
- 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 at 0x7f8ebc3395e0>
- 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
- __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__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class bool_(generic) |
|
Boolean. Character code ``?``. |
|
- Method resolution order:
- bool_
- generic
- 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 at 0x7f8ebc3395e0>
- 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
- __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__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class broadcast(object) |
|
Produce an object that mimics broadcasting.
Parameters
----------
in1, in2, ... : array_like
Input parameters.
Returns
-------
b : broadcast object
Broadcast the input parameters against one another, and
return an object that encapsulates the result.
Amongst others, it has ``shape`` and ``nd`` properties, and
may be used as an iterator.
Examples
--------
Manually adding two vectors, using broadcasting:
>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x, y)
>>> out = np.empty(b.shape)
>>> out.flat = [u+v for (u,v) in b]
>>> out
array([[ 5., 6., 7.],
[ 6., 7., 8.],
[ 7., 8., 9.]])
Compare against built-in broadcasting:
>>> x + y
array([[5, 6, 7],
[6, 7, 8],
[7, 8, 9]]) |
|
Methods defined here:
- __iter__(...)
- x.__iter__() <==> iter(x)
- next(...)
- x.next() -> the next value, or raise StopIteration
- reset(...)
Data descriptors defined here:
- index
- current index in broadcasted result
- iters
- tuple of individual iterators
- nd
- number of dimensions of broadcasted result
- numiter
- number of iterators
- shape
- shape of broadcasted result
- size
- total size of broadcasted result
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc339440>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
byte = class int8(signedinteger) |
|
8-bit integer. Character code ``b``. |
|
- Method resolution order:
- int8
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33a800>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
cdouble = class complex128(complexfloating, complex) |
|
Composed of two 64 bit floats |
|
- Method resolution order:
- complex128
- complexfloating
- inexact
- number
- generic
- complex
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bec0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from complex:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
|
cfloat = class complex128(complexfloating, complex) |
|
Composed of two 64 bit floats |
|
- Method resolution order:
- complex128
- complexfloating
- inexact
- number
- generic
- complex
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bec0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from complex:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
|
class character(flexible) |
| |
- Method resolution order:
- character
- flexible
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
clongdouble = class complex256(complexfloating) |
|
Composed of two 128 bit floats |
|
- Method resolution order:
- complex256
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
clongfloat = class complex256(complexfloating) |
|
Composed of two 128 bit floats |
|
- Method resolution order:
- complex256
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class complex128(complexfloating, complex) |
|
Composed of two 64 bit floats |
|
- Method resolution order:
- complex128
- complexfloating
- inexact
- number
- generic
- complex
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bec0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from complex:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
|
class complex256(complexfloating) |
|
Composed of two 128 bit floats |
|
- Method resolution order:
- complex256
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class complex64(complexfloating) |
|
Composed of two 32 bit floats |
|
- Method resolution order:
- complex64
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bd20>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
complex_ = class complex128(complexfloating, complex) |
|
Composed of two 64 bit floats |
|
- Method resolution order:
- complex128
- complexfloating
- inexact
- number
- generic
- complex
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bec0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from complex:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
|
class complexfloating(inexact) |
| |
- Method resolution order:
- complexfloating
- inexact
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
csingle = class complex64(complexfloating) |
|
Composed of two 32 bit floats |
|
- Method resolution order:
- complex64
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bd20>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
double = class float64(floating, float) |
|
64-bit floating-point number. Character code ``d``. |
|
- Method resolution order:
- float64
- floating
- inexact
- number
- generic
- float
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b9e0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from float:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- float.__format__(format_spec) -> string
Formats the float according to format_spec.
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Returns the Integral closest to x between 0 and x.
- as_integer_ratio(...)
- float.as_integer_ratio() -> (int, int)
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
- hex(...)
- float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
- is_integer(...)
- Returns True if the float is an integer.
Data and other attributes inherited from float:
- __getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
- float.__getformat__(typestr) -> string
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
- __setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
- float.__setformat__(typestr, fmt) -> None
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
- fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
- float.fromhex(string) -> float
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324
|
class dtype(object) |
|
dtype(obj, align=False, copy=False)
Create a data type object.
A numpy array is homogeneous, and contains elements described by a
dtype object. A dtype object can be constructed from different
combinations of fundamental numeric types.
Parameters
----------
obj
Object to be converted to a data type object.
align : bool, optional
Add padding to the fields to match what a C compiler would output
for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
or a comma-separated string.
copy : bool, optional
Make a new copy of the data-type object. If ``False``, the result
may just be a reference to a built-in data-type object.
Examples
--------
Using array-scalar type:
>>> np.dtype(np.int16)
dtype('int16')
Record, one field name 'f1', containing int16:
>>> np.dtype([('f1', np.int16)])
dtype([('f1', '<i2')])
Record, one field named 'f1', in itself containing a record with one field:
>>> np.dtype([('f1', [('f1', np.int16)])])
dtype([('f1', [('f1', '<i2')])])
Record, two fields: the first field contains an unsigned int, the
second an int32:
>>> np.dtype([('f1', np.uint), ('f2', np.int32)])
dtype([('f1', '<u4'), ('f2', '<i4')])
Using array-protocol type strings:
>>> np.dtype([('a','f8'),('b','S10')])
dtype([('a', '<f8'), ('b', '|S10')])
Using comma-separated field formats. The shape is (2,3):
>>> np.dtype("i4, (2,3)f8")
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
Using tuples. ``int`` is a fixed type, 3 the field's shape. ``void``
is a flexible type, here of size 10:
>>> np.dtype([('hello',(np.int,3)),('world',np.void,10)])
dtype([('hello', '<i4', 3), ('world', '|V10')])
Subdivide ``int16`` into 2 ``int8``'s, called x and y. 0 and 1 are
the offsets in bytes:
>>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
dtype(('<i2', [('x', '|i1'), ('y', '|i1')]))
Using dictionaries. Two fields named 'gender' and 'age':
>>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
dtype([('gender', '|S1'), ('age', '|u1')])
Offsets in bytes, here 0 and 25:
>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', '|S25'), ('age', '|u1')]) |
|
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __reduce__(...)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- 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.
Parameters
----------
new_order : string, optional
Byte order to force; a value from the byte order
specifications below. The default value ('S') results in
swapping the current byte order.
`new_order` codes can be any of::
* 'S' - swap dtype from current to opposite endian
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* {'|', 'I'} - ignore (no change to byte order)
The code does a case-insensitive check on the first letter of
`new_order` for these alternatives. For example, any of '>'
or 'B' or 'b' or 'brian' are valid to specify big-endian.
Returns
-------
new_dtype : dtype
New dtype object with the given change to the byte order.
Notes
-----
Changes are also made in all fields and sub-arrays of the data type.
Examples
--------
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> native_dt = np.dtype(native_code+'i2')
>>> swapped_dt = np.dtype(swapped_code+'i2')
>>> native_dt.newbyteorder('S') == swapped_dt
True
>>> native_dt.newbyteorder() == swapped_dt
True
>>> native_dt == swapped_dt.newbyteorder('S')
True
>>> native_dt == swapped_dt.newbyteorder('=')
True
>>> native_dt == swapped_dt.newbyteorder('N')
True
>>> native_dt == native_dt.newbyteorder('|')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('<')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('L')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('>')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('B')
True
Data descriptors defined here:
- alignment
- The required alignment (bytes) of this data-type according to the compiler.
More information is available in the C-API section of the manual.
- base
- byteorder
- A character indicating the byte-order of this data-type object.
One of:
=== ==============
'=' native
'<' little-endian
'>' big-endian
'|' not applicable
=== ==============
All built-in data-type objects have byteorder either '=' or '|'.
Examples
--------
>>> dt = np.dtype('i2')
>>> dt.byteorder
'='
>>> # endian is not relevant for 8 bit numbers
>>> np.dtype('i1').byteorder
'|'
>>> # or ASCII strings
>>> np.dtype('S2').byteorder
'|'
>>> # Even if specific code is given, and it is native
>>> # '=' is the byteorder
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> dt = np.dtype(native_code + 'i2')
>>> dt.byteorder
'='
>>> # Swapped code shows up as itself
>>> dt = np.dtype(swapped_code + 'i2')
>>> dt.byteorder == swapped_code
True
- char
- A unique character code for each of the 21 different built-in types.
- descr
- Array-interface compliant full description of the data-type.
The format is that required by the 'descr' key in the
`__array_interface__` attribute.
- fields
- Dictionary showing any named fields defined for this data type, or None.
The dictionary is indexed by keys that are the names of the fields.
Each entry in the dictionary is a tuple fully describing the field::
(dtype, offset[, title])
If present, the optional title can be any object (if it is string
or unicode then it will also be a key in the fields dictionary,
otherwise it's meta-data). Notice also, that the first two elements
of the tuple can be passed directly as arguments to the `ndarray.getfield`
and `ndarray.setfield` methods.
See Also
--------
ndarray.getfield, ndarray.setfield
- flags
- Bit-flags describing how this data type is to be interpreted.
Bit-masks are in `numpy.core.multiarray` as the constants
`ITEM_HASOBJECT`, `LIST_PICKLE`, `ITEM_IS_POINTER`, `NEEDS_INIT`,
`NEEDS_PYAPI`, `USE_GETITEM`, `USE_SETITEM`. A full explanation
of these flags is in C-API documentation; they are largely useful
for user-defined data-types.
- hasobject
- Boolean indicating whether this dtype contains any reference-counted
objects in any fields or sub-dtypes.
Recall that what is actually in the ndarray memory representing
the Python object is the memory address of that object (a pointer).
Special handling may be required, and this attribute is useful for
distinguishing data types that may contain arbitrary Python objects
and data-types that won't.
- isbuiltin
- Integer indicating how this dtype relates to the built-in dtypes.
= ========================================================================
0 if this is a structured array type, with fields
1 if this is a dtype compiled into numpy (such as ints, floats etc)
2 if the dtype is for a user-defined numpy type
A user-defined type uses the numpy C-API machinery to extend
numpy to handle a new array type. See the Guide to Numpy for
details.
= ========================================================================
Examples
--------
>>> dt = np.dtype('i2')
>>> dt.isbuiltin
1
>>> dt = np.dtype('f8')
>>> dt.isbuiltin
1
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.isbuiltin
0
- isnative
- Boolean indicating whether the byte order of this dtype is native
to the platform.
- itemsize
- The element size of this data-type object.
For 18 of the 21 types this number is fixed by the data-type.
For the flexible data-types, this number can be anything.
- kind
- A character code (one of 'biufcSUV') identifying the general kind of data.
- name
- A bit-width name for this data-type.
Un-sized flexible data-type objects do not have this attribute.
- names
- Ordered list of field names, or ``None`` if there are no fields.
The names are ordered according to increasing byte offset.
- num
- A unique number for each of the 21 different built-in types.
These are roughly ordered from least-to-most precision.
- shape
- Shape tuple of the sub-array if this data type describes a sub-array,
and ``()`` otherwise.
- str
- The array-protocol typestring of this data-type object.
- subdtype
- Tuple ``(item_dtype, shape)`` if this `dtype` describes a sub-array, and
None otherwise.
The *shape* is the fixed shape of the sub-array described by this
data type, and *item_dtype* the data type of the array.
If a field whose dtype object has this attribute is retrieved,
then the extra dimensions implied by *shape* are tacked on to
the end of the retrieved array.
- type
- The type object used to instantiate a scalar of this data-type.
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc338f60>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class flexible(generic) |
| |
- Method resolution order:
- flexible
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class float128(floating) |
| |
- Method resolution order:
- float128
- floating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class float32(floating) |
|
32-bit floating-point number. Character code ``f``. |
|
- Method resolution order:
- float32
- floating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b840>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class float64(floating, float) |
|
64-bit floating-point number. Character code ``d``. |
|
- Method resolution order:
- float64
- floating
- inexact
- number
- generic
- float
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b9e0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from float:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- float.__format__(format_spec) -> string
Formats the float according to format_spec.
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Returns the Integral closest to x between 0 and x.
- as_integer_ratio(...)
- float.as_integer_ratio() -> (int, int)
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
- hex(...)
- float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
- is_integer(...)
- Returns True if the float is an integer.
Data and other attributes inherited from float:
- __getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
- float.__getformat__(typestr) -> string
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
- __setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
- float.__setformat__(typestr, fmt) -> None
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
- fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
- float.fromhex(string) -> float
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324
|
float_ = class float64(floating, float) |
|
64-bit floating-point number. Character code ``d``. |
|
- Method resolution order:
- float64
- floating
- inexact
- number
- generic
- float
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b9e0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from float:
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- float.__format__(format_spec) -> string
Formats the float according to format_spec.
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Returns the Integral closest to x between 0 and x.
- as_integer_ratio(...)
- float.as_integer_ratio() -> (int, int)
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
- hex(...)
- float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
- is_integer(...)
- Returns True if the float is an integer.
Data and other attributes inherited from float:
- __getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
- float.__getformat__(typestr) -> string
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
- __setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
- float.__setformat__(typestr, fmt) -> None
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
- fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
- float.fromhex(string) -> float
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324
|
class floating(inexact) |
| |
- Method resolution order:
- floating
- inexact
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class generic(object) |
| |
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
Data descriptors defined here:
- 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
|
class inexact(number) |
| |
- Method resolution order:
- inexact
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
int0 = class int64(signedinteger, int) |
|
64-bit integer. Character code ``i8``. |
|
- Method resolution order:
- int64
- signedinteger
- integer
- number
- generic
- int
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ace0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from int:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Truncating an Integral returns itself.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- numerator
- the numerator of a rational number in lowest terms
|
class int16(signedinteger) |
|
16-bit integer. Character code ``h``. |
|
- Method resolution order:
- int16
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33a9a0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class int32(signedinteger) |
|
32-bit integer. Character code ``i4``. |
|
- Method resolution order:
- int32
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ab40>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class int64(signedinteger, int) |
|
64-bit integer. Character code ``i8``. |
|
- Method resolution order:
- int64
- signedinteger
- integer
- number
- generic
- int
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ace0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from int:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Truncating an Integral returns itself.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- numerator
- the numerator of a rational number in lowest terms
|
class int8(signedinteger) |
|
8-bit integer. Character code ``b``. |
|
- Method resolution order:
- int8
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33a800>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
int_ = class int64(signedinteger, int) |
|
64-bit integer. Character code ``i8``. |
|
- Method resolution order:
- int64
- signedinteger
- integer
- number
- generic
- int
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ace0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from int:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Truncating an Integral returns itself.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- numerator
- the numerator of a rational number in lowest terms
|
intc = class int32(signedinteger) |
|
32-bit integer. Character code ``i4``. |
|
- Method resolution order:
- int32
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ab40>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class integer(number) |
| |
- Method resolution order:
- integer
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
intp = class int64(signedinteger, int) |
|
64-bit integer. Character code ``i8``. |
|
- Method resolution order:
- int64
- signedinteger
- integer
- number
- generic
- int
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ace0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from int:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Truncating an Integral returns itself.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- numerator
- the numerator of a rational number in lowest terms
|
longcomplex = class complex256(complexfloating) |
|
Composed of two 128 bit floats |
|
- Method resolution order:
- complex256
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
longdouble = class float128(floating) |
| |
- Method resolution order:
- float128
- floating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
longfloat = class float128(floating) |
| |
- Method resolution order:
- float128
- floating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __oct__(...)
- x.__oct__() <==> oct(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
- 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
- __and__(...)
- x.__and__(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)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __invert__(...)
- x.__invert__() <==> ~x
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
longlong = class int64(signedinteger, int) |
| |
- Method resolution order:
- int64
- signedinteger
- integer
- number
- generic
- int
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33ae80>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
Methods inherited from int:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __trunc__(...)
- Truncating an Integral returns itself.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- numerator
- the numerator of a rational number in lowest terms
|
class ndarray(object) |
|
ndarray(shape, dtype=float, buffer=None, offset=0,
strides=None, order=None)
An array object represents a multidimensional, homogeneous array
of fixed-size items. An associated data-type object
describes the format of each element in the array (its byte-order,
how many bytes it occupies in memory, whether it is an integer or
a floating point number, etc.).
Arrays should be constructed using `array`, `zeros` or `empty` (refer to
the ``See Also`` section below). The parameters given here describe
a low-level method for instantiating an array (`ndarray(...)`).
For more information, refer to the `numpy` module and examine the
the methods and attributes of an array.
Attributes
----------
T : ndarray
Transponent of the array.
data : buffer
Array data in memory.
dtype : data type
Data type, describing the format of the elements in the array.
flags : dict
Dictionary containing information related to memory use, e.g.,
'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', and others.
flat : ndarray
Return flattened version of the array as an iterator. The iterator
allows assignments, e.g., ``x.flat = 3``.
imag : ndarray
Imaginary part of the array.
real : ndarray
Real part of the array.
size : int
Number of elements in the array.
itemsize : int
The size of each element in memory (in bytes).
nbytes : int
The total number of bytes required to store the array data,
i.e., ``itemsize * size``.
ndim : int
The number of dimensions that the array has.
shape : tuple of ints
Shape of the array.
strides : tuple of ints
The step-size required to move from one element to the next in memory.
For example, a contiguous ``(3, 4)`` array of type ``int16`` in C-order
has strides ``(8, 2)``. This implies that to move from element to
element in memory requires jumps of 2 bytes. To move from row-to-row,
one needs to jump 6 bytes at a time (``2 * 4``).
ctypes : ctypes object
Class containing properties of the array needed for interaction
with ctypes.
base : ndarray
If the array is a view on another array, that array is
its `base` (unless that array is also a view). The `base` array
is where the array data is ultimately stored.
Parameters
----------
shape : tuple of ints
Shape of created array.
dtype : data type, optional
Any object that can be interpreted a numpy data type.
buffer : object exposing buffer interface, optional
Used to fill the array with data.
offset : int, optional
Offset of array data in buffer.
strides : tuple of ints, optional
Strides of data in memory.
order : {'C', 'F'}, optional
Row-major or column-major order.
See Also
--------
array : Construct an array.
zeros : Create an array and fill its allocated memory with zeros.
empty : Create an array, but leave its allocated memory unchanged.
dtype : Create a data type.
Notes
-----
There are two modes of creating an array using __new__:
1. If `buffer` is None, then only `shape`, `dtype`, and `order`
are used.
2. If `buffer` is an object exporting the buffer interface, then
all keywords are interpreted.
No __init__ method is needed because the array is fully initialized
after the __new__ method.
Examples
--------
These examples illustrate the low-level `ndarray` constructor. Refer
to the `See Also` section for easier ways of constructing an ndarray.
First mode, `buffer` is None:
>>> np.ndarray(shape=(2,2), dtype=float, order='F')
array([[ -1.13698227e+002, 4.25087011e-303],
[ 2.88528414e-306, 3.27025015e-309]])
Second mode:
>>> np.ndarray((2,), buffer=np.array([1,2,3]),
... offset=np.int_().itemsize,
... dtype=int) # offset = 1*itemsize, i.e. skip first element
array([2, 3]) |
|
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __array__(...)
- a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
Returns either a new reference to self if dtype is not given or a new array
of provided data type if dtype is different from the current dtype of the
array.
- __array_wrap__(...)
- a.__array_wrap__(obj) -> Object of same type as a from ndarray obj.
- __contains__(...)
- x.__contains__(y) <==> y in x
- __copy__(...)
- a.__copy__([order])
Return a copy of the array.
Parameters
----------
order : {'C', 'F', 'A'}, optional
If order is 'C' (False) then the result is contiguous (default).
If order is 'Fortran' (True) then the result has fortran order.
If order is 'Any' (None) then the result has fortran order
only if the array already is in fortran order.
- __deepcopy__(...)
- a.__deepcopy__() -> Deep copy of array.
Used if copy.deepcopy is called on an array.
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __delslice__(...)
- x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __iadd__(...)
- x.__iadd__(y) <==> x+y
- __iand__(...)
- x.__iand__(y) <==> x&y
- __idiv__(...)
- x.__idiv__(y) <==> x/y
- __ifloordiv__(...)
- x.__ifloordiv__(y) <==> x//y
- __ilshift__(...)
- x.__ilshift__(y) <==> x<<y
- __imod__(...)
- x.__imod__(y) <==> x%y
- __imul__(...)
- x.__imul__(y) <==> x*y
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __ior__(...)
- x.__ior__(y) <==> x|y
- __ipow__(...)
- x.__ipow__(y) <==> x**y
- __irshift__(...)
- x.__irshift__(y) <==> x>>y
- __isub__(...)
- x.__isub__(y) <==> x-y
- __iter__(...)
- x.__iter__() <==> iter(x)
- __itruediv__(...)
- x.__itruediv__(y) <==> x/y
- __ixor__(...)
- x.__ixor__(y) <==> x^y
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- a.__reduce__()
For pickling.
- __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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __setslice__(...)
- x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
- __setstate__(...)
- a.__setstate__(version, shape, dtype, isfortran, rawdata)
For unpickling.
Parameters
----------
version : int
optional pickle version. If omitted defaults to 0.
shape : tuple
dtype : data-type
isFortran : bool
rawdata : string or list
a binary string with the data (or a list if 'a' is an object array)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- a.all(axis=None, out=None)
Returns True if all elements evaluate to True.
Refer to `numpy.all` for full documentation.
See Also
--------
numpy.all : equivalent function
- any(...)
- a.any(axis=None, out=None)
Check if any of the elements of `a` are true.
Refer to `numpy.any` for full documentation.
See Also
--------
numpy.any : equivalent function
- argmax(...)
- a.argmax(axis=None, out=None)
Return indices of the maximum values along the given axis of `a`.
Parameters
----------
axis : int, optional
Axis along which to operate. By default flattened input is used.
out : ndarray, optional
Alternative output array in which to place the result. Must
be of the same shape and buffer length as the expected output.
Returns
-------
index_array : ndarray
An array of indices or single index value, or a reference to `out`
if it was specified.
Examples
--------
>>> a = np.arange(6).reshape(2,3)
>>> a.argmax()
5
>>> a.argmax(0)
array([1, 1, 1])
>>> a.argmax(1)
array([2, 2])
- argmin(...)
- a.argmin(axis=None, out=None)
Return indices of the minimum values along the given axis of `a`.
Refer to `numpy.ndarray.argmax` for detailed documentation.
- argsort(...)
- a.argsort(axis=-1, kind='quicksort', order=None)
Returns the indices that would sort this array.
Refer to `numpy.argsort` for full documentation.
See Also
--------
numpy.argsort : equivalent function
- astype(...)
- a.astype(t)
Copy of the array, cast to a specified type.
Parameters
----------
t : string or dtype
Typecode or data-type to which the array is cast.
Examples
--------
>>> x = np.array([1, 2, 2.5])
>>> x
array([ 1. , 2. , 2.5])
>>> x.astype(int)
array([1, 2, 2])
- byteswap(...)
- a.byteswap(inplace)
Swap the bytes of the array elements
Toggle between low-endian and big-endian data representation by
returning a byteswapped array, optionally swapped in-place.
Parameters
----------
inplace: bool, optional
If ``True``, swap bytes in-place, default is ``False``.
Returns
-------
out: ndarray
The byteswapped array. If `inplace` is ``True``, this is
a view to self.
Examples
--------
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> map(hex, A)
['0x1', '0x100', '0x2233']
>>> A.byteswap(True)
array([ 256, 1, 13090], dtype=int16)
>>> map(hex, A)
['0x100', '0x1', '0x3322']
Arrays of strings are not swapped
>>> A = np.array(['ceg', 'fac'])
>>> A.byteswap()
array(['ceg', 'fac'],
dtype='|S3')
- choose(...)
- a.choose(choices, out=None, mode='raise')
Use an index array to construct a new array from a set of choices.
Refer to `numpy.choose` for full documentation.
See Also
--------
numpy.choose : equivalent function
- clip(...)
- a.clip(a_min, a_max, out=None)
Return an array whose values are limited to ``[a_min, a_max]``.
Refer to `numpy.clip` for full documentation.
See Also
--------
numpy.clip : equivalent function
- compress(...)
- a.compress(condition, axis=None, out=None)
Return selected slices of this array along given axis.
Refer to `numpy.compress` for full documentation.
See Also
--------
numpy.compress : equivalent function
- conj(...)
- a.conj()
Return an array with all complex-valued elements conjugated.
- conjugate(...)
- a.conjugate()
Return an array with all complex-valued elements conjugated.
- copy(...)
- a.copy(order='C')
Return a copy of the array.
Parameters
----------
order : {'C', 'F', 'A'}, optional
By default, the result is stored in C-contiguous (row-major) order in
memory. If `order` is `F`, the result has 'Fortran' (column-major)
order. If order is 'A' ('Any'), then the result has the same order
as the input.
Examples
--------
>>> x = np.array([[1,2,3],[4,5,6]], order='F')
>>> y = x.copy()
>>> x.fill(0)
>>> x
array([[0, 0, 0],
[0, 0, 0]])
>>> y
array([[1, 2, 3],
[4, 5, 6]])
>>> y.flags['C_CONTIGUOUS']
True
- cumprod(...)
- a.cumprod(axis=None, dtype=None, out=None)
Return the cumulative product of the elements along the given axis.
Refer to `numpy.cumprod` for full documentation.
See Also
--------
numpy.cumprod : equivalent function
- cumsum(...)
- a.cumsum(axis=None, dtype=None, out=None)
Return the cumulative sum of the elements along the given axis.
Refer to `numpy.cumsum` for full documentation.
See Also
--------
numpy.cumsum : equivalent function
- diagonal(...)
- a.diagonal(offset=0, axis1=0, axis2=1)
Return specified diagonals.
Refer to `numpy.diagonal` for full documentation.
See Also
--------
numpy.diagonal : equivalent function
- dump(...)
- a.dump(file)
Dump a pickle of the array to the specified file.
The array can be read back with pickle.load or numpy.load.
Parameters
----------
file : str
A string naming the dump file.
- dumps(...)
- a.dumps()
Returns the pickle of the array as a string.
pickle.loads or numpy.loads will convert the string back to an array.
- fill(...)
- a.fill(value)
Fill the array with a scalar value.
Parameters
----------
a : ndarray
Input array
value : scalar
All elements of `a` will be assigned this value.
Examples
--------
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([ 1., 1.])
- flatten(...)
- a.flatten(order='C')
Return a copy of the array collapsed into one dimension.
Parameters
----------
order : {'C', 'F'}, optional
Whether to flatten in C (row-major) or Fortran (column-major) order.
The default is 'C'.
Returns
-------
y : ndarray
A copy of the input array, flattened to one dimension.
See Also
--------
ravel : Return a flattened array.
flat : A 1-D flat iterator over the array.
Examples
--------
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])
- getfield(...)
- a.getfield(dtype, offset)
Returns a field of the given array as a certain type. A field is a view of
the array data with each itemsize determined by the given type and the
offset into the current array.
- item(...)
- a.item()
Copy the first element of array to a standard Python scalar and return
it. The array must be of size one.
- itemset(...)
- max(...)
- a.max(axis=None, out=None)
Return the maximum along a given axis.
Refer to `numpy.amax` for full documentation.
See Also
--------
numpy.amax : equivalent function
- mean(...)
- a.mean(axis=None, dtype=None, out=None)
Returns the average of the array elements along given axis.
Refer to `numpy.mean` for full documentation.
See Also
--------
numpy.mean : equivalent function
- min(...)
- a.min(axis=None, out=None)
Return the minimum along a given axis.
Refer to `numpy.amin` for full documentation.
See Also
--------
numpy.amin : equivalent function
- newbyteorder(...)
- arr.newbyteorder(new_order='S')
Return the array with the same data viewed with a different byte order.
Equivalent to::
arr.view(arr.dtype.newbytorder(new_order))
Changes are also made in all fields and sub-arrays of the array data
type.
Parameters
----------
new_order : string, optional
Byte order to force; a value from the byte order specifications
above. `new_order` codes can be any of::
* 'S' - swap dtype from current to opposite endian
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* {'|', 'I'} - ignore (no change to byte order)
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_arr : array
New array object with the dtype reflecting given change to the
byte order.
- nonzero(...)
- a.nonzero()
Return the indices of the elements that are non-zero.
Refer to `numpy.nonzero` for full documentation.
See Also
--------
numpy.nonzero : equivalent function
- prod(...)
- a.prod(axis=None, dtype=None, out=None)
Return the product of the array elements over the given axis
Refer to `numpy.prod` for full documentation.
See Also
--------
numpy.prod : equivalent function
- ptp(...)
- a.ptp(axis=None, out=None)
Peak to peak (maximum - minimum) value along a given axis.
Refer to `numpy.ptp` for full documentation.
See Also
--------
numpy.ptp : equivalent function
- put(...)
- a.put(indices, values, mode='raise')
Set a.flat[n] = values[n] for all n in indices.
Refer to `numpy.put` for full documentation.
See Also
--------
numpy.put : equivalent function
- ravel(...)
- a.ravel([order])
Return a flattened array.
Refer to `numpy.ravel` for full documentation.
See Also
--------
numpy.ravel : equivalent function
ndarray.flat : a flat iterator on the array.
- repeat(...)
- a.repeat(repeats, axis=None)
Repeat elements of an array.
Refer to `numpy.repeat` for full documentation.
See Also
--------
numpy.repeat : equivalent function
- reshape(...)
- a.reshape(shape, order='C')
Returns an array containing the same data with a new shape.
Refer to `numpy.reshape` for full documentation.
See Also
--------
numpy.reshape : equivalent function
- resize(...)
- a.resize(new_shape, refcheck=True, order=False)
Change shape and size of array in-place.
Parameters
----------
a : ndarray
Input array.
new_shape : {tuple, int}
Shape of resized array.
refcheck : bool, optional
If False, memory referencing will not be checked. Default is True.
order : bool, optional
<needs an explanation>. Default if False.
Returns
-------
None
Raises
------
ValueError
If `a` does not own its own data, or references or views to it exist.
Examples
--------
Shrinking an array: array is flattened in C-order, resized, and reshaped:
>>> a = np.array([[0,1],[2,3]])
>>> a.resize((2,1))
>>> a
array([[0],
[1]])
Enlarging an array: as above, but missing entries are filled with zeros:
>>> b = np.array([[0,1],[2,3]])
>>> b.resize((2,3))
>>> b
array([[0, 1, 2],
[3, 0, 0]])
Referencing an array prevents resizing:
>>> c = a
>>> a.resize((1,1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that has been referenced ...
- round(...)
- a.round(decimals=0, out=None)
Return an array rounded a to the given number of decimals.
Refer to `numpy.around` for full documentation.
See Also
--------
numpy.around : equivalent function
- searchsorted(...)
- a.searchsorted(v, side='left')
Find indices where elements of v should be inserted in a to maintain order.
For full documentation, see `numpy.searchsorted`
See Also
--------
numpy.searchsorted : equivalent function
- setfield(...)
- m.setfield(value, dtype, offset) -> None.
places val into field of the given array defined by the data type and offset.
- setflags(...)
- a.setflags(write=None, align=None, uic=None)
- sort(...)
- a.sort(axis=-1, kind='quicksort', order=None)
Sort an array, in-place.
Parameters
----------
axis : int, optional
Axis along which to sort. Default is -1, which means sort along the
last axis.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm. Default is 'quicksort'.
order : list, optional
When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc. Not all fields need be
specified.
See Also
--------
numpy.sort : Return a sorted copy of an array.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in sorted array.
Notes
-----
See ``sort`` for notes on the different sorting algorithms.
Examples
--------
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
[1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
[1, 4]])
Use the `order` keyword to specify a field to use when sorting a
structured array:
>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([('c', 1), ('a', 2)],
dtype=[('x', '|S1'), ('y', '<i4')])
- squeeze(...)
- a.squeeze()
Remove single-dimensional entries from the shape of `a`.
Refer to `numpy.squeeze` for full documentation.
See Also
--------
numpy.squeeze : equivalent function
- std(...)
- a.std(axis=None, dtype=None, out=None, ddof=0)
Returns the standard deviation of the array elements along given axis.
Refer to `numpy.std` for full documentation.
See Also
--------
numpy.std : equivalent function
- sum(...)
- a.sum(axis=None, dtype=None, out=None)
Return the sum of the array elements over the given axis.
Refer to `numpy.sum` for full documentation.
See Also
--------
numpy.sum : equivalent function
- swapaxes(...)
- a.swapaxes(axis1, axis2)
Return a view of the array with `axis1` and `axis2` interchanged.
Refer to `numpy.swapaxes` for full documentation.
See Also
--------
numpy.swapaxes : equivalent function
- take(...)
- a.take(indices, axis=None, out=None, mode='raise')
Return an array formed from the elements of a at the given indices.
Refer to `numpy.take` for full documentation.
See Also
--------
numpy.take : equivalent function
- tofile(...)
- a.tofile(fid, sep="", format="%s")
Write array to a file as text or binary.
Data is always written in 'C' order, independently of the order of `a`.
The data produced by this method can be recovered by using the function
fromfile().
This is a convenience function for quick storage of array data.
Information on endianess and precision is lost, so this method is not a
good choice for files intended to archive data or transport data between
machines with different endianess. Some of these problems can be overcome
by outputting the data as text files at the expense of speed and file size.
Parameters
----------
fid : file or string
An open file object or a string containing a filename.
sep : string
Separator between array items for text output.
If "" (empty), a binary file is written, equivalently to
file.write(a.tostring()).
format : string
Format string for text file output.
Each entry in the array is formatted to text by converting it to the
closest Python type, and using "format" % item.
- tolist(...)
- a.tolist()
Return the array as a possibly nested list.
Return a copy of the array data as a (nested) Python list.
Data items are converted to the nearest compatible Python type.
Parameters
----------
none
Returns
-------
y : list
The possibly nested list of array elements.
Notes
-----
The array may be recreated, ``a = np.array(a.tolist())``.
Examples
--------
>>> a = np.array([1, 2])
>>> a.tolist()
[1, 2]
>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]
- tostring(...)
- a.tostring(order='C')
Construct a Python string containing the raw data bytes in the array.
Parameters
----------
order : {'C', 'F', None}
Order of the data for multidimensional arrays:
C, Fortran, or the same as for the original array.
- trace(...)
- a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
Return the sum along diagonals of the array.
Refer to `numpy.trace` for full documentation.
See Also
--------
numpy.trace : equivalent function
- transpose(...)
- a.transpose(*axes)
Returns a view of 'a' with axes transposed. If no axes are given,
or None is passed, switches the order of the axes. For a 2-d
array, this is the usual matrix transpose. If axes are given,
they describe how the axes are permuted.
See Also
--------
ndarray.T : array property returning the array transposed
Examples
--------
>>> a = np.array([[1,2],[3,4]])
>>> a
array([[1, 2],
[3, 4]])
>>> a.transpose()
array([[1, 3],
[2, 4]])
>>> a.transpose((1,0))
array([[1, 3],
[2, 4]])
>>> a.transpose(1,0)
array([[1, 3],
[2, 4]])
- var(...)
- a.var(axis=None, dtype=None, out=None, ddof=0)
Returns the variance of the array elements, along given axis.
Refer to `numpy.var` for full documentation.
See Also
--------
numpy.var : equivalent function
- view(...)
- a.view(dtype=None, type=None)
New view of array with the same data.
Parameters
----------
dtype : data-type
Data-type descriptor of the returned view, e.g. float32 or int16.
type : python type
Type of the returned view, e.g. ndarray or matrix.
Examples
--------
>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
Viewing array data using a different type and dtype:
>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> print y.dtype
int16
>>> print type(y)
<class 'numpy.core.defmatrix.matrix'>
Using a view to convert an array to a record array:
>>> z = x.view(np.recarray)
>>> z.a
array([1], dtype=int8)
Views share data:
>>> x[0] = (9, 10)
>>> z[0]
(9, 10)
Data descriptors defined here:
- T
- Same as transpose() except self is returned for self.ndim < 2.
Examples
--------
>>> x = np.array([[1.,2.],[3.,4.]])
>>> x.T
array([[ 1., 3.],
[ 2., 4.]])
- __array_finalize__
- None.
- __array_interface__
- Array protocol: Python side.
- __array_priority__
- Array priority.
- __array_struct__
- Array protocol: C-struct side.
- base
- Base object if memory is from some other object.
Examples
--------
Base of an array owning its memory is None:
>>> x = np.array([1,2,3,4])
>>> x.base is None
True
Slicing creates a view, and the memory is shared with x:
>>> y = x[2:]
>>> y.base is x
True
- ctypes
- A ctypes interface object.
- data
- Buffer object pointing to the start of the data.
- dtype
- Data-type for the array.
- flags
- Information about the memory layout of the array.
Attributes
----------
C_CONTIGUOUS (C)
The data is in a single, C-style contiguous segment.
F_CONTIGUOUS (F)
The data is in a single, Fortran-style contiguous segment.
OWNDATA (O)
The array owns the memory it uses or borrows it from another object.
WRITEABLE (W)
The data area can be written to.
ALIGNED (A)
The data and strides are aligned appropriately for the hardware.
UPDATEIFCOPY (U)
This array is a copy of some other array. When this array is
deallocated, the base array will be updated with the contents of
this array.
FNC
F_CONTIGUOUS and not C_CONTIGUOUS.
FORC
F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
BEHAVED (B)
ALIGNED and WRITEABLE.
CARRAY (CA)
BEHAVED and C_CONTIGUOUS.
FARRAY (FA)
BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
Notes
-----
The `flags` object can be also accessed dictionary-like, and using
lowercased attribute names. Short flag names are only supported in
dictionary access.
Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
the user, via assigning to ``flags['FLAGNAME']`` or `ndarray.setflags`.
The array flags cannot be set arbitrarily:
- UPDATEIFCOPY can only be set ``False``.
- ALIGNED can only be set ``True`` if the data is truly aligned.
- WRITEABLE can only be set ``True`` if the array owns its own memory
or the ultimate owner of the memory exposes a writeable buffer
interface or is a string.
- flat
- A 1-D flat iterator over the array.
This is a `flatiter` instance, which acts similarly to a Python iterator.
See Also
--------
flatten : Return a copy of the array collapsed into one dimension.
flatiter
Examples
--------
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
[4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
[2, 5],
[3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<type 'numpy.flatiter'>
- imag
- The imaginary part of the array.
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0. , 0.70710678])
>>> x.imag.dtype
dtype('float64')
- itemsize
- Length of one element in bytes.
Examples
--------
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16
- nbytes
- Number of bytes in the array.
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480
- ndim
- Number of array dimensions.
Examples
--------
>>> x = np.array([1,2,3])
>>> x.ndim
1
>>> y = np.zeros((2,3,4))
>>> y.ndim
3
- real
- The real part of the array.
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1. , 0.70710678])
>>> x.real.dtype
dtype('float64')
See Also
--------
numpy.real : equivalent function
- shape
- Tuple of array dimensions.
Examples
--------
>>> x = np.array([1,2,3,4])
>>> x.shape
(4,)
>>> y = np.zeros((4,5,6))
>>> y.shape
(4, 5, 6)
>>> y.shape = (2, 5, 2, 3, 2)
>>> y.shape
(2, 5, 2, 3, 2)
- size
- Number of elements in the array.
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.size
30
- strides
- Tuple of bytes to step in each dimension.
The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
is::
offset = sum(np.array(i) * a.strides)
Examples
--------
>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc338dc0>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class number(generic) |
| |
- Method resolution order:
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
object0 = class object_(generic) |
| |
- Method resolution order:
- object_
- generic
- object
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __call__(...)
- x.__call__(...) <==> x(...)
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delattr__(...)
- x.__delattr__('name') <==> del x.name
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __iadd__(...)
- x.__iadd__(y) <==> x+=y
- __imul__(...)
- x.__imul__(y) <==> x*=y
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setattr__(...)
- x.__setattr__('name', value) <==> x.name = value
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c200>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class object_(generic) |
| |
- Method resolution order:
- object_
- generic
- object
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __call__(...)
- x.__call__(...) <==> x(...)
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delattr__(...)
- x.__delattr__('name') <==> del x.name
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __iadd__(...)
- x.__iadd__(y) <==> x+=y
- __imul__(...)
- x.__imul__(y) <==> x*=y
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setattr__(...)
- x.__setattr__('name', value) <==> x.name = value
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c200>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
short = class int16(signedinteger) |
|
16-bit integer. Character code ``h``. |
|
- Method resolution order:
- int16
- signedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33a9a0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class signedinteger(integer) |
| |
- Method resolution order:
- signedinteger
- integer
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
single = class float32(floating) |
|
32-bit floating-point number. Character code ``f``. |
|
- Method resolution order:
- float32
- floating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b840>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
singlecomplex = class complex64(complexfloating) |
|
Composed of two 32 bit floats |
|
- Method resolution order:
- complex64
- complexfloating
- inexact
- number
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33bd20>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
str_ = class string_(str, character) |
| |
- Method resolution order:
- string_
- str
- basestring
- character
- flexible
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c3a0>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from str:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __format__(...)
- S.__format__(format_spec) -> unicode
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __len__(...)
- x.__len__() <==> len(x)
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- capitalize(...)
- S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
- center(...)
- S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
- encode(...)
- S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format(...)
- S.format(*args, **kwargs) -> unicode
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
- isupper(...)
- S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
- join(...)
- S.join(sequence) -> string
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> string
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- partition(...)
- S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
- replace(...)
- S.replace (old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
- rpartition(...)
- S.rpartition(sep) -> (tail, sep, head)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
- splitlines(...)
- S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
- title(...)
- S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
- upper(...)
- S.upper() -> string
Return a copy of the string S converted to uppercase.
- zfill(...)
- S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
string0 = class string_(str, character) |
| |
- Method resolution order:
- string_
- str
- basestring
- character
- flexible
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c3a0>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from str:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __format__(...)
- S.__format__(format_spec) -> unicode
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __len__(...)
- x.__len__() <==> len(x)
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- capitalize(...)
- S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
- center(...)
- S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
- encode(...)
- S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format(...)
- S.format(*args, **kwargs) -> unicode
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
- isupper(...)
- S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
- join(...)
- S.join(sequence) -> string
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> string
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- partition(...)
- S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
- replace(...)
- S.replace (old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
- rpartition(...)
- S.rpartition(sep) -> (tail, sep, head)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
- splitlines(...)
- S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
- title(...)
- S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
- upper(...)
- S.upper() -> string
Return a copy of the string S converted to uppercase.
- zfill(...)
- S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class string_(str, character) |
| |
- Method resolution order:
- string_
- str
- basestring
- character
- flexible
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c3a0>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from str:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __format__(...)
- S.__format__(format_spec) -> unicode
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __len__(...)
- x.__len__() <==> len(x)
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- capitalize(...)
- S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
- center(...)
- S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
- encode(...)
- S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format(...)
- S.format(*args, **kwargs) -> unicode
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
- isupper(...)
- S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
- join(...)
- S.join(sequence) -> string
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> string
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- partition(...)
- S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
- replace(...)
- S.replace (old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
- rpartition(...)
- S.rpartition(sep) -> (tail, sep, head)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
- splitlines(...)
- S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
- title(...)
- S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
- upper(...)
- S.upper() -> string
Return a copy of the string S converted to uppercase.
- zfill(...)
- S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
ubyte = class uint8(unsignedinteger) |
| |
- Method resolution order:
- uint8
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b020>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class ufunc(object) |
|
Functions that operate element by element on whole arrays.
Unary ufuncs:
=============
op(X, out=None)
Apply op to X elementwise
Parameters
----------
X : array_like
Input array
out : array_like
An array to store the output. Must be the same shape as X.
Returns
-------
r : array_like
r will have the same shape as X; if out is provided, r will be
equal to out.
Binary ufuncs:
==============
op(X, Y, out=None)
Apply op to X and Y elementwise. May "broadcast" to make
the shapes of X and Y congruent.
The broadcasting rules are:
* Dimensions of length 1 may be prepended to either array
* Arrays may be repeated along dimensions of length 1
Parameters
----------
X : array_like
First input array
Y : array_like
Second input array
out : array-like
An array to store the output. Must be the same shape as the
output would have.
Returns
-------
r : array-like
The return value; if out is provided, r will be equal to out. |
|
Methods defined here:
- __call__(...)
- x.__call__(...) <==> x(...)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
- accumulate(...)
- accumulate(array, axis=None, dtype=None, out=None)
Accumulate the result of applying the operator to all elements.
For a one-dimensional array, accumulate produces results equivalent to:
::
r = np.empty(len(A))
t = op.identity
for i in xrange(len(A)):
t = op(t,A[i])
r[i] = t
return r
For example, add.accumulate() is equivalent to cumsum().
Parameters
----------
array : array_like
The array to act on.
axis : int, optional
The axis along which to apply the accumulation.
dtype : data-type-code, optional
The type used to represent the intermediate results. Defaults
to the data type of the output array if this is provided, or
the data type of the input array if no output array is provided.
out : ndarray, optional
A location into which the result is stored. If not provided a
freshly-allocated array is returned.
Returns
-------
r : ndarray
The accumulated values. If `out` was supplied, `r` is equal to
`out`.
Examples
--------
>>> np.multiply.accumulate([2,3,5])
array([2,6,30])
- outer(...)
- outer(A,B)
Compute the result of applying op to all pairs (a,b)
op.outer(A,B) is equivalent to
op(A[:,:,...,:,newaxis,...,newaxis]*B[newaxis,...,newaxis,:,...,:])
where A has B.ndim new axes appended and B has A.ndim new axes prepended.
For A and B one-dimensional, this is equivalent to
::
r = empty(len(A),len(B))
for i in xrange(len(A)):
for j in xrange(len(B)):
r[i,j] = A[i]*B[j]
If A and B are higher-dimensional, the result has dimension A.ndim+B.ndim
Parameters
----------
A : array_like
First term
B : array_like
Second term
Returns
-------
r : ndarray
Output array
Examples
--------
>>> np.multiply.outer([1,2,3],[4,5,6])
array([[ 4, 5, 6],
[ 8, 10, 12],
[12, 15, 18]])
- reduce(...)
- reduce(array, axis=0, dtype=None, out=None)
Reduce applies the operator to all elements of the array.
For a one-dimensional array, reduce produces results equivalent to:
::
r = op.identity
for i in xrange(len(A)):
r = op(r,A[i])
return r
For example, add.reduce() is equivalent to sum().
Parameters
----------
array : array_like
The array to act on.
axis : integer, optional
The axis along which to apply the reduction.
dtype : data-type-code, optional
The type used to represent the intermediate results. Defaults
to the data type of the output array if this is provided, or
the data type of the input array if no output array is provided.
out : array_like, optional
A location into which the result is stored. If not provided a
freshly-allocated array is returned.
Returns
-------
r : ndarray
The reduced values. If out was supplied, r is equal to out.
Examples
--------
>>> np.multiply.reduce([2,3,5])
30
- reduceat(...)
- reduceat(self, array, indices, axis=None, dtype=None, out=None)
Reduceat performs a reduce with specified slices over an axis.
Computes op.reduce(`array[indices[i]:indices[i+1]]`)
for i=0..end with an implicit `indices[i+1]` = len(`array`)
assumed when i = end - 1.
If `indices[i]` >= `indices[i + 1]`
then the result is `array[indices[i]]` for that value.
The function op.accumulate(`array`) is the same as
op.reduceat(`array`, `indices`)[::2]
where `indices` is range(len(`array`)-1) with a zero placed
in every other sample:
`indices` = zeros(len(`array`)*2 - 1)
`indices[1::2]` = range(1, len(`array`))
The output shape is based on the size of `indices`.
Parameters
----------
array : array_like
The array to act on.
indices : array_like
Paired indices specifying slices to reduce.
axis : int, optional
The axis along which to apply the reduceat.
dtype : data-type-code, optional
The type used to represent the intermediate results. Defaults
to the data type of the output array if this is provided, or
the data type of the input array if no output array is provided.
out : ndarray, optional
A location into which the result is stored. If not provided a
freshly-allocated array is returned.
Returns
-------
r : array
The reduced values. If `out` was supplied, `r` is equal to `out`.
Examples
--------
To take the running sum of four successive values:
>>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
array([ 6, 10, 14, 18])
Data descriptors defined here:
- identity
- identity value
- nargs
- number of arguments
- nin
- number of inputs
- nout
- number of outputs
- ntypes
- number of types
- signature
- signature
- types
- return a list with types grouped input->output
|
uint = class uint64(unsignedinteger) |
| |
- Method resolution order:
- uint64
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b500>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
uint0 = class uint64(unsignedinteger) |
| |
- Method resolution order:
- uint64
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b500>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class uint16(unsignedinteger) |
| |
- Method resolution order:
- uint16
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b1c0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class uint32(unsignedinteger) |
| |
- Method resolution order:
- uint32
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b360>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class uint64(unsignedinteger) |
| |
- Method resolution order:
- uint64
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b500>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class uint8(unsignedinteger) |
| |
- Method resolution order:
- uint8
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b020>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
uintc = class uint32(unsignedinteger) |
| |
- Method resolution order:
- uint32
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b360>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
uintp = class uint64(unsignedinteger) |
| |
- Method resolution order:
- uint64
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b500>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
ulonglong = class uint64(unsignedinteger) |
| |
- Method resolution order:
- uint64
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b6a0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
unicode0 = class unicode_(unicode, character) |
| |
- Method resolution order:
- unicode_
- unicode
- basestring
- character
- flexible
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c540>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from unicode:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __format__(...)
- S.__format__(format_spec) -> unicode
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __len__(...)
- x.__len__() <==> len(x)
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- capitalize(...)
- S.capitalize() -> unicode
Return a capitalized version of S, i.e. make the first character
have upper case.
- center(...)
- S.center(width[, fillchar]) -> unicode
Return S centered in a Unicode string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
Unicode string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> string or unicode
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registerd with codecs.register_error that is
able to handle UnicodeDecodeErrors.
- encode(...)
- S.encode([encoding[,errors]]) -> string or unicode
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> unicode
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format(...)
- S.format(*args, **kwargs) -> unicode
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdecimal(...)
- S.isdecimal() -> bool
Return True if there are only decimal characters in S,
False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
- isnumeric(...)
- S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
- isupper(...)
- S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
- join(...)
- S.join(sequence) -> unicode
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> int
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> unicode
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- partition(...)
- S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
- replace(...)
- S.replace (old, new[, count]) -> unicode
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> unicode
Return S right-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- rpartition(...)
- S.rpartition(sep) -> (tail, sep, head)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
- splitlines(...)
- S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- S.strip([chars]) -> unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> unicode
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
- title(...)
- S.title() -> unicode
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
- translate(...)
- S.translate(table) -> unicode
Return a copy of the string S, where all characters have been mapped
through the given translation table, which must be a mapping of
Unicode ordinals to Unicode ordinals, Unicode strings or None.
Unmapped characters are left untouched. Characters mapped to None
are deleted.
- upper(...)
- S.upper() -> unicode
Return a copy of S converted to uppercase.
- zfill(...)
- S.zfill(width) -> unicode
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class unicode_(unicode, character) |
| |
- Method resolution order:
- unicode_
- unicode
- basestring
- character
- flexible
- generic
- object
Methods defined here:
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c540>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from unicode:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __format__(...)
- S.__format__(format_spec) -> unicode
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __len__(...)
- x.__len__() <==> len(x)
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- capitalize(...)
- S.capitalize() -> unicode
Return a capitalized version of S, i.e. make the first character
have upper case.
- center(...)
- S.center(width[, fillchar]) -> unicode
Return S centered in a Unicode string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
Unicode string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> string or unicode
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registerd with codecs.register_error that is
able to handle UnicodeDecodeErrors.
- encode(...)
- S.encode([encoding[,errors]]) -> string or unicode
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> unicode
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format(...)
- S.format(*args, **kwargs) -> unicode
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdecimal(...)
- S.isdecimal() -> bool
Return True if there are only decimal characters in S,
False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
- isnumeric(...)
- S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
- isupper(...)
- S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
- join(...)
- S.join(sequence) -> unicode
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> int
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> unicode
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- partition(...)
- S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
- replace(...)
- S.replace (old, new[, count]) -> unicode
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> unicode
Return S right-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- rpartition(...)
- S.rpartition(sep) -> (tail, sep, head)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
- splitlines(...)
- S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- S.strip([chars]) -> unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> unicode
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
- title(...)
- S.title() -> unicode
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
- translate(...)
- S.translate(table) -> unicode
Return a copy of the string S, where all characters have been mapped
through the given translation table, which must be a mapping of
Unicode ordinals to Unicode ordinals, Unicode strings or None.
Unmapped characters are left untouched. Characters mapped to None
are deleted.
- upper(...)
- S.upper() -> unicode
Return a copy of S converted to uppercase.
- zfill(...)
- S.zfill(width) -> unicode
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __and__(...)
- x.__and__(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
- __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
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __reduce__(...)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class unsignedinteger(integer) |
| |
- Method resolution order:
- unsignedinteger
- integer
- number
- generic
- object
Methods inherited from generic:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(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)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hex__(...)
- x.__hex__() <==> hex(x)
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
ushort = class uint16(unsignedinteger) |
| |
- Method resolution order:
- uint16
- unsignedinteger
- integer
- number
- generic
- object
Methods defined here:
- __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
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33b1c0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- getfield(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setfield(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
|
class void(flexible) |
| |
- Method resolution order:
- void
- flexible
- generic
- object
Methods defined here:
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- getfield(...)
- setfield(...)
Data descriptors defined here:
- dtype
- dtype object
- flags
- integer value of flags
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c6e0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
- 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
|
void0 = class void(flexible) |
| |
- Method resolution order:
- void
- flexible
- generic
- object
Methods defined here:
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- getfield(...)
- setfield(...)
Data descriptors defined here:
- dtype
- dtype object
- flags
- integer value of flags
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object at 0x7f8ebc33c6e0>
- 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
- __and__(...)
- x.__and__(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
- __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
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(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
- __ror__(...)
- x.__ror__(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
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __setstate__(...)
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __xor__(...)
- x.__xor__(y) <==> x^y
- all(...)
- any(...)
- argmax(...)
- argmin(...)
- argsort(...)
- astype(...)
- byteswap(...)
- choose(...)
- clip(...)
- compress(...)
- conj(...)
- conjugate(...)
- copy(...)
- cumprod(...)
- cumsum(...)
- diagonal(...)
- dump(...)
- dumps(...)
- fill(...)
- flatten(...)
- item(...)
- itemset(...)
- max(...)
- mean(...)
- min(...)
- 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:
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
Parameters
----------
new_order : string, 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(...)
- prod(...)
- ptp(...)
- put(...)
- ravel(...)
- repeat(...)
- reshape(...)
- resize(...)
- round(...)
- searchsorted(...)
- setflags(...)
- sort(...)
- squeeze(...)
- std(...)
- sum(...)
- swapaxes(...)
- take(...)
- tofile(...)
- tolist(...)
- tostring(...)
- trace(...)
- transpose(...)
- var(...)
- view(...)
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
- 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
| |