更过的Numpy教程连载内容：https://www.jianshu.com/nb/47449944

Numpy 的入门知识

Numpy 所处理的主要是齐次多维数组（homogeneous multidimensional array），数组中的元素使用元组（tuple）作为索引，Numpy 中的维度（dimension）也被称为轴（axes）

Numpy 的数组类是 ndarray，或者 array

数组最基本属性

• ndarray.ndim: 数组的维数/轴数
• ndarray.shape: 数组的维度（元组）
• ndarray.size: 数组的大小（元素总个数）
• ndarray.dtype: 数组类型，可赋值的对象，可以使用 ndarray.dtype.name 返回该类型的名字字符串
• ndarray.itemsize: 数组中单个元素所占用的字节数，例如 float64 类型的数组 itemsize 为 8，等于 ndarray.dtype.itemsize
• ndarray.data: 数组缓存占用空间的存储地址

a = np.arange(15).reshape(3,5)
print(a)
print(a.ndim)
print(a.shape)
print(a.size)
print(a.dtype)
print(a.itemsize)
print(a.data)

------

[[ 0  1  2  3  4]
    [ 5  6  7  8  9]
    [10 11 12 13 14]]
2
(3, 5)
15
int32
4
<memory at 0x00000292B5270048>

创建数组

从Python的序列创建

numpy可以将Python的序列（sequence），即 list 或者 tuple 以及 list 和 tuple 搭配的多维度序列，转换成数组，转换时可以通过 dtype 声明数组的数据类型：

al = [1,2,3]
at = (1,2.5,3.2)

ala = np.array(al)
print(ala,ala.dtype)

ata = np.array(at)
print(ata,ata.dtype)

alac = np.array(al,dtype=complex)
print(alac,alac.dtype)

blt = [(1,2,3),(4.5,5.6,6.7)]
btl = ([1,2,3],[4.5,5.6,6.7])

blta = np.array(blt)
print(blta,blta.dtype)

btla = np.array(btl)
print(btla,btla.dtype)

------

[1 2 3] int32
[1.  2.5 3.2] float64
[1.+0.j 2.+0.j 3.+0.j] complex128
[[1.  2.  3. ]
    [4.5 5.6 6.7]] float64
[[1.  2.  3. ]
    [4.5 5.6 6.7]] float64

创建特殊数组

创建特殊的数组时用于声明数组大小、形状的参数是一个元组，也可以使用 dtype 规定数组数据类型

• 零数组：

  np.zeros( shapeTulpe )
  np.zeros_like( anotherArray )
  

• 全1数组：

  np.ones( shapeTulpe )
  np.ones_like( anotherArray )
  

• 空数组（未初始化的数组）：

  np.empty( shapeTulpe )
  np.empty_like( anotherArray )
  

• 序列数组，使用方式类似于 Python 的 range 函数，但是可以接受小数作为参数且返回 array 对象：

  np.arrange( lowerBound, upperBound, stepLength)
  

• 指定起步值、终止值和数组大小：

  np.linspace( lowerBound, upperBound, elementsNumber )
  

打印数组

• 一维数组打印成一行
• 二维数组打印成矩阵
• 三维数组打印成多个二维矩阵
• 多元素使用 … 省略，如果想强制显示所有元素而不是用省略，需要：

  import sys
  np.set_printoptions(threshold = sys.maxsize)
  

基本操作

Numpy 的算术运算时基于同位元素逐个（elementwise）计算的。

• 运算时，创建一个新的数组然后填充计算结果的运算，比如加减乘除、乘方、函数运算、布尔值判断，注意，这些运算都是基于 elementwise 的，也就是对应位的元素逐个进行运算，所以可以看到两个 4×1 大小的向量执行乘法和除法后依然是一个 4×1 大小的向量：

  a = np.array([20,30,40,50])
  b = np.arange(1,5)
  
  print(a + b)
  print(a - b)
  print(a * b)
  print(a / b)
  print(b ** 2)
  print(10 * np.sin(a))
  print(a<35)
  
  ------
  
  [21 32 43 54]
  [19 28 37 46]
  [ 20  60 120 200]
  [20.         15.         13.33333333 12.5       ]
  [1  4  9 16]
  [9.12945251 -9.88031624  7.4511316  -2.62374854]
  [True  True False False]
  

• 乘法

  • 使用普通的乘法符号进行运算，按照 elementwise 规则逐位对应运算，即 a*b
    这种乘法会有如下几种维度情况，其他情况均会报错 (详细的内容请看关于广播有关的内容)：

    a.shape	b.shape	(a*b).shape
    (1,n)	(1,n)	(1,n)
    (n,1)	(n,1)	(n,1)
    (n,n)	(n,n)	(n,n)
    (n,m)	(n,m)	(n,m)
    (n,m)	(1,m)	(n,m)
    (n,m)	(n,1)	(n,m)
    (n,1)	(1,m)	(n,m)
    (1,n)	(m,1)	(m,n)

  • 按照矩阵乘法的规则运算，需要使用 A@B (Python >= 3.5) 或者 A.dot(B)：

    A = np.array([[1,1],[0,1]])
    B = np.array([[2,0],[3,4]])
    
    print(A@B)
    print(A.dot(B))
    print(B@A)
    print(B.dot(A))
    
    ------
    
    [[5 4]
     [3 4]]
    [[5 4]
     [3 4]]
    [[2 2]
     [3 7]]
    [[2 2]
     [3 7]]
    

• 赋值型运算，类似 +=、-=、*=、/= 之类的依然适用，但是注意数据类型需要符合转换规则，比如 A+=B 运算中，A和B的数据类型要相同或者B可以隐式地转换成A

• 其他基于方法的运算，使用 axis 参数可以指定运算的轴：

  • ndarray.sum( axis=? ): 求所有元素之和
  • ndarray.min( axis=? ): 求所有元素的最小值
  • ndarray.max( axis=? ): 求所有元素的最大值

全局函数

一些基于 elementwise 的运算功能的函数称为全局函数（universal functions，ufunc），这类函数均是numpy类的方法，接收一个数组做参数，执行elementwise操作后返回一个数组：

• numpy.sin(A): sin 函数
• numpy.cos(A): cos 函数
• numpy.exp(A): e的次方
• numpy.sqrt(A)：开方
• numpy.add(A,B)：A+B
• numpy.all(A): 检测是否所有元素为True
• numpy.any(A): 检查是否存在True元素
• numpy.apply_along_axis(function, axis, A): 对于A中指定的轴应用函数function
• numpy.argmax(A): 返回最大值的索引
• numpy.argmin(A): 返回最小值的索引
• numpy.argsort(A)：返回排序后的索引
• numpy.average(A)：平均值

其他还有很多：

all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, invert, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where

等等：参考 https://numpy.org/devdocs/user/quickstart.html#universal-functions

索引、切片与遍历（Indexing, Slicing and Iteracting）

索引与切片

• 一维数组：
  • 直接使用下标索引到指定的唯一元素
  • 使用一个冒号表示取该位置能取到的所有的值
  • 使用 i:j:k 的形式来表示从索引 i 到 j（不包含j）的这个区间内的元素，当k为正整数时，表示每k个取一次，当k为负整数的时候，表示每k个取一次，但是时倒着取
    其中，i、j、k 三个位置的数字均可以省略：
    • i省略表示从第一个元素开始
    • j省略表示最后一个元素结束
    • i 和 j 同时省略则表示所有元素，也就不存在从小索引到大索引还是从大索引到小索引的区别了 （例如 a[::-1] 表示a数组的倒序）
    • k省略表示步长为1，正向取值，但当k值也省略的时候，第二个冒号也就没有必要写了，于是就变成了直接使用 i:j 表示区间的形式
• 多维数组：
  • 多维数组可以使用与维度大小相同数量的多个索引值指定到唯一元素，多个索引值使用逗号隔开
  • 每一个维度都可以使用 i:j:k 的形式表示区间，或者使用一个冒号表示取该位置能取到的所有的值，维度之间使用逗号隔开
  • 使用三个点（…）表示多个维度，尤其是表示维度非常复杂的数组时：

    x[1,2,...] == x[1,2,:,:,:]
    x[...,3] == x[:,:,:,:,3]
    x[4,...,5,:] == x[4,:,:,5,:]
    

有关Python和Numpy中使用冒号、逗号、中括号进行索引的详细总结可以移步：https://www.jianshu.com/p/dd166725a2c3

遍历

Numpy数组的遍历可以使用Python中的 for … in 循环，如果想不管维数而遍历所有的元素，可以使用 ndarray 的 flat 属性来展开整个数组：

• ndarry.flat: 将数组中的所有元素展开成可以遍历的结构

  b=np.array([[1,2,3],[4,5,6]])
  
  for element in b.flat:
      print(element)
  
  ------
  
  1
  2
  3
  4
  5
  6