python numpy模块使用笔记（更新）

np.arange(int a)

生成一个一维array，元素个数是a个，元素是0到a-1

注意arange不能直接生成多维array

np.arange(int a).reshape(int b,int c)

生成一个一维array，个数为a，然后改成二维数组b*c，b*c=a；也可更多维

reshape与原shape无关，只要总元素个数符合即可

reshape返回的对象实际是原array的一个引用，仅形式不一样，改变一个，两个都会变

np.arange(int a, dtype=np.uint8)

生成一个类型为np.uint8（或其他参数）的一维数组，个数为a

np.arange(a,b)

生成一个array，从a开始，到b以内，间隔为1，浮点数则间隔为1.0

np.arange(a,b,c)

生成一个array，从a开始，到b以内，间隔为c

array的直接赋值不产生新的array

np.zeros()构造一个全0.0的array

np.ones()构造一个全1.0的array

np.full( (tuple shape) , num ) 构造一个全为num的array，大小由shape规定

np.eye( int d )构造一个d维（d*d）的单位矩阵array

 import numpy as np
 a = np.array([[1,2,3],[1,2]])
 print("a", a)
 b = a
 print("b is a? ", b is a)
 c = np.zeros((3,4))
 print("c", c)
 d = np.ones((3,4),dtype=np.int16)
 print("d", d)
 e = np.empty((3,4))
 print("e", e)
 f = np.arange(10.1,20.0)
 print("f", f)
 g = np.arange(12).reshape((3,4)).reshape((2,2,3))
 h = g.reshape((3,4))
 h[0][0] = 100
 print("h is g?", h is g)
 print(g)
 i = np.linspace(1,10,19)
 print("i", i)

a [list([1, 2, 3]) list([1, 2])]
b is a?  True
c [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
d [[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]
e [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
f [10.1 11.1 12.1 13.1 14.1 15.1 16.1 17.1 18.1 19.1]
h is g? False
[[[100   1   2]
  [  3   4   5]]

 [[  6   7   8]
  [  9  10  11]]]
i [ 1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5  7.   7.5
  8.   8.5  9.   9.5 10. ]

np.array(list l)

用list类型的对象l生成一个新的array

np.array(ndarray l)

用ndarray类型的对象l生成一个新的array

np.asarray(list l)

用list类型的对象l生成一个新的array

np.asarray(ndarray l)

用ndarray类型的对象l生成一个array，但两者是同一个对象

 a = [0,1,2]
 b = np.arange(3)
 c = np.array(a)
 d = np.array(b)
 e = np.asarray(a)
 f = np.asarray(b)
 a[0] = 1
 b[0] = 1
 print(c,d)
 print(e,f)
 print("f is b?", f is b)

[0 1 2] [0 1 2]
[0 1 2] [1 1 2]
f is b? True

a.copy()将a的值copy出来，生成一个新对象

 a = np.ones((1,3))
 b = a.copy()
 b[0][0] = 0
 print(a,b)

[[1. 1. 1.]] [[0. 1. 1.]]

a.ndim

维数

a.shape

形状，几乘几乘几的array

a.size

元素个数

a.dtype

元素类型

 print(a.ndim)
 print(a.shape)
 print(a.size)
 print(a.dtype)
 print(type(a))

2
(2, 3)
6
float64
<class 'numpy.ndarray'>

基本运算都是对于array内的元素的运算

运算，+-*\&|^等二元运算符运用于两个shape相同的array间，结果是对应位置的元素分别运算

幂次**等运算符结果是每个元素分别进行幂运算

比较运算同样是对每个元素进行操作

np.sin(ndarray a)

np.cos(ndarray a)

np.tan(ndarray a)

 a = np.arange(2,5)
 b = np.arange(1,4)
 print(a,b)
 print(a+b,a-b,a*b,a/b,a&b,a|b,a^b)
 print(a**3)
 print(a<b,a<3)
 print(np.sin(a))

[2 3 4] [1 2 3]
[3 5 7] [1 1 1] [ 2  6 12] [2.         1.5        1.33333333] [0 2 0] [3 3 7] [3 1 7]
[ 8 27 64]
[False False False] [ True False False]
[ 0.90929743  0.14112001 -0.7568025 ]

np.dot(ndarray a,ndarray b)

a.dot(ndarray b)

对于一维array，效果同向量点积，需满足长度相等

对于高维array，效果为矩阵乘法，需满足矩乘要求

a.transpose()或a.T矩阵转置，对一维array无效

 a = np.arange(0,6)
 print("1: ", a,a.T)
 print("2: ", a.dot(a))
 a = a.reshape((2,3))
 print("3: ", a)
 print("4: ", a.T)
 print("5: ", a.transpose())
 print("6: ", a.dot(a.T))
 print("7: ", a.T.dot(a))

1:  [0 1 2 3 4 5] [0 1 2 3 4 5]
2:  55
3:  [[0 1 2]
 [3 4 5]]
4:  [[0 3]
 [1 4]
 [2 5]]
5:  [[0 3]
 [1 4]
 [2 5]]
6:  [[ 5 14]
 [14 50]]
7:  [[ 9 12 15]
 [12 17 22]
 [15 22 29]]

np.random.random(shape)根据shape随机生成array，元素在0到1间

np.median(ndarray a[, axis=0])中位数

np.average(ndarray a[, axis=0])均值

np.diff(ndarray a[, axis=0])差分

a.max([axis=0])

a.min([axis=0])

a.sum([axis=0])

a.cumsum([axis=0])前缀和

a.mean([axis=0])求均值

a.argmax([axis=0])这个函数应该是对于值相同的情况取其中的第一个

np.sort(ndarray a[, axis=0])排序，默认按最高维排序

np.sqrt(ndarray a)对每个元素分别开方

定义axis则对于某一维进行分别运算

 a = np.random.random((2,5))
 print("a", a)
 print("sum", a.sum())
 print("cumsum 1", a.cumsum())
 print("cumsum 2", a.cumsum(axis=0))
 print("diff", np.diff(a))
 print("argmax", a.argmax(axis=0))
 print("max", a.max(axis=1))
 print("mean", a.mean(axis=1))
 print("median", np.median(a,axis=1))
 print("sort", np.sort(a,axis=0))

a [[0.17921251 0.56586623 0.47136818 0.10203327 0.91359077]
 [0.79646881 0.30153261 0.06144976 0.46015996 0.61220888]]
sum 4.463890979638066
cumsum 1 [0.17921251 0.74507874 1.21644692 1.31848019 2.23207096 3.02853977
 3.33007238 3.39152214 3.8516821  4.46389098]
cumsum 2 [[0.17921251 0.56586623 0.47136818 0.10203327 0.91359077]
 [0.97568132 0.86739883 0.53281794 0.56219323 1.52579964]]
diff [[ 0.38665372 -0.09449805 -0.36933491  0.81155749]
 [-0.49493621 -0.24008284  0.3987102   0.15204892]]
argmax [1 0 0 1 0]
max [0.91359077 0.79646881]
mean [0.44641419 0.446364  ]
median [0.47136818 0.46015996]
sort [[0.17921251 0.30153261 0.06144976 0.10203327 0.61220888]
 [0.79646881 0.56586623 0.47136818 0.46015996 0.91359077]]

a.nonzero()输出所有非零元素的下标，输出结果为一个tuple，共维数个array，表示所有元素的每一维下标

a.clip(min,max)将小于min值的设为min值，大于max值的设为max值，返回为新的array

 a = np.arange(0,16).reshape((2,2,2,2))
 print(a)
 print(a.nonzero())
 print(np.zeros(10).nonzero())

[[[[ 0  1]
   [ 2  3]]

  [[ 4  5]
   [ 6  7]]]

 [[[ 8  9]
   [10 11]]

  [[12 13]
   [14 15]]]]
(array([0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int64), array([0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1], dtype=int64), array([0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1], dtype=int64), array([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], dtype=int64))
(array([], dtype=int64),)

 a = np.random.random((2,5))
 print(a)
 print(a.clip(0.25,0.75))

[[0.13959892 0.82723864 0.46736009 0.81501597 0.73909778]
 [0.93349076 0.46512676 0.49638509 0.81460657 0.98483514]]
[[0.25       0.75       0.46736009 0.75       0.73909778]
 [0.75       0.46512676 0.49638509 0.75       0.75      ]]

a.flatten()将a所有元素列成一个一维array

a.flat a的迭代器

 a = np.arange(0,6).reshape((2,3))
 print(a)
 print(a.flatten())
 for item in a.flat:
     print(item)

[[0 1 2]
 [3 4 5]]
[0 1 2 3 4 5]
0
1
2
3
4
5

a[np.newaxis]将原对象作为一个元素放进一个array里，即在最外面加了一维

a[:[,:],np.newaxis]按照np.newaxis之前的切片表示的遍历最小元素，将每个元素放进一个array

这种操作都没有产生新的对象

 a = np.arange(0,6)
 print(a[np.newaxis])
 print(a[:,np.newaxis])
 a[np.newaxis][0][1] = 0
 print(a)
 print("a[np.newaxis][0][1] is a?",a[np.newaxis][0][1] is a)
 b = np.arange(0,6).reshape((2,3))
 print("1: ", b[np.newaxis])
 print("2: ", b[:,np.newaxis])
 print("3: ", b[:,:,np.newaxis])

[[0 1 2 3 4 5]]
[[0]
 [1]
 [2]
 [3]
 [4]
 [5]]
[0 0 2 3 4 5]
a[np.newaxis][0][1] is a? False
1:  [[[0 1 2]
  [3 4 5]]]
2:  [[[0 1 2]]

 [[3 4 5]]]
3:  [[[0]
  [1]
  [2]]

 [[3]
  [4]
  [5]]]

np.vstack(ndarray a, ndarray b[,...])将a、b整体进行连接，合成一个ndarray，要求a和b除第一维外其余维一样，合并后得到的第一维为a、b的第一维相加，第二维shape不变

np.hstack(ndarray a, ndarray b[,...])将a、b的每一个第一维元素进行连接，合成一个ndarray，要求第二维外其余维一样，合并后第二维为a、b的第二维相加，其余维不变

np.concatenate((ndarray a, ndarray b[,...]),axis=0)可以自由定义以第几维进行连接，除指定维外其余维一样

对于一维array，运算时当做1*n的array进行连接，运算完h连接会产生1*2n的array，仍变成一维的长2n的array，而v连接产生2*n的array

连接操作均返回新的对象

 a = np.arange(0,6).reshape((2,3))
 b = np.arange(6,12).reshape((2,3))
 print("a: ", a)
 print("b: ", b)
 print("vab: ", np.vstack((a,b)))
 print("hab: ", np.hstack((a,b)))
 print(a.shape,b.shape,np.vstack((a,b)).shape)
 print(a.shape,b.shape,np.hstack((a,b)).shape)
 a = np.arange(0,6)
 b = np.arange(6,12)
 print("a: ", a)
 print("b: ", b)
 print("vab: ", np.vstack((a,b)))
 print("hab: ", np.hstack((a,b)))
 print(a.shape,b.shape,np.vstack((a,b)).shape)
 print(a.shape,b.shape,np.hstack((a,b)).shape)
 a = np.arange(0,6).reshape((1,6))
 b = np.arange(6,12).reshape((1,6))
 print("a: ", a)
 print("b: ", b)
 print("vab: ", np.vstack((a,b)))
 print("hab: ", np.hstack((a,b)))
 print(a.shape,b.shape,np.vstack((a,b)).shape)
 print(a.shape,b.shape,np.hstack((a,b)).shape)

a:  [[0 1 2]
 [3 4 5]]
b:  [[ 6  7  8]
 [ 9 10 11]]
vab:  [[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
hab:  [[ 0  1  2  6  7  8]
 [ 3  4  5  9 10 11]]
(2, 3) (2, 3) (4, 3)
(2, 3) (2, 3) (2, 6)
a:  [0 1 2 3 4 5]
b:  [ 6  7  8  9 10 11]
vab:  [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
hab:  [ 0  1  2  3  4  5  6  7  8  9 10 11]
(6,) (6,) (2, 6)
(6,) (6,) (12,)
a:  [[0 1 2 3 4 5]]
b:  [[ 6  7  8  9 10 11]]
vab:  [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
hab:  [[ 0  1  2  3  4  5  6  7  8  9 10 11]]
(1, 6) (1, 6) (2, 6)
(1, 6) (1, 6) (1, 12)

 a = np.arange(0,6).reshape((2,3))
 b = np.arange(6,10).reshape((2,2))
 print("a: ", a)
 print("b: ", b)
 print("hab: ", np.hstack((a,b)))
 print(a.shape,b.shape,np.hstack((a,b)).shape)
 a = np.arange(0,6).reshape((3,2))
 b = np.arange(6,10).reshape((2,2))
 print("a: ", a)
 print("b: ", b)
 print("vab: ", np.vstack((a,b)))
 print(a.shape,b.shape,np.vstack((a,b)).shape)
 a = np.arange(0,12).reshape((2,2,3))
 b = np.arange(12,20).reshape((2,2,2))
 print("a: ", a)
 print("b: ", b)
 print("cab-2: ", np.concatenate((a,b),axis=2))
 print(a.shape,b.shape,np.concatenate((a,b),axis=2).shape)

a:  [[0 1 2]
 [3 4 5]]
b:  [[6 7]
 [8 9]]
hab:  [[0 1 2 6 7]
 [3 4 5 8 9]]
(2, 3) (2, 2) (2, 5)
a:  [[0 1]
 [2 3]
 [4 5]]
b:  [[6 7]
 [8 9]]
vab:  [[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
(3, 2) (2, 2) (5, 2)
a:  [[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
b:  [[[12 13]
  [14 15]]

 [[16 17]
  [18 19]]]
cab-2:  [[[ 0  1  2 12 13]
  [ 3  4  5 14 15]]

 [[ 6  7  8 16 17]
  [ 9 10 11 18 19]]]
(2, 2, 3) (2, 2, 2) (2, 2, 5)

 a = np.arange(0,6)
 b = np.arange(6,12)
 np.hstack((a,b))[0] = 100
 np.hstack((a,b))[6] = 100
 print(a)
 print(b)

[0 1 2 3 4 5]
[ 6  7  8  9 10 11]

np.vsplit(ndarray a, b)将a对第一维进行拆分成b等份

np.hsplit(ndarray a, b)将a对第二维进行拆分成b等份

np.split(ndarray a, b, axis=0)将a对指定的维度进行拆分成b等份

np.array_split(ndarray a, b, axis=0)将a对指定的维度进行拆分成b份，允许不等分，此时会尽量均等，多出部分从前到后分配

 a = np.arange(6).reshape((2,3))
 print(a)
 print(np.vsplit(a,2))
 print(np.hsplit(a,3))
 print(np.split(a,2,axis=0))
 print(np.split(a,3,axis=1))
 print(np.array_split(a,2,axis=1))

[[0 1 2]
 [3 4 5]]
[array([[0, 1, 2]]), array([[3, 4, 5]])]
[array([[0],
       [3]]), array([[1],
       [4]]), array([[2],
       [5]])]
[array([[0, 1, 2]]), array([[3, 4, 5]])]
[array([[0],
       [3]]), array([[1],
       [4]]), array([[2],
       [5]])]
[array([[0, 1],
       [3, 4]]), array([[2],
       [5]])]

np.empty_like( array x )：返回一个大小和类型与x相同的array，但其中内容并未初始化，可能为随机值

np.zeros_like( array x )：返回一个大小与x相同，但元素全为 0 的array

np.ones_like( array x )：返回一个大小与x相同，但元素全为 1 的array

np.tile( array x, tuple shape)：返回一个大小为 x 的维分别于 shape 的维相乘的 array，即将 x copy了 shape遍。