ndarray_ndarray排序 - CSDN
精华内容
参与话题
  • 什么是Numpy的ndarray

    千次阅读 2017-11-07 15:12:06
    什么是Numpy的ndarray 什么是Numpy的ndarray 首先,Numpy的核心是ndarray。 然后,ndarray本质是数组,其不同于一般的数组,或者Python 的list的地方在于它可以有N 维(dimentions),也可简单理解为数组里面嵌套...

    首先,Numpy的核心是ndarray。

    然后,ndarray本质是数组,其不同于一般的数组,或者Python 的list的地方在于它可以有N 维(dimentions),也可简单理解为数组里面嵌套数组。

    最后,Numpy为ndarray提供了便利的操作函数,而且性能优越,完爆Python 的list,因此在数值计算,机器学习,人工智能,神经网络等领域广泛应用。

    Numpy几乎是Python 生态系统的数值计算的基石,例如Scipy,Pandas,Scikit-learn,Keras等出色的包都基于Numpy。

    展开全文
  • Python NumPy ndarray 入门指南

    千次阅读 2019-09-12 18:52:18
    因为这几天做模糊数学和用 Python OpenCV2 都涉及到 NumPy ndarray,搜到的东西都没有写一些自己想要的。于是干脆自己写一篇,方便以后查阅。 numpy.ndarray 的官方文档在这里:...

    因为这几天做模糊数学和用 Python OpenCV2 都涉及到 NumPy ndarray,搜到的东西都没有写一些自己想要的。于是干脆自己写一篇,方便以后查阅。

    numpy.ndarray 的参数说明在这里:https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
    使用指南:https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.ndarray.html
    本文参考的 quick start 在这里:https://docs.scipy.org/doc/numpy/user/quickstart.html

    基础

    NumPy 的主要对象是齐次多维数组。它是一个元素表(通常是元素是数字),其中所有元素类型都相同,元素以正整数元组索引。在 NumPy 维度(dimension)被称为轴(axis)。
    ps. 有几个轴就是几维数组,符合平时生活中有 x, y 两个坐标轴就是二维空间,再加上 z 轴就是三维空间的概念

    例如三维空间空一个点的坐标 [1, 2, 1] 有一个轴。这个轴有 3 个元素,即该轴的长度是 3。下面代码区中的数组有两个轴。第一个轴长度是 2,第二个长度是 3.

    [[ 1., 0., 0.],
     [ 0., 1., 2.]]
    

    Numpy 的数组类称做 ndarry,别名是 array。注意 numpy.array 和 Python 标准库的类 array.array 不同,标准库的类只处理一维数组(one-dimensional arrays)。

    重要属性

    • ndarray.ndim
      the number of axes (dimensions) of the array.
    • ndarray.shape
      数组的维度(the dimensions of the array)。 以一个整型元组的方式表示数组中每个维度的大小。比如对一个有 n 行 m 列的矩阵来说,其 shape 属性为 (n, m)。The length of the shape tuple is therefore the number of axes, ndim.
    • ndarray.size
      数组元素总数。相当于 shape 中每个元素的乘积。
    • ndarray.dtype
      一个用来描述数组中元素类型的对象。我们可以使用 Python 标准类型来创建指定该对象,NumPy 也提供了自己的类型,如 numpy.int32, numpy.int16, and numpy.float641
    • ndarray.itemsize
      数组中每个元素的字节大小。 For example, an array of elements of type float64 has itemsize 8 (=64/8), while one of type complex32 has itemsize 4 (=32/8). It is equivalent to ndarray.dtype.itemsize.

    创建

    对于创建 numpy.ndarray,官网上给出了五种创建方式2,这里介绍更为常见的两种:

    1. 从 python 其他数据结构中转化而来,比如 list, tuple 等
    2. 固有的 NumPy ndarray 创建方式,比如 np.arange(), np.ones(), np.zeros() 等

    这里还会补充一种从文件中读入的方式。

    Converting Python array_like Objects to NumPy Arrays

    整体来说,我们可以使用 numpy.array() 函数将 Python 中任何以类似数组方式组织的数值数据转化成 numpy.ndarray。最显而易见的例子是 list 和 tuple3

    有一些对象支持 array-protocol,因此我们也可以使用 numpy.array() 函数将这些对象转换成 numpy.array。最简单判断对象是否支持这种转换方式的方法是自己动手转换试试。

    >>> import numpy as np
    >>> x = np.array([2,3,1,0]) # 列表方式
    >>> x
    array([2, 3, 1, 0])
    >>> type(x)
    <class 'numpy.ndarray'>
    >>> x.dtype
    dtype('int32')
    
    >>> x = np.array((1, 2, 3)) # 元组方式
    >>> x
    array([1, 2, 3])
    
    >>> x = np.array([[ 1.+0.j, 2.+0.j], [ 0.+0.j, 0.+0.j], [ 1.+1.j, 3.+0.j]])  # 不同类型的数据
    >>> x
    array([[1.+0.j, 2.+0.j],
           [0.+0.j, 0.+0.j],
           [1.+1.j, 3.+0.j]])
    >>> x.dtype
    dtype('complex128')
    
    >>> x = np.array([[1,2.0],[0,0],(1+1j,3.)]) # note mix of tuple and lists, and types
    >>> x
    array([[1.+0.j, 2.+0.j],
           [0.+0.j, 0.+0.j],
           [1.+1.j, 3.+0.j]])
    >>> x.dtype
    dtype('complex128')
    

    Intrinsic NumPy Array Creation

    一般来说 array 的元素本身是不知道的,但是如果我们知道 array 的大小(size),我们就可以使用 NumPy 提供的一些方法来创建具有初始值的 array。

    下面我列举了一些用于创建 numpy.ndarray 的内建函数,更多可以参考 Array creation routines

    1. numpy.zeros(shape, dtype=float, order=‘C’)
    2. numpy.ones(shape, dtype=None, order=‘C’)
    3. numpy.arange([start, ]stop, [step, ]dtype=None)
    4. numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    5. numpy.indices(dimensions, dtype=<class ‘int’>)

    其中的 shape 参数指定你想创建数组的维度以及每维的大小。比如 (2, 3, 4) 就是创建 234 的三维数组。

    其中函数 zero() 创建一个全为 0 的 array,函数 ones() 创建一个全为 1 的 array,函数 empty() 创建一个根据内存状态随机初始化值的 array。

    numpy.zeros(shape, dtype=float, order=‘C’)

    从函数本身我们就可以知道这个是创建一个全为 0 的 ndarray。其中 shape 指定创建 ndarray 的形状,如是 2行3列的,还是 4行5列的。

    >>> np.zeros((2, 3))
    array([[ 0., 0., 0.], [ 0., 0., 0.]])
    

    numpy.arange([start, ]stop, [step, ]dtype=None)

    arange() 会创建有规律递增的数值的 ndarray,个人感觉类似 range() 函数

    >>> np.arange(10)
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    
    >>> np.arange(2, 10, dtype=float)
    array([ 2., 3., 4., 5., 6., 7., 8., 9.])
    
    >>> np.arange(2, 3, 0.1)
    array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
    

    numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

    当我们给 arange() 函数传入附点类型参数的时候,我们通常不能预测我们创建 array 里元素的个数,这时候我们可以使用 linspace() 函数。

    linspace() 会根据 num 参数创建指定数量等差数据,数据的范围在 start 和 stop 之间,默认包含 stop。

    >>> np.linspace(1., 4., 6)
    array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])
    

    从文件中读入

    使用 numpy.genfromtxt,这里以读入 CSV 文件为例

    import numpy as np
    myFile = np.genfromtxt('filepath', delimiter=',')
    

    如果想读入以 TAB 为分隔符的文件,将 delimiter 换成 \t

    多维数组

    array() 函数将序列的序列转化成二维数组,将序列的序列的序列转化成三维数组,这样依次下去。

    >>> b = np.array([(1.5,2,3), (4,5,6)])
    >>> b
    array([[ 1.5,  2. ,  3. ],
           [ 4. ,  5. ,  6. ]])
    

    在创建的时候我们也可以指明元素的类型

    >>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
    >>> c
    array([[ 1.+0.j,  2.+0.j],
           [ 3.+0.j,  4.+0.j]])
    

    注意事项

    NumPy 的 ndarray 基本和 C++/Java 创建时要注意的差不多,创建的时候我们最好对我们需求的大小有个估计,然后再创建一个略多一点的就可以了。 ndarry 并没有 Python 的 list 那么灵活,可以随时更改数组大小(不过你要想增加一行或一列的话,也有一些方法),要更改大小的话一般得重新创建数组,效率不是很高4

    增加行

    https://stackoverflow.com/questions/3881453/numpy-add-row-to-array
    使用函数 vstack

    >>> a = np.zeros((3, 4))
    >>> a
    array([[0., 0., 0., 0.],
           [0., 0., 0., 0.],
           [0., 0., 0., 0.]])
    
    >>> row = np.ones((1, a.shape[1]))
    >>> row
    
    array([[1., 1., 1., 1.]])
    >>> np.vstack((a, row))
    array([[0., 0., 0., 0.],
           [0., 0., 0., 0.],
           [0., 0., 0., 0.],
           [1., 1., 1., 1.]])
    

    增加列

    https://stackoverflow.com/questions/15815854/how-to-add-column-to-numpy-array
    用 hstack

    >>> col = np.ones((a.shape[0], 2))
    >>> col
    array([[1., 1.],
           [1., 1.],
           [1., 1.]])
    >>> np.hstack((a, col))
    array([[0., 0., 0., 0., 1., 1.],
           [0., 0., 0., 0., 1., 1.],
           [0., 0., 0., 0., 1., 1.]])
    

    索引,切片,迭代(Indexing, Slicing and Iterating)

    一维

    一维数组像 Python list 一样被索引、切片和迭代。

    >>> a = np.arange(10)**3  # 创建数组
    >>> a
    array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
    >>> a[2]  # 索引
    8
    >>> a[2:5]  # 切片
    array([ 8, 27, 64])
    >>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
    >>> a
    array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
    >>> a[ : :-1]   # reversed a
    array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
    >>> for i in a:  # 迭代
    ...     print(i**(1/3.))
    ...
    nan
    1.0
    nan
    3.0
    nan
    5.0
    6.0
    7.0
    8.0
    9.0
    

    多维

    多维数组每个轴可以有一个索引,这些索引以逗号分隔的元组给出:

    索引

    参考 arrays indexing

    索引单个元素
    >>> b = np.arange(12).reshape(4,3)  # 将一维数组改成 4*3 的二维数组
    >>> b
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11]])
    >>> b[0, 2]  # 注意这里不能越界了。其实和 C++/Java 二维数组访问差不多。
    2
    
    索引行

    索引第 1 行

    >>> b[1, :]
    array([3, 4, 5])
    

    索引 0 3 行

    >>> b[[0,3], :]
    array([[ 0,  1,  2],
           [ 9, 10, 11]])
    
    索引列

    索引第 0 列

    >>> b[:, 0]
    array([0, 3, 6, 9])
    

    切片

    >>> b
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11]])
    >>> b[0:4, 1]              # each row in the second column of b
    array([ 1,  4,  7, 10])
    >>> b[0:5, 1]              # 这里可以越界
    array([ 1,  4,  7, 10])
    >>> b[ : ,1]               # equivalent to the previous example
    array([ 1,  4,  7, 10])
    >>> b[1:3, : ]             # each column in the second and third row of b
    array([[3, 4, 5],
           [6, 7, 8]])
    

    当提供的索引少于轴的数量时,缺失的索引被认为是完整的切片

    >>> b[-1]       # the last row. Equivalent to b[-1,:]
    array([ 9, 10, 11])
    

    迭代

    对多维数组进行迭代是针对第一个轴完成的

    >>> b
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11]])
    >>> for row in b:
    	print(row)
    
    [0 1 2]
    [3 4 5]
    [6 7 8]
    [ 9 10 11]
    

    如果你想对数组中的每个元素进行操作的话,你可以使用 flat 属性完成对每个元素的迭代。

    >>> for element in b.flat:
    	print(element)
    
    0
    ... # 为了节省地方,我这里认为删去了很多行。把 0~11 竖起来就是结果
    11
    

    基本运算

    当涉及到算术运算的时候,数组中的每个元素都会参与,运算最后会创建一个新数组并填充结果。

    >>> a = np.array( [20,30,40,50] )
    >>> b = np.arange( 4 )
    >>> b
    array([0, 1, 2, 3])
    >>> c = a-b  # 减
    >>> c
    array([20, 29, 38, 47])
    >>> a + 10  # 加
    array([30, 40, 50, 60])
    >>> b**2  # 幂运算
    array([0, 1, 4, 9])
    >>> a<35 # 比较运算
    array([ True, True, False, False])
    

    在 NumPy 数组中 * 是按对应元素进行计算的。想要进行 矩阵运算5 我们需要使用操作符 @ 或者 dot() 方法

    >>> A = np.array( [[1,1],
    ...                [0,1]] )
    >>> B = np.array( [[2,0],
    ...                [3,4]] )
    >>> A * B           # elementwise product
    array([[2, 0],
           [0, 4]])
    >>> A @ B           # matrix product
    array([[5, 4],
           [3, 4]])
    >>> A.dot(B)        # another matrix product
    array([[5, 4],
           [3, 4]])
    

    一些运算如,*= 和 += 并不会新创建数组,而是在原有数组上进行修改。

    通用数学函数

    NumPy 提供一系列数学函数,例如sin,cos和exp。在 NumPy 中,这些被称为“通用函数”(ufunc)。在 NumPy 中,这些函数都产生一个数组作为输出
    由于比较多,我把它放到了脚注6
    因为其中的很多函数都涉及到 axis 这个参数,这里就来简单介绍一下这个参数怎么指定,我们不妨以 np.sum() 来探究。

    numpy.sum(a, axis=None, dtype=None, out=None, keepdims=, initial=)
    给指定轴上的元素求和:
    参数说明(这里只介绍这里要谈的参数):

    • a: array_like
    • axis: None or int or tuple of ints, 可选
      指定要求和的轴。默认 axis=None 会对输入数组的所有元素求和,指定负数的话是从最后一个轴开始往前统计(其实和数组负数索引是一个道理)。

    对一个轴上的元素求和是一个减少操作,指定的轴会在运算完后消失。比如对一个一维数组上的元素求和,最后我们会得到是一个数。7

    想要理解这个东西,我们首先要对每个轴上有哪些元素有个清楚的认识。
    比如下图: axis=0 轴的大小是 8,其上的元素是 [100]\begin{bmatrix} 1 &amp; 0 &amp; 0 \end{bmatrix}[010]\begin{bmatrix} 0 &amp; 1 &amp; 0 \end{bmatrix}[001]\begin{bmatrix} 0 &amp; 0 &amp; 1 \end{bmatrix}[010]\begin{bmatrix} 0 &amp; 1 &amp; 0 \end{bmatrix}.

    而 axis=1 轴的大小是 3,其上的元素是 [1001...]\begin{bmatrix} 1 \\ 0 \\ 0 \\ 1 \\ ... \end{bmatrix}[0100...]\begin{bmatrix} 0 \\ 1 \\ 0 \\ 0 \\ ... \end{bmatrix}[0010...]\begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \\ ... \end{bmatrix}

    对 axis=0 求和就是把其上的所有元素相加 [100]+[010]+[001]+...+[010]\begin{bmatrix} 1 &amp; 0 &amp; 0 \end{bmatrix}+\begin{bmatrix} 0 &amp; 1 &amp; 0 \end{bmatrix}+\begin{bmatrix} 0 &amp; 0 &amp; 1 \end{bmatrix}+ ... +\begin{bmatrix} 0 &amp; 1 &amp; 0 \end{bmatrix},因此这个这从图上我们可以直观的看出来 axis=0 这个轴被压缩了,也就是消失了。
    在这里插入图片描述
    注:上图中的 sum of each row 这些文字我都是参考 universal-function 上面一小节程序里的注释的,因此应该不会出错。

    要是没搞懂的话,可以再来看看下面这个三维的例子。

    >>> a = np.ones((2,3,4))  # 创建一个三维的数组
    >>> a
    array([[[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]],
    
           [[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]]])
    >>> a.shape # 第一个轴大小为2,第二个轴大小为3,第三个轴大小为4
    (2, 3, 4)
    >>> a.ndim  # 一共有三个轴
    3
    >>> a.sum() # 计算所有元素的总和
    24
    
    >>> a.sum(axis=0)
    array([[2., 2., 2., 2.],
           [2., 2., 2., 2.],
           [2., 2., 2., 2.]])
    >>> a.sum(axis=0).shape
    (3, 4)
    
    >>> a.sum(axis=1)
    array([[3., 3., 3., 3.],
           [3., 3., 3., 3.]])
    >>> a.sum(axis=1).shape
    (2, 4)
    
    >>> a.sum(axis=2)
    array([[4., 4., 4.],
           [4., 4., 4.]])
    >>> a.sum(axis=2).shape
    (2, 3)
    

    参数指定为负数

    >>> a.sum(axis=-1)  # 等价于 a.sum(axis=2)
    array([[4., 4., 4.],
           [4., 4., 4.]])
    >>> a.sum(axis=-2)  # 等价于 a.sum(axis=1)
    array([[3., 3., 3., 3.],
           [3., 3., 3., 3.]])
    >>> a.sum(axis=-3)  # 等价于 a.sum(axis=0)
    array([[2., 2., 2., 2.],
           [2., 2., 2., 2.],
           [2., 2., 2., 2.]])
    

    参数指定为元组

    >>> a.shape
    (2, 3, 4)
    >>> a.sum(axis=(0,1))
    array([6., 6., 6., 6.])
    >>> a.sum(axis=(0,1)).shape
    (4,)
    

    输出

    当我们输出数组时,NumPy 以与嵌套列表类似的方式显示它,但具有以下布局:

    • the last axis is printed from left to right,
    • the second-to-last is printed from top to bottom,
    • the rest are also printed from top to bottom, with each slice separated from the next by an empty line.

    然后将一维数组打印为行,将二维数组打印为矩阵,将三维数组打印为矩阵列表。

    >>> a = np.arange(6)                         # 1d array
    >>> print(a)
    [0 1 2 3 4 5]
    >>>
    >>> b = np.arange(12).reshape(4,3)           # 2d array
    >>> print(b)
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    >>>
    >>> c = np.arange(24).reshape(2,3,4)         # 3d array
    >>> print(c)
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    

    当数组太大的时候,会省略显示一部分内容

    >>> print(np.arange(10000))
    [   0    1    2 ..., 9997 9998 9999]
    

    我们可以通过以下方式强制显示全:

    >>> np.set_printoptions(threshold=np.nan)
    

    1. Data types ↩︎

    2. Array creation routines ↩︎

    3. 列表和元组的区别是,元组不能修改。创建空元组和空列表方式类似:empty_tuple = () ↩︎

    4. https://stackoverflow.com/questions/568962/how-do-i-create-an-empty-array-matrix-in-numpy ↩︎

    5. [a1b1c1d1][a2b2c2d2]=[(a1a2+b1c2)(a1b2+b1d2)(c1a2+d1c2)(c1b2+d1d2)]\begin{bmatrix} a1 &amp; b1 \\ c1 &amp; d1 \end{bmatrix} * \begin{bmatrix} a2 &amp; b2 \\ c2 &amp; d2 \end{bmatrix} = \begin{bmatrix} (a1*a2+b1*c2) &amp; (a1*b2+b1*d2) \\ (c1*a2+d1*c2) &amp; (c1*b2+d1*d2) \end{bmatrix} ↩︎

    6. all,
      any,
      apply_along_axis,
      argmax,
      argmin,
      argsort,
      average,
      bincount,
      ceil,
      clip,
      conj,
      corrcoef,
      cov,
      cross,
      cumprod,
      cumsum,
      diff,
      dot 矩阵乘法
      floor,
      inner,
      inv,
      lexsort,
      max, 最大值
      maximum,
      mean, 平均值
      median,
      min, 最小值
      minimum,
      nonzero,
      outer,
      prod,
      re,
      round,
      sort, 排序
      std, 样本标准差
      sum, 求和
      trace,
      transpose,
      var,
      vdot,
      vectorize,
      where ↩︎

    7. https://stackoverflow.com/questions/22320534/how-does-the-axis-parameter-from-numpy-work ↩︎

    展开全文
  • ndarray基础操作

    千次阅读 2019-02-07 22:45:01
    ndarray是具有相同类型和大小的项目的(通常是固定大小的)多维容器。数组中的维和项的数量由其shape(形状)定义,该形状是指定每个维的大小的N个正整数的 元组 数组中的项类型由单独的数据类型对象(dtype)指定,...

    N维数组

    ndarray是具有相同类型和大小的项目的(通常是固定大小的)多维容器。数组中的维和项的数量由其shape(形状)定义,该形状是指定每个维的大小的N个正整数的 元组 数组中的项类型由单独的数据类型对象(dtype)指定,其中一个对象与每个ndarray关联。

    与Python中的其他容器对象一样,可以通过对数组进行索引或切片(例如,使用整数n),以及通过 ndarray 的方法和属性来访问和修改 ndarray 的内容。

    不同的ndarrays可以共享相同的数据,因此在一个ndarray中所做的更改可能在另一个中可见。 也就是说,ndarray可以是另一个ndarray的“视图”,它所指的数据由“base”ndarray处理。 ndarrays也可以是Pythonchace所拥有的内存视图或实现buffer或数组接口的对象


    数组属性

    数组属性反映数组本身固有的信息。通常,通过数组的属性访问它,你可以获取并设置数组的内部属性,而无需创建新的数组。公开的属性是数组的核心部分,只有其中一些属性可以在不创建新数组的情况下进行有意义的重置。每个属性的信息如下。

    内存相关的属性

    以下属性包含有关数组内存的信息:

    • ndarray.flags 有关数组内存分布的信息。
    • ndarray.shape 数组维度的元组。
    • ndarray.strides 遍历数组时要在每个维度中执行的字节元组。
    • ndarray.ndim 数组维数。
    • ndarray.data 指向数组数据开始的Python缓冲区对象。
    • ndarray.size 数组中的元素数。
    • ndarray.itemsize 一个数组元素的长度(以字节为单位)。
    • ndarray.nbytes 数组元素消耗的总字节。
    • ndarray.base 如果内存来自其他对象,则为基本对象。

    数据类型

    ndarray.dtype数组元素的数据类型。

    其他属性

    • ndarray.Tself.transpose()相同,只是如果 self.ndim <2 则返回自己。
    • ndarray.real 数组的真实部分。
    • ndarray.imag 数组的虚部。
    • ndarray.flat 数组上的一维迭代器。
    • ndarray.ctypes 一个简化数组与ctypes模块交互的对象。

    数组方法

    ndarray 对象有许多方法以某种方式对数组进行操作或与数组一起操作,通常返回数组结果。 下面简要说明这些方法。(每个方法的文档都有更完整的描述。)

    对于以下方法,numpy中还有相应的函数:all,any,argmax,argmin,argpartition,argsort,choose,clip,compress,copy,cumprod,cumsum,diagonal,imag,max,mean,min,nonzero,partition, prod,ptp,put,ravel,real,repeat,reshape,round,searchsorted,sort,squeeze,std,sum,swapaxes,take,trace,transpose,var

    数组转换

    • ndarray.item(*args) 将数组元素复制到标准Python标量并返回它。
    • ndarray.tolist() 将数组作为(可能是嵌套的)列表返回。
    • ndarray.itemset(*args) 将标量插入数组(如果可能,将标量转换为数组的dtype)
    • ndarray.tostring([order]) 构造包含数组中原始数据字节的Python字节。
    • ndarray.tobytes([order]) 构造包含数组中原始数据字节的Python字节。
    • ndarray.tofile(fid[, sep, format]) 将数组作为文本或二进制写入文件(默认)。
    • ndarray.dump(file) 将数组的pickle转储到指定的文件。
    • ndarray.dumps() 以字符串形式返回数组的pickle。
    • ndarray.astype(dtype[, order, casting, …]) 数组的副本,强制转换为指定的类型。
    • ndarray.byteswap([inplace]) 交换数组元素的字节
    • ndarray.copy([order]) 返回数组的副本。
    • ndarray.view([dtype, type]) 具有相同数据的数组的新视图。
    • ndarray.getfield(dtype[, offset]) 返回给定数组的字段作为特定类型。
    • ndarray.setflags([write, align, uic]) 分别设置数组标志WRITEABLE,ALIGNED,(WRITEBACKIFCOPY和UPDATEIFCOPY)。
    • ndarray.fill(value) 使用标量值填充数组。

    项目选择和操作

    对于采用axis关键字的数组方法,默认为None。 如果axis为None,则将数组视为1维数组。轴的任何其他值表示操作应该沿着的维度。

    • ndarray.take(indices[, axis, out, mode]) 返回由给定索引处的a元素组成的数组。
    • ndarray.put(indices, values[, mode]) 为索引中的所有n设置 a.flat[n] = values[n]。
    • ndarray.repeat(repeats[, axis]) 重复数组的元素。
    • ndarray.choose(choices[, out, mode]) 使用索引数组从一组选项中构造新数组。
    • ndarray.sort([axis, kind, order]) 就地对数组进行排序。
    • ndarray.argsort([axis, kind, order]) 返回将对此数组进行排序的索引。
    • ndarray.partition(kth[, axis, kind, order]) 重新排列数组中的元素,使得第k个位置的元素值处于排序数组中的位置。
    • ndarray.argpartition(kth[, axis, kind, order]) 重新排列数组中的元素,使得第k个位置的元素值处于排序数组中的位置。
    • ndarray.searchsorted(v[, side, sorter]) 查找应在其中插入v的元素以维护顺序的索引。
    • ndarray.nonzero() 返回非零元素的索引。
    • ndarray.compress(condition[, axis, out]) 沿给定轴返回此数组的选定切片。
    • ndarray.diagonal([offset, axis1, axis2]) 返回指定的对角线。

    计算

    在下面这种情况下,其中许多方法都采用名为axis的参数。

    • 如果axis为None(默认值),则将数组视为1-D数组,并对整个数组执行操作。 如果self是0维数组或数组标量,则此行为也是默认行为。 (数组标量是类型/类float32,float64等的实例,而0维数组是包含恰好一个数组标量的ndarray实例。)
    • 如果axis是整数,则操作在给定轴上完成(对于可沿给定轴创建的每个1维的子阵列)。若数组是二维的,则axis=0表示沿列进行运算,axis=1表示沿行进行运算。

    对于多种方法,还可以提供可选的out参数,并将结果放入给定的输出数组中。 out参数必须是 ndarray 并且具有相同数量的元素。 它可以具有不同的数据类型,在这种情况下将执行转换。

    • ndarray.argmax([axis, out]) 返回给定轴的最大值索引。
    • ndarray.min([axis, out, keepdims]) 沿给定轴返回最小值。
    • ndarray.argmin([axis, out]) 沿a的给定轴返回最小值的索引。
    • ndarray.ptp([axis, out]) 沿给定轴的峰峰值(最大值 - 最小值)。
    • ndarray.clip([min, max, out]) 返回其值限制为 [min, max] 的数组。
    • ndarray.conj() 复合共轭所有元素。
    • ndarray.round([decimals, out]) 返回a,每个元素四舍五入到给定的小数位数。
    • ndarray.trace([offset, axis1, axis2, dtype, out]) 返回数组对角线的总和。
    • ndarray.sum([axis, dtype, out, keepdims]) 返回给定轴上的数组元素的总和。
    • ndarray.cumsum([axis, dtype, out]) 返回给定轴上元素的累积和。
    • ndarray.mean([axis, dtype, out, keepdims]) 返回给定轴上数组元素的平均值。
    • ndarray.var([axis, dtype, out, ddof, keepdims]) 返回给定轴的数组元素的方差。
    • ndarray.std([axis, dtype, out, ddof, keepdims]) 返回给定轴的数组元素的标准偏差。
    • ndarray.prod([axis, dtype, out, keepdims]) 返回给定轴上的数组元素的乘积
    • ndarray.cumprod([axis, dtype, out]) 返回沿给定轴的元素的累积乘积。
    • ndarray.all([axis, out, keepdims]) 如果所有元素都计算为True,则返回True。
    • ndarray.any([axis, out, keepdims]) 如果求值的任何元素为True,则返回True。

    特殊方法

    标准库函数:

    • ndarray.copy() 如果在数组上调用copy.copy,则使用此方法。
    • ndarray.deepcopy(memo, /) 如果在数组上调用copy.deepcopy,则使用此方法。
    • ndarray.reduce() 用于腌制(译者注:很形象)。
    • ndarray.setstate(state, /) 用于反腌制。

    基本的定制:

    • ndarray.new($type, args, *kwargs) 创建并返回一个新对象。
    • ndarray.array(|dtype) 如果没有给出dtype,则返回对self的新引用;如果dtype与数组的当前dtype不同,则返回提供的数据类型的新数组。
    • ndarray.array_wrap(obj)

    容器的定制: (参见索引)

    • ndarray.len($self, /) 返回 len(self).
    • ndarray.getitem($self, key, /) 返回 self[key].
    • ndarray.setitem($self, key, value, /) 给 self[key] 设置一个值。
    • ndarray.contains($self, key, /) 返回 自身的关键索引。

    转换;操作complex,int,long,float,oct和hex。它们位于数组中,其中包含一个元素并返回相应的标量。

    • ndarray.int(self)
    • ndarray.long
    • ndarray.float(self)
    • ndarray.oct
    • ndarray.hex

    字符串表示:

    • ndarray.str($self, /) 返回 str(self).
    • ndarray.repr($self, /) 返回 repr(self).

    以上内容摘自https://www.numpy.org.cn/reference/array_objects/n_dimensional_array.html

    展开全文
  • ndarray 数据基本操作

    千次阅读 2018-03-14 19:02:17
    ndarray 数据基本操作 (1)数组与标量、数组之间的运算 (2)数组的矩阵积(matrix product) (3)数组的索引与切片 (4)数组的转置与轴对换 (5)通用函数:快速的元素级数组成函数 (6)聚合函数 (7)np....

    ndarray 数据基本操作

      (1)数组与标量、数组之间的运算

      (2)数组的矩阵积(matrix product)

      (3)数组的索引与切片

      (4)数组的转置与轴对换

      (5)通用函数:快速的元素级数组成函数

      (6)聚合函数

      (7)np.where函数

      (8)np.unique函数


     (1)数组与标量的运算

    arr1=np.random.random((2,3))

    arr2=np.random.random((2,3))

    arr3=np.random.random((3,2))

    print(arr1)

    # 加减乘除、乘方

    print(arr1*2)

    print()

    print(arr1+2)

    print()

    print(arr1-2)

    print()

    print(arr1/2)

    print()

    print(arr1**2)



    (2)数组与数组的运算

    # 加减乘除、乘方、数组的矩阵积

    # 两个二维矩阵(行和列的矩阵)满足第一个矩阵的列数与第二个矩阵的行数相同,

    # 那么可以进行矩阵的乘法,即矩阵积,矩阵积不是元素级的运算。也称为点积、数量积。

    print(arr1+arr2)

    print()

    print(arr1-arr2)

    print()

    print(arr1*arr2)

    print()

    print(arr1/arr2)

    print()

    print(arr1**arr2)

    print()

    print(arr1.dot(arr3))



     (3)数组的索引与切片

    # 定义一个3*3*3的数组

    arr3=np.array([

        [[1,2,3],[4,5,6],[7,8,9]],

        [[10,11,12],[13,14,15],[16,17,18]],

        [[19,20,21],[22,23,24],[25,26,27]]

    ])

    # 索引

    print(arr3)

    print("# # # # # # #arr3[0]# # # # # # # # # # # # # # ")

    print(arr3[0])

    print("# # # # # # #arr3[1] # # # # # # # # # # # # # ")

    print(arr3[1])

    print("# # # # # # # arr3[2] # # # # # # # # # # # # # # ")

    print(arr3[2])

    print("# # # # # # # arr3[0][0] # # # # # # # # # # # # # # ")

    print(arr3[0][0])

    print("# # # # # # # arr3[0][1] # # # # # # # # # # # # # # ")

    print(arr3[0][1])

    print("# # # # # # # arr3[0][2]# # # # # # # # # # # # # # ")

    print(arr3[0][2])

    print("# # # # # # # arr3[0][2][0] # # # # # # # # # # # # # # ")

    print(arr3[0][2][0])

    print("# # # # # # # arr3[0][2][1]# # # # # # # # # # # # # # ")

    print(arr3[0][2][1])

    print("# # # # # # # arr3[0][2][2]# # # # # # # # # # # # # # ")

    print(arr3[0][2][2])

    # 切片,,,在各维度上单独切片,如果纬度都保留,则使用冒号,不指定起始值

    print("# # # # # # # arr3[0,:,0:2]# # # # # # # # # # # # # # ")

    print(arr3[0,:,0:2])

    print("# # # # # # # arr3[1,:,0:2]# # # # # # # # # # # # # # ")

    print(arr3[1,:,0:2])

    print("# # # # # # # arr3[2,:,0:2]# # # # # # # # # # # # # # ")

    print(arr3[2,:,0:2])

    print("# # # # # # # arr3[:,:,0:2]# # # # # # # # # # # # # # ")

    print(arr3[:,:,0:2])

    print("# # # # # # # arr3[:,0,0:2]# # # # # # # # # # # # # # ")

    print(arr3[:,0,0:2])

    print("# # # # # # # arr3[:,1,0:2]# # # # # # # # # # # # # # ")

    print(arr3[:,1,0:2])

    print("# # # # # # # arr3[:,2,0:2]# # # # # # # # # # # # # # ")

    print(arr3[:,2,0:2])



    ndarray-布尔类型索引

    #  利用布尔类型的数组进行数据索引,最终返回的结果是对应索引数组中数据为True位置的值。

    # numpy中不能使用Python中and、or、not,使用&(与)、|(或)、~(非)

    arr6=np.random.random((3,4))

    print(arr6)

    print("# # # # # # ## #arr6>0.5得到的布尔值,为真则取该位置的值,否则就舍去 # # # # # # # # # ")

    # A=arr6<0.5

    A=arr6>0.5

    print(A)

    print("# # # # # # ## # # # # # #将对应的布尔值转换为一维数组 # # # # # # # # # # # # # # ## # ")

    # 装换成一维数组

    arr7=arr6[A]

    print(arr7)

    print(arr7.shape)



    # 利用布尔值进行索引的一个应用实例

    names=np.array(['Gerry','Tom','John'])

    scores=np.array([

        [98,87,86,95],

        [48,84,84,45],

        [58,7,81,95]

    ])

    class1=np.array(['语文','数学','英语','科学'])

    print("Gerry score is:",scores[names=='Gerry'].reshape((-1)))

    print("Gerry score is:",scores[names=='Gerry'].reshape((-1))[class1=='数学'])

    print("Gerry和Tom的成绩")

    print(scores[(names=='Gerry')|(names=='Tom')])

    print("非Gerry和Tom的成绩")

    print(scores[(names!='Gerry')&(names!='Tom')])

    print("成绩大于90的全部输出")

    print(scores[scores>90])



     ndarray-花式索引:指的是利用整数数组进行索引的方式。

    arr7=np.arange(40).reshape(5,8)

    print(arr7)

    print("获取第0、3、5行的数据")

    print(arr7[[0,2,4]])

    print("获取第(0,0)、(3,0)、(4,2)的数据")

    print(arr7[[0,3,4],[0,0,2]])

    print("获取第0、3、5行的第0、2、3列数据")

    print(arr7[[0,3,4]].T[[0,1,2]].T)

    print("ix_会产生一个索引器")

    print(arr7[np.ix_([0,3,4],[0,1,2])])



    # ndarray-花式索引:指的是利用整数数组进行索引的方式。

    arr7=np.arange(40).reshape(5,8)

    print(arr7)

    print("获取第0、3、5行的数据")

    print(arr7[[0,2,4]])

    print("获取第(0,0)、(3,0)、(4,2)的数据")

    print(arr7[[0,3,4],[0,0,2]])

    print("获取第0、3、5行的第0、2、3列数据")

    print(arr7[[0,3,4]])

    print("##################")

    print(arr7[[0,3,4]].T)

    print("##################")

    print(arr7[[0,3,4]].T[[0,1,2]])

    print("##################")

    print(arr7[[0,3,4]].T[[0,1,2]].T)

    print("ix_会产生一个索引器")

    print(arr7[np.ix_([0,3,4],[0,1,2])])



     ndarray-数组转置与轴对换

    # 数组转置是指将shape进行重置操作,并将其值重置为原始shape元组的倒置,

    # 比如原始的shape值为:(2,3,4),那么转置后的新元组的shape的值为: (4,3,2)f

    # 可以通过调用数组的transpose函数或者T属性进行数组转置操作

    arr=np.random.random(30).reshape(3,5,2)

    print(arr)

    print("#############################################")

    arr1=arr.T

    print(arr1)

    print("#############################################")

    arr2=np.transpose(arr1)

    print(arr2)



    ndarray-通用函数/常用函数

    numpy模块中对ndarray中数据进行快速元素级运算的函数,也可以看做是简单的函数(接受一个或多个标量值,并产生一个或多个标量值)的矢量化包装器。主要包括一元函数和二元函数。



    一元函数

    arr3=np.array([

        [1,2,-3],

        [0.1,0.6,-0.4]

    ])

    print(arr3)

    print("#############################################")

    # abs fabs计算绝对值

    print(np.abs(arr3))

    print("#############################################")

    # sqrt 计算各元素的平方根

    print(np.sqrt(abs(arr3)))

    print("#############################################")

    # square计算各元素的评分:arr3**2

    print(np.square(arr3))

    print("#############################################")

    # exp计算各元素指数e的x次方

    print(np.exp(arr3))

    print("#############################################")

    # log2、log10分别计算底数为10、2的log值,以及log(1+x)

    print(np.log10(abs(arr3)))

    print(np.log2(abs(arr3)))

    print(np.log1p(abs(arr3)))

    print("#############################################")

    # sign计算各个元素的正负号,1:正号  0:0  -1:负号

    print(np.sign(arr3))

    print("#############################################")

    # ceil 计算各个元素的ceil值,大于等于该值的最小整数

    print(np.ceil(arr3))

    print("#############################################")

    # floor 计算各个元素的floor的值,小于等于该值的最大整数

    print(np.floor(arr3))

    print("#############################################")

    # rint 将各个元素的四书五入到最接近的整数

    print(np.rint(arr3)

    print("#############################################")

    # modf 将数组中元素的小数位和整数位以两部分独立数组的形式返回

    print(np.modf(arr3))

    print("#############################################")

    # isnan 返回一个表示“那些值是NaN(不是一个数字)”的布尔类型数组

    print(np.isnan(arr3))

    print("#############################################")

    # isfinite、isinf  分别一个表示”那些元素是有穷的(非inf、非NaN)”或者“那些元素是无穷的”的布尔型数组

    print(np.isfinite(arr3))

    print(np.isinf(arr3))

    print("#############################################")

    # cos、cosh、sin、sinh、tan、tanh  普通以及双曲型三角函数

    print(np.tan(arr3))

    print("#############################################")

    # arccos、arccosh、arcsin、arcsinh、arctan、arctanh 反三角函数

    print(np.arctan(arr3))



     二元函数

    arr4=np.array([

        [1,0,-3],

        [0.1,0.6,-0.4]

    ])

    arr5=np.array([

        [2,-5,8],

        [-0.1,-0.6,0.4],

    ])

    arr6=np.array([

        [2,-5,8],

        [-0.1,-0.6,0.4],

        [-0.1,-0.6,0.4]

    ])

    print("#############################################")

    # mod 取模运算,做除法运算之后的余数

    print(np.mod(arr4,arr5))

    print("#############################################")

    # dot 求两个数组的点积

    print(np.dot(arr4,arr6))

    print("#############################################")

    # greater(大于)、greater_equal(大于等于)、less(小于)、less_equal(小于等于)、equal(等于)、not_equal(不等于)

    # 执行元素级别的比较运算,最终返回一个布尔型数组

    print(np.greater(arr4,arr5))

    print("#############################################")

    # logical_and、logical_or、logical_xor

    # 执行元素级别的布尔逻辑运算,相当于中缀运算符&、|、^

    print(np.logical_and(arr4,arr5))

    print(np.logical_xor(arr4,arr5))

    print("#############################################")

    # power 求解对数组中的每个元素进行给定次数的指数值,类似于: arr ** 3

    print(np.power(arr3,4))



     ndarray-聚合函数

     聚合函数是对一组值(eg一个数组)进行操作,返回一个单一值作为结果的函数。

     当然聚合函数也可以指定对某个具体的轴进行数据聚合操作;

    #常将的聚合操作有:平均值mean、最大值max、最小值min、方差std等等

    arr7=np.array([

        [2,-5,8],

        [-0.1,-0.6,0.4],

        [-0.1,-0.6,0.4]

    ])

    print(np.mean(arr7))

    print(np.max(arr7))

    print(np.min(arr7))

    print(np.std(arr7))



     np.where函数

    # np.where函数是三元表达式x if condition else y的矢量化版本

    arr8=np.array([2,7,8])

    arr9=np.array([-0.1,-0.6,0.4])

    condition=arr8>arr

    result=np.where(condition,arr8,arr9)

    print(result)

    np.unique函数

    # np.unique函数的主要作用是将数组中的元素进行去重操作(也就是只保存不重复的数据)

    arr10=np.array(["Python","Python","java"])

    print(arr10)

    print(np.unique(arr10))

    展开全文
  • numpy中的ndarray方法和属性

    万次阅读 多人点赞 2015-08-03 12:55:17
    原文地址 NumPy数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2,以此类推。在NumPy中,每一个线性的数组称为是一个轴(axes),秩其实是描述轴的数量。...Numpy库中的矩阵模块为ndarray对象,
  • mxnet快速入门教程值NDArray(一)

    千次阅读 2019-04-21 20:03:53
    通过一系列文章你将能够快速掌握mxnet的核心NDArray和Gluron以及灵活利用mxnet来构建神经网络,mxnet中的NDArray数据结构相当于TensorFlow中的tensor,其结构有点类似于numpy的array,通过mxnet的Gluron可以快速来...
  • Numpy:array的创建和ndarray的基本操作

    万次阅读 2018-07-22 08:27:11
    Numpy 导入:import numpy as np 1.创建数组 一维数组的创建 arr1=np.array([1,2,3,4,5],float) ...arr2=np.array([[1,2,3],[3,4,5],[1,5,8]]) ...如果传进来的列表中包含不同的类型,则统一为统一类型,str&...
  • NDArray

    2019-06-30 17:26:43
    import mxnet as mx import mxnet.ndarray as nd img = nd.array([[[[1],[2],[3],[4]], [[5],[6],[7],[8]], [[9],[10],[11],[12]], [[13],[14],[15],[16]]]]) ...
  • Python: NumPy中的多维数组ndarray

    万次阅读 多人点赞 2017-10-15 20:28:40
    Python中的数组
  • numpy中的ndarray与array的区别、不同

    万次阅读 2017-09-14 22:02:20
    What is the difference between ndarray and array in Numpy
  • python中ndarray与dataframe互转

    千次阅读 2017-12-11 21:54:43
    情况1:输入的数据data为list 情况2:输入的数据data为dict 情况3:输入的数据data为ndarray
  • NDArray 与 numpy.ndarray 互相转换

    千次阅读 2018-06-19 15:12:59
    import numpy as np from mxnet import nd ...# numpy.ndarray 变 mx.NDArray np_val = np.array([1, 2, 3]) nd_val = nd.array(np_val) # 深复制 # NDArray 变 numpy.ndarray np_val_ = nd_val.asnumpy()
  • [numpy] ndarray 与 list 互相转换

    万次阅读 多人点赞 2018-05-19 13:29:20
    list 转 numpynp.array(a)ndarray 转 lista.tolist()
  • ndarray 数据类型 —— dtype

    千次阅读 2018-01-16 22:20:43
    fghfhg
  • ndarray 与 array 的区别 关系

    千次阅读 2020-02-06 20:00:37
    ndarray 数组 ndarray 与 array 的区别 关系 ndarray 是 np.array这个方法来创建的一个对象 1、ndarray数组 是用np.ndarray类的对象表示n维数组 import numpy as np ary = np.array([1,2,3,4,5,6]) print(type(ary))...
  • NumPy是高性能科学计算和数据分析的基础包。...3.NumPy.ndarray的属性 4.NumPy.ndarray的函数 5.NumPy.ndarray的索引与切片 6.NumPy.random常用函数: 7.NumPy.linalg常用函数函数 8.总结 0.导入numpy...
  • numpy数组的创建

    万次阅读 2017-12-15 19:17:37
    创建数组创建ndarray创建数组最简单的方法就是使用array函数。它接收一切序列型的对象(包括其他数组),然后产生一个新的含有传入数据的Numpy数组。array函数创建数组import numpy as np ndarray1 = np.array([1, 2...
  • numpy 的ndarray 转换数据类型dtype

    千次阅读 2019-01-19 16:32:10
    以将adarry中数据从int类型转换成complex为例。   如果使用a.dtype=complex,显然结果是不对的   要使用astype函数转换 ,成功了,并且a不变
  • 数据分析三大神器之一:Numpy

    千次阅读 2019-03-29 16:58:02
    ndarray, 具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。 用于对整组数据进行快速运算的标准数学函数(无需编写循环)。 用于读写磁盘数据的工具以及用于操作内存映射文件的工具。 线性代数、...
  • np.array与np.ndarray区别

    千次阅读 2019-06-20 16:58:23
    (Numpy中ndarray和array的区别是什么?我在哪儿能够找到numpy中相应的实现?) 答:Well, np.array is just a convenience function to create an ndarray, it is not a class itself.(嗯,np.array只是一个便捷...
1 2 3 4 5 ... 20
收藏数 27,422
精华内容 10,968
关键字:

ndarray