NumPy doc （二）
来源：互联网 发布：中信淘宝v卡金卡积分 编辑：程序博客网 时间：2024/06/10 05:47
class bool_(generic) | Numpy's Boolean type. Character code: ``?``. Alias: bool8 | | Method resolution order: | bool_ | generic | __builtin__.object | | Methods defined here: | | __and__(...) | x.__and__(y) <==> x&y | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __or__(...) | x.__or__(y) <==> x|y | | __rand__(...) | x.__rand__(y) <==> y&x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __xor__(...) | x.__xor__(y) <==> x^y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __oct__(...) | x.__oct__() <==> oct(x) | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class broadcast(__builtin__.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(...) | reset() | | Reset the broadcasted result's iterator(s). | | Parameters | ---------- | None | | Returns | ------- | None | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]] | >>> b = np.broadcast(x, y) | >>> b.index | 0 | >>> b.next(), b.next(), b.next() | ((1, 4), (2, 4), (3, 4)) | >>> b.index | 3 | >>> b.reset() | >>> b.index | 0 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | index | current index in broadcasted result | | Examples | -------- | >>> x = np.array([[1], [2], [3]]) | >>> y = np.array([4, 5, 6]) | >>> b = np.broadcast(x, y) | >>> b.index | 0 | >>> b.next(), b.next(), b.next() | ((1, 4), (1, 5), (1, 6)) | >>> b.index | 3 | | iters | tuple of iterators along ``self``'s "components." | | Returns a tuple of `numpy.flatiter` objects, one for each "component" | of ``self``. | | See Also | -------- | numpy.flatiter | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> row, col = b.iters | >>> row.next(), col.next() | (1, 4) | | nd | Number of dimensions of broadcasted result. | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.nd | 2 | | numiter | Number of iterators possessed by the broadcasted result. | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.numiter | 2 | | shape | Shape of broadcasted result. | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.shape | (3, 3) | | size | Total size of broadcasted result. | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.size | 9 | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T class busdaycalendar(__builtin__.object) | busdaycalendar(weekmask='1111100', holidays=None) | | A business day calendar object that efficiently stores information | defining valid days for the busday family of functions. | | The default valid days are Monday through Friday ("business days"). | A busdaycalendar object can be specified with any set of weekly | valid days, plus an optional "holiday" dates that always will be invalid. | | Once a busdaycalendar object is created, the weekmask and holidays | cannot be modified. | | .. versionadded:: 1.7.0 | | Parameters | ---------- | weekmask : str or array_like of bool, optional | A seven-element array indicating which of Monday through Sunday are | valid days. May be specified as a length-seven list or array, like | [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string | like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for | weekdays, optionally separated by white space. Valid abbreviations | are: Mon Tue Wed Thu Fri Sat Sun | holidays : array_like of datetime64[D], optional | An array of dates to consider as invalid dates, no matter which | weekday they fall upon. Holiday dates may be specified in any | order, and NaT (not-a-time) dates are ignored. This list is | saved in a normalized form that is suited for fast calculations | of valid days. | | Returns | ------- | out : busdaycalendar | A business day calendar object containing the specified | weekmask and holidays values. | | See Also | -------- | is_busday : Returns a boolean array indicating valid days. | busday_offset : Applies an offset counted in valid days. | busday_count : Counts how many valid days are in a half-open date range. | | Attributes | ---------- | Note: once a busdaycalendar object is created, you cannot modify the | weekmask or holidays. The attributes return copies of internal data. | weekmask : (copy) seven-element array of bool | holidays : (copy) sorted array of datetime64[D] | | Examples | -------- | >>> # Some important days in July | ... bdd = np.busdaycalendar( | ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) | >>> # Default is Monday to Friday weekdays | ... bdd.weekmask | array([ True, True, True, True, True, False, False], dtype='bool') | >>> # Any holidays already on the weekend are removed | ... bdd.holidays | array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]') | | Methods defined here: | | __init__(...) | x.__init__(...) initializes x; see help(type(x)) for signature | | ---------------------------------------------------------------------- | Data descriptors defined here: | | holidays | A copy of the holiday array indicating additional invalid days. | | weekmask | A copy of the seven-element boolean mask indicating valid days. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T byte = class int8(signedinteger) | 8-bit integer. Character code ``b``. C char compatible. | | Method resolution order: | int8 | signedinteger | integer | number | generic | __builtin__.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> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | 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 | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __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__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension bytes_ = class string_(__builtin__.str, character) | Method resolution order: | string_ | __builtin__.str | __builtin__.basestring | character | flexible | generic | __builtin__.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> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.str: | | __add__(...) | x.__add__(y) <==> x+y | | __contains__(...) | x.__contains__(y) <==> y in x | | __format__(...) | S.__format__(format_spec) -> string | | Return a formatted version of S as described by format_spec. | | __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) -> string | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | 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(iterable) -> string | | Return a string which is the concatenation of the strings in the | iterable. 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) -> (head, sep, tail) | | 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=False) -> 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 or None. | If the table argument is None, no translation is applied and | the operation simply removes the characters in deletechars. | | 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(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension cdouble = class complex128(complexfloating, __builtin__.complex) | Composed of two 64 bit floats | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | __builtin__.complex | __builtin__.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> | 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 | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __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__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.complex: | | __coerce__(...) | x.__coerce__(y) <==> coerce(x, y) | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getnewargs__(...) | | __hash__(...) | x.__hash__() <==> hash(x) cfloat = class complex128(complexfloating, __builtin__.complex) | Composed of two 64 bit floats | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | __builtin__.complex | __builtin__.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> | 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 | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __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__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.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 | __builtin__.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 | | __format__(...) | NumPy array scalar formatter | | __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__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class chararray(numpy.ndarray) | chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, | strides=None, order=None) | | Provides a convenient view on arrays of string and unicode values. | | .. note:: | The `chararray` class exists for backwards compatibility with | Numarray, it is not recommended for new development. Starting from numpy | 1.4, if one needs arrays of strings, it is recommended to use arrays of | `dtype` `object_`, `string_` or `unicode_`, and use the free functions | in the `numpy.char` module for fast vectorized string operations. | | Versus a regular Numpy array of type `str` or `unicode`, this | class adds the following functionality: | | 1) values automatically have whitespace removed from the end | when indexed | | 2) comparison operators automatically remove whitespace from the | end when comparing values | | 3) vectorized string operations are provided as methods | (e.g. `.endswith`) and infix operators (e.g. ``"+", "*", "%"``) | | chararrays should be created using `numpy.char.array` or | `numpy.char.asarray`, rather than this constructor directly. | | This constructor creates the array, using `buffer` (with `offset` | and `strides`) if it is not ``None``. If `buffer` is ``None``, then | constructs a new array with `strides` in "C order", unless both | ``len(shape) >= 2`` and ``order='Fortran'``, in which case `strides` | is in "Fortran order". | | Methods | ------- | astype | argsort | copy | count | decode | dump | dumps | encode | endswith | expandtabs | fill | find | flatten | getfield | index | isalnum | isalpha | isdecimal | isdigit | islower | isnumeric | isspace | istitle | isupper | item | join | ljust | lower | lstrip | nonzero | put | ravel | repeat | replace | reshape | resize | rfind | rindex | rjust | rsplit | rstrip | searchsorted | setfield | setflags | sort | split | splitlines | squeeze | startswith | strip | swapaxes | swapcase | take | title | tofile | tolist | tostring | translate | transpose | upper | view | zfill | | Parameters | ---------- | shape : tuple | Shape of the array. | itemsize : int, optional | Length of each array element, in number of characters. Default is 1. | unicode : bool, optional | Are the array elements of type unicode (True) or string (False). | Default is False. | buffer : int, optional | Memory address of the start of the array data. Default is None, | in which case a new array is created. | offset : int, optional | Fixed stride displacement from the beginning of an axis? | Default is 0. Needs to be >=0. | strides : array_like of ints, optional | Strides for the array (see `ndarray.strides` for full description). | Default is None. | order : {'C', 'F'}, optional | The order in which the array data is stored in memory: 'C' -> | "row major" order (the default), 'F' -> "column major" | (Fortran) order. | | Examples | -------- | >>> charar = np.chararray((3, 3)) | >>> charar[:] = 'a' | >>> charar | chararray([['a', 'a', 'a'], | ['a', 'a', 'a'], | ['a', 'a', 'a']], | dtype='|S1') | | >>> charar = np.chararray(charar.shape, itemsize=5) | >>> charar[:] = 'abc' | >>> charar | chararray([['abc', 'abc', 'abc'], | ['abc', 'abc', 'abc'], | ['abc', 'abc', 'abc']], | dtype='|S5') | | Method resolution order: | chararray | numpy.ndarray | __builtin__.object | | Methods defined here: | | __add__(self, other) | Return (self + other), that is string concatenation, | element-wise for a pair of array_likes of str or unicode. | | See also | -------- | add | | __array_finalize__(self, obj) | | __eq__(self, other) | Return (self == other) element-wise. | | See also | -------- | equal | | __ge__(self, other) | Return (self >= other) element-wise. | | See also | -------- | greater_equal | | __getitem__(self, obj) | | __gt__(self, other) | Return (self > other) element-wise. | | See also | -------- | greater | | __le__(self, other) | Return (self <= other) element-wise. | | See also | -------- | less_equal | | __lt__(self, other) | Return (self < other) element-wise. | | See also | -------- | less | | __mod__(self, i) | Return (self % i), that is pre-Python 2.6 string formatting | (iterpolation), element-wise for a pair of array_likes of `string_` | or `unicode_`. | | See also | -------- | mod | | __mul__(self, i) | Return (self * i), that is string multiple concatenation, | element-wise. | | See also | -------- | multiply | | __ne__(self, other) | Return (self != other) element-wise. | | See also | -------- | not_equal | | __radd__(self, other) | Return (other + self), that is string concatenation, | element-wise for a pair of array_likes of `string_` or `unicode_`. | | See also | -------- | add | | __rmod__(self, other) | | __rmul__(self, i) | Return (self * i), that is string multiple concatenation, | element-wise. | | See also | -------- | multiply | | argsort(self, axis=-1, kind='quicksort', order=None) | | capitalize(self) | Return a copy of `self` with only the first character of each element | capitalized. | | See also | -------- | char.capitalize | | center(self, width, fillchar=' ') | Return a copy of `self` with its elements centered in a | string of length `width`. | | See also | -------- | center | | count(self, sub, start=0, end=None) | Returns an array with the number of non-overlapping occurrences of | substring `sub` in the range [`start`, `end`]. | | See also | -------- | char.count | | decode(self, encoding=None, errors=None) | Calls `str.decode` element-wise. | | See also | -------- | char.decode | | encode(self, encoding=None, errors=None) | Calls `str.encode` element-wise. | | See also | -------- | char.encode | | endswith(self, suffix, start=0, end=None) | Returns a boolean array which is `True` where the string element | in `self` ends with `suffix`, otherwise `False`. | | See also | -------- | char.endswith | | expandtabs(self, tabsize=8) | Return a copy of each string element where all tab characters are | replaced by one or more spaces. | | See also | -------- | char.expandtabs | | find(self, sub, start=0, end=None) | For each element, return the lowest index in the string where | substring `sub` is found. | | See also | -------- | char.find | | index(self, sub, start=0, end=None) | Like `find`, but raises `ValueError` when the substring is not found. | | See also | -------- | char.index | | isalnum(self) | Returns true for each element if all characters in the string | are alphanumeric and there is at least one character, false | otherwise. | | See also | -------- | char.isalnum | | isalpha(self) | Returns true for each element if all characters in the string | are alphabetic and there is at least one character, false | otherwise. | | See also | -------- | char.isalpha | | isdecimal(self) | For each element in `self`, return True if there are only | decimal characters in the element. | | See also | -------- | char.isdecimal | | isdigit(self) | Returns true for each element if all characters in the string are | digits and there is at least one character, false otherwise. | | See also | -------- | char.isdigit | | islower(self) | Returns true for each element if all cased characters in the | string are lowercase and there is at least one cased character, | false otherwise. | | See also | -------- | char.islower | | isnumeric(self) | For each element in `self`, return True if there are only | numeric characters in the element. | | See also | -------- | char.isnumeric | | isspace(self) | Returns true for each element if there are only whitespace | characters in the string and there is at least one character, | false otherwise. | | See also | -------- | char.isspace | | istitle(self) | Returns true for each element if the element is a titlecased | string and there is at least one character, false otherwise. | | See also | -------- | char.istitle | | isupper(self) | Returns true for each element if all cased characters in the | string are uppercase and there is at least one character, false | otherwise. | | See also | -------- | char.isupper | | join(self, seq) | Return a string which is the concatenation of the strings in the | sequence `seq`. | | See also | -------- | char.join | | ljust(self, width, fillchar=' ') | Return an array with the elements of `self` left-justified in a | string of length `width`. | | See also | -------- | char.ljust | | lower(self) | Return an array with the elements of `self` converted to | lowercase. | | See also | -------- | char.lower | | lstrip(self, chars=None) | For each element in `self`, return a copy with the leading characters | removed. | | See also | -------- | char.lstrip | | partition(self, sep) | Partition each element in `self` around `sep`. | | See also | -------- | partition | | replace(self, old, new, count=None) | For each element in `self`, return a copy of the string with all | occurrences of substring `old` replaced by `new`. | | See also | -------- | char.replace | | rfind(self, sub, start=0, end=None) | For each element in `self`, return the highest index in the string | where substring `sub` is found, such that `sub` is contained | within [`start`, `end`]. | | See also | -------- | char.rfind | | rindex(self, sub, start=0, end=None) | Like `rfind`, but raises `ValueError` when the substring `sub` is | not found. | | See also | -------- | char.rindex | | rjust(self, width, fillchar=' ') | Return an array with the elements of `self` | right-justified in a string of length `width`. | | See also | -------- | char.rjust | | rpartition(self, sep) | Partition each element in `self` around `sep`. | | See also | -------- | rpartition | | rsplit(self, sep=None, maxsplit=None) | For each element in `self`, return a list of the words in | the string, using `sep` as the delimiter string. | | See also | -------- | char.rsplit | | rstrip(self, chars=None) | For each element in `self`, return a copy with the trailing | characters removed. | | See also | -------- | char.rstrip | | split(self, sep=None, maxsplit=None) | For each element in `self`, return a list of the words in the | string, using `sep` as the delimiter string. | | See also | -------- | char.split | | splitlines(self, keepends=None) | For each element in `self`, return a list of the lines in the | element, breaking at line boundaries. | | See also | -------- | char.splitlines | | startswith(self, prefix, start=0, end=None) | Returns a boolean array which is `True` where the string element | in `self` starts with `prefix`, otherwise `False`. | | See also | -------- | char.startswith | | strip(self, chars=None) | For each element in `self`, return a copy with the leading and | trailing characters removed. | | See also | -------- | char.strip | | swapcase(self) | For each element in `self`, return a copy of the string with | uppercase characters converted to lowercase and vice versa. | | See also | -------- | char.swapcase | | title(self) | For each element in `self`, return a titlecased version of the | string: words start with uppercase characters, all remaining cased | characters are lowercase. | | See also | -------- | char.title | | translate(self, table, deletechars=None) | For each element in `self`, return a copy of the string where | all characters occurring in the optional argument | `deletechars` are removed, and the remaining characters have | been mapped through the given translation table. | | See also | -------- | char.translate | | upper(self) | Return an array with the elements of `self` converted to | uppercase. | | See also | -------- | char.upper | | zfill(self, width) | Return the numeric string left-filled with zeros in a string of | length `width`. | | See also | -------- | char.zfill | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(subtype, shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order='C') | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Methods inherited from numpy.ndarray: | | __abs__(...) | x.__abs__() <==> abs(x) | | __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_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __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) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __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 | | __len__(...) | x.__len__() <==> len(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]) | | __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 | | __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) | | __sizeof__(...) | | __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, keepdims=False) | | 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, keepdims=False) | | Returns True if any of the elements of `a` evaluate to 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. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input paramter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | Starting in NumPy 1.9, astype method now returns an error if the string | dtype to cast to is not long enough in 'safe' casting mode to hold the max | value of integer/float array that is being casted. Previously the casting | was allowed even if the result was truncated. | | Raises | ------ | ComplexWarning | When casting from complex to float or int. To avoid this, | one should use ``a.real.astype(t)``. | | 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(min=None, max=None, out=None) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | 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() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:numpy.copy are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | 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. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | NumPy 1.10 the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[ 2., 2.], | [ 2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[ 8., 8.], | [ 8., 8.]]) | | 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. | | Parameters | ---------- | None | | fill(...) | a.fill(value) | | Fill the array with a scalar value. | | Parameters | ---------- | 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', 'A'}, optional | Whether to flatten in row-major (C-style) or | column-major (Fortran-style) order or preserve the | C/Fortran ordering from `a`. 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=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[ 1.+1.j, 0.+0.j], | [ 0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[ 1., 0.], | [ 0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[ 1., 0.], | [ 0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[3, 1, 7], | [2, 8, 3], | [8, 5, 3]]) | >>> x.item(3) | 2 | >>> x.item(7) | 5 | >>> x.item((0, 1)) | 1 | >>> x.item((2, 2)) | 3 | | itemset(...) | a.itemset(*args) | | Insert scalar into an array (scalar is cast to array's dtype, if possible) | | There must be at least 1 argument, and define the last argument | as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster | than ``a[args] = item``. The item should be a scalar value and `args` | must select a single item in the array `a`. | | Parameters | ---------- | \*args : Arguments | If one argument: a scalar, only used in case `a` is of size 1. | If two arguments: the last argument is the value to be set | and must be a scalar, the first argument specifies a single array | element location. It is either an int or a tuple. | | Notes | ----- | Compared to indexing syntax, `itemset` provides some speed increase | for placing a scalar into a particular location in an `ndarray`, | if you must do this. However, generally this is discouraged: | among other problems, it complicates the appearance of the code. | Also, when using `itemset` (and `item`) inside a loop, be sure | to assign the methods to a local variable to avoid the attribute | look-up at each loop iteration. | | Examples | -------- | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[3, 1, 7], | [2, 8, 3], | [8, 5, 3]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[3, 1, 7], | [2, 0, 3], | [8, 5, 9]]) | | 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, keepdims=False) | | 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, keepdims=False) | | 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 | below. `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, keepdims=False) | | 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) | | Change shape and size of array in-place. | | Parameters | ---------- | new_shape : tuple of ints, or `n` ints | Shape of resized array. | refcheck : bool, optional | If False, reference count will not be checked. Default is True. | | Returns | ------- | None | | Raises | ------ | ValueError | If `a` does not own its own data or references or views to it exist, | and the data memory must be changed. | | SystemError | If the `order` keyword argument is specified. This behaviour is a | bug in NumPy. | | See Also | -------- | resize : Return a new array with the specified shape. | | Notes | ----- | This reallocates space for the data area if necessary. | | Only contiguous arrays (data elements consecutive in memory) can be | resized. | | The purpose of the reference count check is to make sure you | do not use this array as a buffer for another Python object and then | reallocate the memory. However, reference counts can increase in | other ways so if you are sure that you have not shared the memory | for this array with another Python object, then you may safely set | `refcheck` to False. | | Examples | -------- | Shrinking an array: array is flattened (in the order that the data are | stored in memory), resized, and reshaped: | | >>> a = np.array([[0, 1], [2, 3]], order='C') | >>> a.resize((2, 1)) | >>> a | array([[0], | [1]]) | | >>> a = np.array([[0, 1], [2, 3]], order='F') | >>> a.resize((2, 1)) | >>> a | array([[0], | [2]]) | | Enlarging an array: as above, but missing entries are filled with zeros: | | >>> b = np.array([[0, 1], [2, 3]]) | >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple | >>> 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 ... | | Unless `refcheck` is False: | | >>> a.resize((1, 1), refcheck=False) | >>> a | array([[0]]) | >>> c | array([[0]]) | | round(...) | a.round(decimals=0, out=None) | | Return `a` with each element rounded 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', sorter=None) | | 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(...) | a.setfield(val, dtype, offset=0) | | Put a value into a specified place in a field defined by a data-type. | | Place `val` into `a`'s field defined by `dtype` and beginning `offset` | bytes into the field. | | Parameters | ---------- | val : object | Value to be placed in field. | dtype : dtype object | Data-type of the field in which to place `val`. | offset : int, optional | The number of bytes into the field at which to place `val`. | | Returns | ------- | None | | See Also | -------- | getfield | | Examples | -------- | >>> x = np.eye(3) | >>> x.getfield(np.float64) | array([[ 1., 0., 0.], | [ 0., 1., 0.], | [ 0., 0., 1.]]) | >>> x.setfield(3, np.int32) | >>> x.getfield(np.int32) | array([[3, 3, 3], | [3, 3, 3], | [3, 3, 3]]) | >>> x | array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], | [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], | [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) | >>> x.setfield(np.eye(3), np.int32) | >>> x | array([[ 1., 0., 0.], | [ 0., 1., 0.], | [ 0., 0., 1.]]) | | setflags(...) | a.setflags(write=None, align=None, uic=None) | | Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. | | These Boolean-valued flags affect how numpy interprets the memory | area used by `a` (see Notes below). The ALIGNED flag can only | be set to True if the data is actually aligned according to the type. | The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE | can only be set to True if the array owns its own memory, or the | ultimate owner of the memory exposes a writeable buffer interface, | or is a string. (The exception for string is made so that unpickling | can be done without copying memory.) | | Parameters | ---------- | write : bool, optional | Describes whether or not `a` can be written to. | align : bool, optional | Describes whether or not `a` is aligned properly for its type. | uic : bool, optional | Describes whether or not `a` is a copy of another "base" array. | | Notes | ----- | Array flags provide information about how the memory area used | for the array is to be interpreted. There are 6 Boolean flags | in use, only three of which can be changed by the user: | UPDATEIFCOPY, WRITEABLE, and ALIGNED. | | WRITEABLE (W) the data area can be written to; | | ALIGNED (A) the data and strides are aligned appropriately for the hardware | (as determined by the compiler); | | UPDATEIFCOPY (U) this array is a copy of some other array (referenced | by .base). When this array is deallocated, the base array will be | updated with the contents of this array. | | All flags can be accessed using their first (upper case) letter as well | as the full name. | | Examples | -------- | >>> y | array([[3, 1, 7], | [2, 0, 0], | [8, 5, 9]]) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : True | ALIGNED : True | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set UPDATEIFCOPY flag to True | | 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 : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | 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. | partition: Partial sort. | | 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(axis=None) | | 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, keepdims=False) | | 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, keepdims=False) | | 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 | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]]) | >>> x.tobytes() | b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str | An open file object, or a string containing a filename. | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness 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 endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | 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 Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings. | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]]) | >>> x.tobytes() | b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00' | | 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 the array with axes transposed. | | For a 1-D array, this has no effect. (To change between column and | row vectors, first cast the 1-D array into a matrix object.) | For a 2-D array, this is the usual matrix transpose. | For an n-D array, if axes are given, their order indicates how the | axes are permuted (see Examples). If axes are not provided and | ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then | ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``. | | Parameters | ---------- | axes : None, tuple of ints, or `n` ints | | * None or no argument: reverses the order of the axes. | | * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s | `i`-th axis becomes `a.transpose()`'s `j`-th axis. | | * `n` ints: same as an n-tuple of the same ints (this form is | intended simply as a "convenience" alternative to the tuple form) | | Returns | ------- | out : ndarray | View of `a`, with axes suitably 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, keepdims=False) | | 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 or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. The | default, None, results in the view having the same data-type as `a`. | This argument can also be specified as an ndarray sub-class, which | then specifies the type of the returned object (this is equivalent to | setting the ``type`` parameter). | type : Python type, optional | Type of the returned view, e.g., ndarray or matrix. Again, the | default None results in type preservation. | | Notes | ----- | ``a.view()`` is used two different ways: | | ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view | of the array's memory with a different data-type. This can cause a | reinterpretation of the bytes of memory. | | ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just | returns an instance of `ndarray_subclass` that looks at the same array | (same shape, dtype, etc.) This does not cause a reinterpretation of the | memory. | | For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of | bytes per entry than the previous dtype (for example, converting a | regular array to a structured array), then the behavior of the view | cannot be predicted just from the superficial appearance of ``a`` (shown | by ``print(a)``). It also depends on exactly how ``a`` is stored in | memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus | defined as a slice or transpose, etc., the view may give different | results. | | | 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) | >>> y | matrix([[513]], dtype=int16) | >>> print type(y) | <class 'numpy.matrixlib.defmatrix.matrix'> | | Creating a view on a structured array so it can be used in calculations | | >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)]) | >>> xv = x.view(dtype=np.int8).reshape(-1,2) | >>> xv | array([[1, 2], | [3, 4]], dtype=int8) | >>> xv.mean(0) | array([ 2., 3.]) | | Making changes to the view changes the underlying array | | >>> xv[0,1] = 20 | >>> print x | [(1, 20) (3, 4)] | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1], dtype=int8) | | Views share data: | | >>> x[0] = (9, 10) | >>> z[0] | (9, 10) | | Views that change the dtype size (bytes per entry) should normally be | avoided on arrays defined by slices, transposes, fortran-ordering, etc.: | | >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16) | >>> y = x[:, 0:2] | >>> y | array([[1, 2], | [4, 5]], dtype=int16) | >>> y.view(dtype=[('width', np.int16), ('length', np.int16)]) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: new type not compatible with array. | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from numpy.ndarray: | | T | Same as self.transpose(), except that self is returned if | self.ndim < 2. | | Examples | -------- | >>> x = np.array([[1.,2.],[3.,4.]]) | >>> x | array([[ 1., 2.], | [ 3., 4.]]) | >>> x.T | array([[ 1., 3.], | [ 2., 4.]]) | >>> x = np.array([1.,2.,3.,4.]) | >>> x | array([ 1., 2., 3., 4.]) | >>> x.T | array([ 1., 2., 3., 4.]) | | __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 | -------- | The base of an array that owns its memory is None: | | >>> x = np.array([1,2,3,4]) | >>> x.base is None | True | | Slicing creates a view, whose memory is shared with x: | | >>> y = x[2:] | >>> y.base is x | True | | ctypes | An object to simplify the interaction of the array with the ctypes | module. | | This attribute creates an object that makes it easier to use arrays | when calling shared libraries with the ctypes module. The returned | object has, among others, data, shape, and strides attributes (see | Notes below) which themselves return ctypes objects that can be used | as arguments to a shared library. | | Parameters | ---------- | None | | Returns | ------- | c : Python object | Possessing attributes data, shape, strides, etc. | | See Also | -------- | numpy.ctypeslib | | Notes | ----- | Below are the public attributes of this object which were documented | in "Guide to NumPy" (we have omitted undocumented public attributes, | as well as documented private attributes): | | * data: A pointer to the memory area of the array as a Python integer. | This memory area may contain data that is not aligned, or not in correct | byte-order. The memory area may not even be writeable. The array | flags and data-type of this array should be respected when passing this | attribute to arbitrary C-code to avoid trouble that can include Python | crashing. User Beware! The value of this attribute is exactly the same | as self._array_interface_['data'][0]. | | * shape (c_intp*self.ndim): A ctypes array of length self.ndim where | the basetype is the C-integer corresponding to dtype('p') on this | platform. This base-type could be c_int, c_long, or c_longlong | depending on the platform. The c_intp type is defined accordingly in | numpy.ctypeslib. The ctypes array contains the shape of the underlying | array. | | * strides (c_intp*self.ndim): A ctypes array of length self.ndim where | the basetype is the same as for the shape attribute. This ctypes array | contains the strides information from the underlying array. This strides | information is important for showing how many bytes must be jumped to | get to the next element in the array. | | * data_as(obj): Return the data pointer cast to a particular c-types object. | For example, calling self._as_parameter_ is equivalent to | self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a | pointer to a ctypes array of floating-point data: | self.data_as(ctypes.POINTER(ctypes.c_double)). | | * shape_as(obj): Return the shape tuple as an array of some other c-types | type. For example: self.shape_as(ctypes.c_short). | | * strides_as(obj): Return the strides tuple as an array of some other | c-types type. For example: self.strides_as(ctypes.c_longlong). | | Be careful using the ctypes attribute - especially on temporary | arrays or arrays constructed on the fly. For example, calling | ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory | that is invalid because the array created as (a+b) is deallocated | before the next Python statement. You can avoid this problem using | either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will | hold a reference to the array until ct is deleted or re-assigned. | | If the ctypes module is not available, then the ctypes attribute | of array objects still returns something useful, but ctypes objects | are not returned and errors may be raised instead. In particular, | the object will still have the as parameter attribute which will | return an integer equal to the data attribute. | | Examples | -------- | >>> import ctypes | >>> x | array([[0, 1], | [2, 3]]) | >>> x.ctypes.data | 30439712 | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) | <ctypes.LP_c_long object at 0x01F01300> | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents | c_long(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents | c_longlong(4294967296L) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x01FFD580> | >>> x.ctypes.shape_as(ctypes.c_long) | <numpy.core._internal.c_long_Array_2 object at 0x01FCE620> | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x01FCE620> | >>> x.ctypes.strides_as(ctypes.c_longlong) | <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300> | | data | Python buffer object pointing to the start of the array's data. | | dtype | Data-type of the array's elements. | | Parameters | ---------- | None | | Returns | ------- | d : numpy dtype object | | See Also | -------- | numpy.dtype | | Examples | -------- | >>> x | array([[0, 1], | [2, 3]]) | >>> x.dtype | dtype('int32') | >>> type(x.dtype) | <type 'numpy.dtype'> | | 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. Setting this to False locks | the data, making it read-only. A view (slice, etc.) inherits WRITEABLE | from its base array at creation time, but a view of a writeable | array may be subsequently locked while the base array remains writeable. | (The opposite is not true, in that a view of a locked array may not | be made writeable. However, currently, locking a base object does not | lock any views that already reference it, so under that circumstance it | is possible to alter the contents of a locked array via a previously | created writeable view onto it.) Attempting to change a non-writeable | array raises a RuntimeError exception. | ALIGNED (A) | The data and all elements 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 accessed dictionary-like (as in ``a.flags['WRITEABLE']``), | or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag | names are only supported in dictionary access. | | Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by | the user, via direct assignment to the attribute or dictionary entry, | or by calling `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. | | Arrays can be both C-style and Fortran-style contiguous simultaneously. | This is clear for 1-dimensional arrays, but can also be true for higher | dimensional arrays. | | Even for contiguous arrays a stride for a given dimension | ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1`` | or the array has no elements. | It does *not* generally hold that ``self.strides[-1] == self.itemsize`` | for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for | Fortran-style contiguous arrays is true. | | flat | A 1-D iterator over the array. | | This is a `numpy.flatiter` instance, which acts similarly to, but is not | a subclass of, Python's built-in iterator object. | | 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'> | | An assignment example: | | >>> x.flat = 3; x | array([[3, 3, 3], | [3, 3, 3]]) | >>> x.flat[[1,4]] = 1; x | array([[3, 1, 3], | [3, 1, 3]]) | | 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 array 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 | Total bytes consumed by the elements of the array. | | Notes | ----- | Does not include memory consumed by non-element attributes of the | array object. | | 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. | | Notes | ----- | May be used to "reshape" the array, as long as this would not | require a change in the total number of elements | | Examples | -------- | >>> x = np.array([1, 2, 3, 4]) | >>> x.shape | (4,) | >>> y = np.zeros((2, 3, 4)) | >>> y.shape | (2, 3, 4) | >>> y.shape = (3, 8) | >>> y | array([[ 0., 0., 0., 0., 0., 0., 0., 0.], | [ 0., 0., 0., 0., 0., 0., 0., 0.], | [ 0., 0., 0., 0., 0., 0., 0., 0.]]) | >>> y.shape = (3, 6) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: total size of new array must be unchanged | | size | Number of elements in the array. | | Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> 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 inherited from numpy.ndarray: | | __hash__ = None clongdouble = class complex128(complexfloating) | Composed of two 64 bit floats | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | __builtin__.object | | Methods defined here: | | __complex__(...) | | __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> | 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 | | __format__(...) | NumPy array scalar formatter | | __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__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension clongfloat = class complex128(complexfloating) | Composed of two 64 bit floats | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | __builtin__.object | | Methods defined here: | | __complex__(...) | | __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> | 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 | | __format__(...) | NumPy array scalar formatter | | __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__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension 0 0
- NumPy doc （二）
- NumPy doc （一）
- NumPy doc （三）
- NumPy doc（四）
- NumPy doc （五）
- NumPy doc （六）
- NumPy doc (七）
- NumPy使用（二）
- numpy实用技巧（二）
- NumPy学习（二）
- Numpy（二）
- Numpy学习（二）
- numpy 常用api（二）
- NumPy学习笔记（二）
- numpy学习日记（二）
- numpy的用法（二）
- NumPy教程之（二）
- numpy快速入门教程（二）
- 第七章 评估推理关系（一）
- [Java并发包学习八]深度剖析ConcurrentHashMap
- VS远程调试器(MSVSMON.EXE)似乎没有在远程计算机上运行，解决办法之云服务器版
- 大话设计模式，让你的代码更完美7---外观模式
- RPC原理
- NumPy doc （二）
- MFC创建主对话框为非模态对话框
- 2.http dns
- Caffe 训练遇到的问题
- Java中的多态性理解(注意与C++区分)
- FlowNet: Learning Optical Flow with Convolutional Networks
- sql查询作业-保单涉及表的复杂查询
- 实验六—【项目一：数组操作】
- log4j 格式详解
