Python Numpy入门基础(一)创建数组

这篇具有很好参考价值的文章主要介绍了Python Numpy入门基础(一)创建数组。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Python Numpy入门基础(一)创建数组,Python,python,numpy,开发语言

入门基础(一)

创建数组

1- np.array()

参数众多,初学时只要关注基本用法。

array(...)
    array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,
          like=None)
    
    Create an array.
    
    Parameters
    ----------
    object : array_like
        An array, any object exposing the array interface, an object whose
        __array__ method returns an array, or any (nested) sequence.
    dtype : data-type, optional
        The desired data-type for the array.  If not given, then the type will
        be determined as the minimum type required to hold the objects in the
        sequence.
    copy : bool, optional
        If true (default), then the object is copied.  Otherwise, a copy will
        only be made if __array__ returns a copy, if obj is a nested sequence,
        or if a copy is needed to satisfy any of the other requirements
        (`dtype`, `order`, etc.).
    order : {'K', 'A', 'C', 'F'}, optional
        Specify the memory layout of the array. If object is not an array, the
        newly created array will be in C order (row major) unless 'F' is
        specified, in which case it will be in Fortran order (column major).
        If object is an array the following holds.
    
        ===== ========= ===================================================
        order  no copy                     copy=True
        ===== ========= ===================================================
        'K'   unchanged F & C order preserved, otherwise most similar order
        'A'   unchanged F order if input is F and not C, otherwise C order
        'C'   C order   C order
        'F'   F order   F order
        ===== ========= ===================================================
    
        When ``copy=False`` and a copy is made for other reasons, the result is
        the same as if ``copy=True``, with some exceptions for 'A', see the
        Notes section. The default order is 'K'.
    subok : bool, optional
        If True, then sub-classes will be passed-through, otherwise
        the returned array will be forced to be a base-class array (default).
    ndmin : int, optional
        Specifies the minimum number of dimensions that the resulting
        array should have.  Ones will be pre-pended to the shape as
        needed to meet this requirement.
    like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.
    
        .. versionadded:: 1.20.0

元组、列表转换

>>> import numpy as np
>>> np.array((1,2,3))
array([1, 2, 3])
>>> np.array([3,2,3])
array([3, 2, 3])
>>> np.array([[3,2,3],[4,5,6]])
array([[3, 2, 3],
       [4, 5, 6]])

内置函数 range()

>>> import numpy as np
>>> np.array(range(5))
array([0, 1, 2, 3, 4])
>>> np.array(range(2,11,2))
array([ 2,  4,  6,  8, 10])
>>> np.array([range(1,5),range(5,9)])
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

数组副本copy,开辟一块新内存复制原数组

>>> import numpy as np
>>> a = np.array([1,2,3])
>>> b = np.array(a)
>>> b
array([1, 2, 3])
>>> a[0] = 3
>>> a,b
(array([3, 2, 3]), array([1, 2, 3]))

主要参数:
dtype=     数组元素的数据类型,可选
copy=      对象是否需要复制,可选
order=     创建数组的样式,C为行方向,F为列方向,A为任意方向(默认)
subok=    默认返回一个与基类类型一致的数组
ndmin=    指定生成数组的最小维度

>>> import numpy as np
>>> np.array([[1, 2, 3, 4]], dtype=float)
array([[1., 2., 3., 4.]])
>>> np.array([[1, 2], [3, 4]], dtype=complex)
array([[1.+0.j, 2.+0.j],
       [3.+0.j, 4.+0.j]])
>>> np.array([[1, 2, 3, 4]], dtype=np.int64)
array([[1, 2, 3, 4]], dtype=int64)
>>> np.array({1, 2, 3, 4})
array({1, 2, 3, 4}, dtype=object)
>>> np.array({1, 2, 3, 4}).dtype
dtype('O') #集合只能作一个整体,大写字母O,即object
>>> np.array([[1, 2, 3, 4]], dtype=np.int64).dtype
dtype('int64')
>>> np.array([[1, 2], [3, 4, 5]])
array([list([1, 2]), list([3, 4, 5])], dtype=object)
>>> np.array([[1, 2], [3, 4, 5]]).dtype
dtype('O')
>>> 

>>> np.array([1, 2, 3, 4, 5], ndmin =  1)
array([1, 2, 3, 4, 5])
>>> np.array([1, 2, 3, 4, 5], ndmin =  2)
array([[1, 2, 3, 4, 5]])
>>> np.array([1, 2, 3, 4, 5], ndmin =  3)
array([[[1, 2, 3, 4, 5]]])
>>>

2.1- 基本属性 .shape  .ndim .dtype .size等

>>> a = np.array(range(2,11,2))
>>> b = np.array([range(1,5),range(5,9)])
>>> a.shape
(5,)
>>> b.shape
(2, 4)
>>> a.ndim, b.ndim
(1, 2)
>>> np.array(1)
array(1)
>>> np.array(1).ndim
0 #常数为0维
>>> a.dtype.name, b.dtype.name
('int32', 'int32')
>>> a.size, b.size
(5, 8)
>>> type(a), type(b)
(<class 'numpy.ndarray'>, <class 'numpy.ndarray'>)
>>> a
array([ 2,  4,  6,  8, 10])
>>> b
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
>>> print(a)
[ 2  4  6  8 10]
>>> print(b)
[[1 2 3 4]
 [5 6 7 8]]

.ndim      秩,即轴的数量或维度的数量
.shape    数组的维度,对于矩阵,n 行 m 列
.size       数组元素的总个数,相当于 .shape 中 n*m 的值
.dtype     对象的元素类型
.itemsize     对象中每个元素的大小,以字节为单位
.flags      对象的内存信息
.real       元素的实部
.imag     元素的虚部
.data      包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。 

2.2- 与属性同名的方法

除.itemsize .flags .data外者有同名方法,其它有方法的参数都为ndarray,dtype()除外。

>>> a = np.array([*range(5)],dtype=complex)
>>> np.ndim(a)
1
>>> np.shape(a)
(5,)
>>> np.size(a)
5
>>> np.real(a)
array([0., 1., 2., 3., 4.])
>>> np.imag(a)
array([0., 0., 0., 0., 0.])
>>> np.dtype(int)
dtype('int32')
>>> np.dtype(complex)
dtype('complex128')
>>> np.dtype(float)
dtype('float64')
>>> a.itemsize
16
>>> a.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

>>> a.data
<memory at 0x0000000002D79DC0>

3- np.arange()

arange(...)
    arange([start,] stop[, step,], dtype=None, *, like=None)
    
    Return evenly spaced values within a given interval.
    
    Values are generated within the half-open interval ``[start, stop)``
    (in other words, the interval including `start` but excluding `stop`).
    For integer arguments the function is equivalent to the Python built-in
    `range` function, but returns an ndarray rather than a list.
    
    When using a non-integer step, such as 0.1, the results will often not
    be consistent.  It is better to use `numpy.linspace` for these cases.
    
    Parameters
    ----------
    start : integer or real, optional
        Start of interval.  The interval includes this value.  The default
        start value is 0.
    stop : integer or real
        End of interval.  The interval does not include this value, except
        in some cases where `step` is not an integer and floating point
        round-off affects the length of `out`.
    step : integer or real, optional
        Spacing between values.  For any output `out`, this is the distance
        between two adjacent values, ``out[i+1] - out[i]``.  The default
        step size is 1.  If `step` is specified as a position argument,
        `start` must also be given.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, infer the data
        type from the other input arguments.
    like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.
    
        .. versionadded:: 1.20.0

np.arange() 与 np.array(range()) 类似,但前者允许用浮点数

>>> np.arange(12)
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> np.arange(0,1.1,0.1)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
>>> np.arange(2,5,0.3)
array([2. , 2.3, 2.6, 2.9, 3.2, 3.5, 3.8, 4.1, 4.4, 4.7])

4- np.reshape()

reshape(a, newshape, order='C')
    Gives a new shape to an array without changing its data.
    
    Parameters
    ----------
    a : array_like
        Array to be reshaped.
    newshape : int or tuple of ints
        The new shape should be compatible with the original shape. If
        an integer, then the result will be a 1-D array of that length.
        One shape dimension can be -1. In this case, the value is
        inferred from the length of the array and remaining dimensions.
    order : {'C', 'F', 'A'}, optional
        Read the elements of `a` using this index order, and place the
        elements into the reshaped array using this index order.  'C'
        means to read / write the elements using C-like index order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest. 'F' means to read / write the
        elements using Fortran-like index order, with the first index
        changing fastest, and the last index changing slowest. Note that
        the 'C' and 'F' options take no account of the memory layout of
        the underlying array, and only refer to the order of indexing.
        'A' means to read / write the elements in Fortran-like index
        order if `a` is Fortran *contiguous* in memory, C-like order
        otherwise.
    
    Returns
    -------
    reshaped_array : ndarray
        This will be a new view object if possible; otherwise, it will
        be a copy.  Note there is no guarantee of the *memory layout* (C- or
        Fortran- contiguous) of the returned array.
>>> a = np.arange(8)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> np.reshape(a,(2,4))
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> np.reshape(a,(4,2))
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])
>>> np.reshape(a,(8,1))
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [7]])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> a.reshape(2,4)
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> a.reshape(4,2)
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7])

5- 数据类型

dtype对应的类型除了内置的int,float,complex等,可以用 np.bool_, np.int8, np.uint64:

bool_    布尔型数据类型(True 或者 False)
int_    默认的整数类型(类似于 C 语言中的 long,int32 或 int64)
intc    与 C 的 int 类型一样,一般是 int32 或 int 64
intp    用于索引的整数类型(类似于 C 的 ssize_t,一般情况下仍然是 int32 或 int64)
int8    字节(-128 to 127)
int16    整数(-32768 to 32767)
int32    整数(-2147483648 to 2147483647)
int64    整数(-9223372036854775808 to 9223372036854775807)
uint8    无符号整数(0 to 255)
uint16    无符号整数(0 to 65535)
uint32    无符号整数(0 to 4294967295)
uint64    无符号整数(0 to 18446744073709551615)
float_    float64 类型的简写
float16    半精度浮点数,包括:1 个符号位,5 个指数位,10 个尾数位
float32    单精度浮点数,包括:1 个符号位,8 个指数位,23 个尾数位
float64    双精度浮点数,包括:1 个符号位,11 个指数位,52 个尾数位
complex_    complex128 类型的简写,即 128 位复数
complex64    复数,表示双 32 位浮点数(实数部分和虚数部分)
complex128    复数,表示双 64 位浮点数(实数部分和虚数部分)

每个内建类型都有一个唯一定义它的字符代码:

b    布尔型
i    (有符号) 整型
u    无符号整型 integer
f    浮点型
c    复数浮点型
m    timedelta(时间间隔)
M    datetime(日期时间)
O    (Python) 对象
S, a    (byte-)字符串
U    Unicode
V    原始数据 (void)

int8, int16, int32, int64 -- i1, i2, i4, i8
uint8,uint16,uint32,uint64 -- u1, u2, u4, u8
float16,float32,float64,float128 -- f2, f4, f8, f16
或: float32,float64,float128 -- f, d, g
complex64,complex128,complex256 -- c8,c16,c32
bool -- ?

>>> import numpy as np
>>> np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
dtype([('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
>>> import numpy as np
>>> student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
>>> student
dtype([('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
>>> np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
array([(b'abc', 21, 50.), (b'xyz', 18, 75.)],
      dtype=[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
>>> a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
>>> print(a)
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]

6- np.asarray()

asarray(...)
    asarray(a, dtype=None, order=None, *, like=None)
    
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F', 'A', 'K'}, optional
        Memory layout.  'A' and 'K' depend on the order of input array a.
        'C' row-major (C-style),
        'F' column-major (Fortran-style) memory representation.
        'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
        'K' (keep) preserve input order
        Defaults to 'C'.
    like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.
    
        .. versionadded:: 1.20.0
>>> import numpy as np
>>> a = np.array([1,2,3])
>>> b = np.asarray(a)
>>> a,b
(array([1, 2, 3]), array([1, 2, 3]))
>>> a[0]=3
>>> a,b
(array([3, 2, 3]), array([3, 2, 3]))

注意 b=asarray(a)  与 b=array(a) 的区别,前者两数组指向同一内存地址。

7- np.fromiter()

fromiter(...)
    fromiter(iter, dtype, count=-1, *, like=None)
    
    Create a new 1-dimensional array from an iterable object.
    
    Parameters
    ----------
    iter : iterable object
        An iterable object providing data for the array.
    dtype : data-type
        The data-type of the returned array.
    count : int, optional
        The number of items to read from *iterable*.  The default is -1,
        which means all data is read.
    like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.
    
        .. versionadded:: 1.20.0
    
    Returns
    -------
    out : ndarray
        The output array.
    
    Notes
    -----
    Specify `count` to improve performance.  It allows ``fromiter`` to
    pre-allocate the output array, instead of resizing it on demand.
>>> import numpy as np
>>> np.fromiter(range(5),dtype=int)
array([0, 1, 2, 3, 4])
>>> np.fromiter(range(5),dtype=float)
array([0., 1., 2., 3., 4.])
>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable, float)
array([ 0.,  1.,  4.,  9., 16.])
>>> np.fromiter({1,2,3,4}, float)
array([1., 2., 3., 4.])
>>> np.array({1,2,3,4})
array({1, 2, 3, 4}, dtype=object)
#注意:array()不能从集合中取出元素,只能作为一个整体
>>> np.fromiter('Hann Yang',dtype='S1')
array([b'H', b'a', b'n', b'n', b' ', b'Y', b'a', b'n', b'g'], dtype='|S1')
>>> np.fromiter(b'Hann Yang',dtype=np.uint8)
array([ 72,  97, 110, 110,  32,  89,  97, 110, 103], dtype=uint8)
#注意:字节串b''与字符串str的区别

8- np.frombuffer()

流的形式读入转化成 ndarray 对象,还可以分批读入。

frombuffer(...)
    frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)
    
    Interpret a buffer as a 1-dimensional array.
    
    Parameters
    ----------
    buffer : buffer_like
        An object that exposes the buffer interface.
    dtype : data-type, optional
        Data-type of the returned array; default: float.
    count : int, optional
        Number of items to read. ``-1`` means all data in the buffer.
    offset : int, optional
        Start reading the buffer from this offset (in bytes); default: 0.
    like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.
    
        .. versionadded:: 1.20.0
>>> np.frombuffer('Hann Yang',dtype='S1')
Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    np.frombuffer('Hann Yang',dtype='S1')
TypeError: a bytes-like object is required, not 'str'
>>> np.frombuffer(b'Hann Yang',dtype='S1')
array([b'H', b'a', b'n', b'n', b' ', b'Y', b'a', b'n', b'g'], dtype='|S1')
>>> np.frombuffer(b'Hann Yang',dtype=int)
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    np.frombuffer(b'Hann Yang',dtype=int)
ValueError: buffer size must be a multiple of element size
>>> np.frombuffer(b'Hann Yang',dtype=np.uint8)
array([ 72,  97, 110, 110,  32,  89,  97, 110, 103], dtype=uint8)
>>> np.frombuffer(b'Hann Yang',dtype='S1')
array([b'H', b'a', b'n', b'n', b' ', b'Y', b'a', b'n', b'g'], dtype='|S1')
>>> np.frombuffer(b'Hann Yang',dtype=np.uint8)
array([ 72,  97, 110, 110,  32,  89,  97, 110, 103], dtype=uint8)
>>> np.frombuffer(b'Hann Yang',dtype=np.uint8,count=4)
array([ 72,  97, 110, 110], dtype=uint8)
>>> np.frombuffer(b'Hann Yang',dtype=np.uint8,count=4,offset=4)
array([ 32,  89,  97, 110], dtype=uint8)
>>> np.frombuffer(b'Hann Yang',dtype=np.uint8,count=-1,offset=8)
array([103], dtype=uint8)

9.1- np.linspace()

以等差数列创建数组

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
    Return evenly spaced numbers over a specified interval.
    
    Returns `num` evenly spaced samples, calculated over the
    interval [`start`, `stop`].
    
    The endpoint of the interval can optionally be excluded.
    
    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.
    
    .. versionchanged:: 1.20.0
        Values are rounded towards ``-inf`` instead of ``0`` when an
        integer ``dtype`` is specified. The old behavior can
        still be obtained with ``np.linspace(start, stop, num).astype(int)``
    
    Parameters
    ----------
    start : array_like
        The starting value of the sequence.
    stop : array_like
        The end value of the sequence, unless `endpoint` is set to False.
        In that case, the sequence consists of all but the last of ``num + 1``
        evenly spaced samples, so that `stop` is excluded.  Note that the step
        size changes when `endpoint` is False.
    num : int, optional
        Number of samples to generate. Default is 50. Must be non-negative.
    endpoint : bool, optional
        If True, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    retstep : bool, optional
        If True, return (`samples`, `step`), where `step` is the spacing
        between samples.
    dtype : dtype, optional
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred dtype will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.
    
        .. versionadded:: 1.9.0
    
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.
    
        .. versionadded:: 1.16.0

创建区间可以是全开区间,也可以前开后闭区间。 

>>> np.linspace(2.0, 3.0, num=5)
array([2.  , 2.25, 2.5 , 2.75, 3.  ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([2. ,  2.2,  2.4,  2.6,  2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
>>> np.linspace(1, 1, 10, dtype=int)
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

9.2- np.logspace() 

以对数数列创建数组

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
    Return numbers spaced evenly on a log scale.
    
    In linear space, the sequence starts at ``base ** start``
    (`base` to the power of `start`) and ends with ``base ** stop``
    (see `endpoint` below).
    
    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.
    
    Parameters
    ----------
    start : array_like
        ``base ** start`` is the starting value of the sequence.
    stop : array_like
        ``base ** stop`` is the final value of the sequence, unless `endpoint`
        is False.  In that case, ``num + 1`` values are spaced over the
        interval in log-space, of which all but the last (a sequence of
        length `num`) are returned.
    num : integer, optional
        Number of samples to generate.  Default is 50.
    endpoint : boolean, optional
        If true, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    base : array_like, optional
        The base of the log space. The step size between the elements in
        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
        Default is 10.0.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred type will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.
    
        .. versionadded:: 1.16.0
>>> np.logspace(2.0, 3.0, num=4)
array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
>>> np.logspace(2.0, 3.0, num=4, endpoint=False)
array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
>>> np.logspace(2.0, 3.0, num=4, base=2.0)
array([4.        ,  5.0396842 ,  6.34960421,  8.        ])

9.3- np.geomspace() 

geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)
    Return numbers spaced evenly on a log scale (a geometric progression).
    
    This is similar to `logspace`, but with endpoints specified directly.
    Each output sample is a constant multiple of the previous.
    
    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.
    
    Parameters
    ----------
    start : array_like
        The starting value of the sequence.
    stop : array_like
        The final value of the sequence, unless `endpoint` is False.
        In that case, ``num + 1`` values are spaced over the
        interval in log-space, of which all but the last (a sequence of
        length `num`) are returned.
    num : integer, optional
        Number of samples to generate.  Default is 50.
    endpoint : boolean, optional
        If true, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred dtype will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.
    
        .. versionadded:: 1.16.0
>>> np.geomspace(1, 1000, num=4)
array([    1.,    10.,   100.,  1000.])
>>> np.geomspace(1, 1000, num=3, endpoint=False)
array([   1.,   10.,  100.])
>>> np.geomspace(1, 1000, num=4, endpoint=False)
array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
>>> np.geomspace(1, 256, num=9)
array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])
    
#Note that the above may not produce exact integers:
    
>>> np.geomspace(1, 256, num=9, dtype=int)
array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
>>> np.around(np.geomspace(1, 256, num=9)).astype(int)
array([  1,   2,   4,   8,  16,  32,  64, 128, 256])
    
#Negative, decreasing, and complex inputs are allowed:
    
>>> np.geomspace(1000, 1, num=4)
array([1000.,  100.,   10.,    1.])
>>> np.geomspace(-1000, -1, num=4)
array([-1000.,  -100.,   -10.,    -1.])
>>> np.geomspace(1j, 1000j, num=4)  # Straight line
array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
>>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
            6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
            1.00000000e+00+0.00000000e+00j])

10.1- 常量np.pi np.e np.nan np.inf 等

>>> np.pi
3.141592653589793
>>> np.e
2.718281828459045
>>> np.nan
nan
>>> np.inf
inf
>>> np.Inf
inf
>>> np.Infinity
inf
>>> np.PINF
inf
>>> np.NINF
-inf
>>> np.PZERO
0.0
>>> np.NZERO
-0.0

10.2- 常量数组 zeros() ones() empty()

>>> np.zeros((2,5))
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])
>>> np.zeros((2,5),dtype=int)
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])
>>> np.linspace(0, 0, 10, dtype=int).reshape((2,5))
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])
>>> 
>>> np.ones((3,4))
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
>>> np.ones((3,4),dtype=int)
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> np.linspace(1, 1, 12, dtype=int).reshape((3,4))
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>>
>>> np.linspace(1, 1, 12, dtype=int).reshape((3,4))*3
array([[3, 3, 3, 3],
       [3, 3, 3, 3],
       [3, 3, 3, 3]])
>>> np.linspace(1, 1, 12, dtype=int).reshape((3,4))*np.pi
array([[3.14159265, 3.14159265, 3.14159265, 3.14159265],
       [3.14159265, 3.14159265, 3.14159265, 3.14159265],
       [3.14159265, 3.14159265, 3.14159265, 3.14159265]])

10.3- 常量数组 zeros_like() ones_like() empty_like()

>>> arr = np.ones((3,4))
>>> np.zeros_like(arr)
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

10.4- 单位矩阵 np.eye() 或 np.identity() 对角线为1,其余为0

>>> np.eye(4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
>>> np.identity(4, dtype=int)
array([[1, 0, 0, 0],
       [0, 1, 0, 0],
       [0, 0, 1, 0],
       [0, 0, 0, 1]])

Python Numpy入门基础(一)创建数组,Python,python,numpy,开发语言文章来源地址https://www.toymoban.com/news/detail-621579.html

到了这里,关于Python Numpy入门基础(一)创建数组的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Python入门知识】NumPy 数组搜索,案例+理论讲解

    前言 嗨喽~大家好呀,这里是魔王呐 ❤ ~! 搜索数组 可以在数组中搜索(检索)某个值,然后返回获得匹配的索引。 要搜索数组,请使用 where() 方法。 实例 查找值为 4 的索引: 运行实例 更多python资料、源码、教程: 点击此处跳转文末名片获取 上例会返回一个元组:(array([

    2024年02月03日
    浏览(48)
  • 【Python 零基础入门】 Numpy

    在众多 Python 的数据处理库中, Numpy 是一个非常强大的存在. Numpy 为我们提供了高性能的多维数组, 以及这些数组对象上的各种操作. 但是, 作为一个刚入门 Python 的新手, 你可能会问: \\\"为什么我需要 Numpy, 而不是直接使用Python 的内置列表?\\\"在这篇文章的开篇, 我们就来探讨这个问

    2024年02月08日
    浏览(49)
  • 【Python】数据科学工具(Numpy Pandas np.array() 创建访问数组 向量与矩阵 Series DataFrame)

    1.Numpy numpy是Python中一个非常重要的科学计算库,其最基础的功能就是N维数组对象——ndarray。 1.1 数组的创建 1)np.array() 用 np.array() 函数可以将Python的序列对象(如列表、元组)转换为ndarray数组。 2)arange、linspace、logspace np.arange(start, stop, step) :创建一个一维数组,其中的值

    2024年02月10日
    浏览(48)
  • 【Python 零基础入门】Numpy 常用函数 通用函数 & 保存加载

    Numpy (Numerical Python) 是 Python 编程语言的一个扩展程序库, 支持大量的维度数组与矩阵运算, 并提供了大量的数学函数库. Numpy 利用了多线程数组来存储和处理大型数据集, 从而提供了一个高效的方式来进行数值计算, 特别是对于矩阵预算和线性代数. 通用函数 (Ufuncs) 是 numpy 的核

    2024年02月05日
    浏览(65)
  • 【Python Numpy】广播、数组的迭代

    在Python的科学计算领域,NumPy是一个强大的工具,它提供了用于操作多维数组的功能。广播(Broadcasting)是NumPy中的一个重要概念,它使得不同形状的数组之间的计算变得非常灵活和便捷。本文将介绍广播是什么,以及如何在NumPy中使用广播来进行数组计算。 在Python的科学计算

    2024年02月06日
    浏览(62)
  • Python numpy - 数组与矩阵的运算

    目录  数组array 一 数组的函数 unique函数  sum函数  max函数 二 数组的加减 三 数组的乘除  矩阵matrix 一 矩阵的生成 二 矩阵的加减 三  矩阵的乘法 创建数组a和b用来运算(至少两个) 数组常用函数 函数 作用 unique() 求数组里的唯一值,输出从小到大排列 sum() 对数组整

    2024年02月11日
    浏览(46)
  • 【深度学习】 Python 和 NumPy 系列教程(十二):NumPy详解:4、数组广播;5、排序操作

    目录 一、前言 二、实验环境 三、NumPy 0、多维数组对象(ndarray) 多维数组的属性 1、创建数组 2、数组操作 3、数组数学 4、数组广播 5、排序操作 1. np.sort() 函数 2. np.argsort() 函数 3. ndarray.sort() 方法 4. 按列或行排序 5. np.lexsort() 函数 6. np.partition() 函数 7. np.argpartition() 函

    2024年02月08日
    浏览(67)
  • 【python】使用numpy创建同心矩阵

    输入一个正奇数N,创建一个N*N的矩阵满足: 1. 矩阵中心的元素为N,其外层被N-1包围; 2. N-1的外层被N-2包围; 3. 依次循环,直到形成一个N*N的矩阵。 很容易可以计算得出,矩阵元素从内到外递减,最外层的元素为(N+1)/2. 我们可以使用numpy从外向内地填充矩阵;首先生成一个

    2024年02月13日
    浏览(45)
  • 【Python入门第四十六天】Python丨NumPy 数组重塑

    重塑意味着更改数组的形状。 数组的形状是每个维中元素的数量。 通过重塑,我们可以添加或删除维度或更改每个维度中的元素数量。 实例 将以下具有 12 个元素的 1-D 数组转换为 2-D 数组。 最外面的维度将有 4 个数组,每个数组包含 3 个元素: 运行实例 从 1-D 重塑为 3-D

    2023年04月08日
    浏览(48)
  • python实战应用讲解-【numpy数组篇】常用函数(八)(附python示例代码)

    目录 Python Numpy MaskedArray.cumprod()函数 Python Numpy MaskedArray.cumsum()函数 Python Numpy MaskedArray.default_fill_value()函数 Python Numpy MaskedArray.flatten()函数 Python Numpy MaskedArray.masked_equal()函数 numpy.MaskedArray.cumprod() 返回在给定轴上被屏蔽的数组元素的累积乘积。在计算过程中,被屏蔽的值在内部

    2024年02月02日
    浏览(58)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包