Numpy的基本用法_numpy的全程是?

前言

Numpy是一个python用来处理数学问题的包，全程是Numerical Python。
其最重要的一点就是，提供了n维数组，弥补了list的不足。
而且Numpy还有一个优势，就是快。它可以利用矩阵的计算优化，比用for循环计算要快很多。

数据类型

在深度学习中，常见的就是数据有

• 零维数据，也就是一个数，俗称标量
• 一维数据，也就是一列数，俗称向量。一般用于描述特征。
• 二维数据，一个矩阵，比如一张图片
• 三维数据，多个矩阵。常常出现在batch训练中，一维batch，另外两维就是图片。

创建数组

有多种方式，最常见的一种方式就是用list生成。
此外Numpy也提供了别的生产方式包括随机生成，线性生成等。

list方式

nd1 = np.array([[1,2,3],[4,5,6]])
#[[1 2 3]
# [4 5 6]]
1
2
3

随机生成

这个非常重要，特别是正态分布的随机生成，因为在神经网络的初始过程中，常常需要使用这个。

nd2 = np.random.randn(3,4)#正态分布随机数，在神经网络初始值的时候非常重要
nd3 = np.random.random([4,8])

#[[-0.10173459 -0.54538422 -0.29352747  0.50820633]
# [-0.71678867  0.84748088  0.53617277  0.9507533 ]
# [-0.51062093  0.36694861  0.19478153 -1.12682578]]
#[[0.09053044 0.49628049 0.97283994 0.90603421 0.12833269 0.80542632 0.0449014  0.54654473]
# [0.93020989 0.82291035 0.65991494 0.8846432  0.2886918  0.14652968 0.64752396 0.00876962]
# [0.7109207  0.46917494 0.38844244 0.43906524 0.34592282 0.44015401  0.27424505 0.11715678]
# [0.62527117 0.75357782 0.23492603 0.42408179 0.77642505 0.45620374 0.60924712 0.98498708]]
1
2
3
4
5
6
7
8
9
10

特殊矩阵

例如全是0的矩阵，全1矩阵，对角阵。

nd1 = np.zeros([3 , 4]) #全是0
nd2 = np.ones([3,4])#全是1
nd3 = np.diag([1,2,3])
1
2
3

线性生成

这个和matlab非常像，提供有部分函数。

print(np.arange(10))
print(np.arange(1,4,0.5)) #开始，结束，步长
print(np.linspace(0,1,10)) #开始，结束，点的数量
#[0 1 2 3 4 5 6 7 8 9]
#[1.  1.5 2.  2.5 3.  3.5]
#[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 0.66666667 0.77777778 0.88888889 1.        ]
1
2
3
4
5
6

数据读取

通过:，-1就可以完成所需要的操作。

nd = np.arange(25).reshape(5,5)
print(nd)
print(nd[0:2,:])
print(nd[:,2])
print(nd[3:,2:])
print(nd[2::2,::2])
1
2
3
4
5
6

运行结果：

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
[[0 1 2 3 4]
 [5 6 7 8 9]]
[ 2  7 12 17 22]
[[17 18 19]
 [22 23 24]]
[[10 12 14]
 [20 22 24]]
1
2
3
4
5
6
7
8
9
10
11
12

乘法运算

有两种乘法，一种是对应元素相乘（需要两个矩阵大小相同），另一个就是矩阵乘法。

A = np.arange(4).reshape(2,2)
B = np.arange(8).reshape(2,4)
C = np.arange(4).reshape(2,2)
print(A*C)
print(np.dot(A , B))
1
2
3
4
5

运行结果

[[0 1]
 [4 9]]
[[ 4  5  6  7]
 [12 17 22 27]]
1
2
3
4

改变矩阵形状

这一点非常重要，比如说在图片识别，往往需要将一个二维的图片，转换成一个一维向量。

#reshape不改变数组本身
#resize改变数组
A = np.arange(10)
print(A.reshape(2,5))
A.resize(2,4)
print(A)
A = A.transpose(1,0)
print(A)
print(A.flatten())
1
2
3
4
5
6
7
8
9

运行结果

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

通过一个例子可以更好地理解reshare，它不会重新复制一遍整个数组，而是一个指针。

aa = numpy.arange(12)
bb = aa.reshape((3,4))
print(bb)
bb[:] = 111
print(aa)
1
2
3
4
5

运行结果

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

在修改bb之后会导致aa全部被修改，这也就是指针是特性。
从数据库的角度来看，aa就是概念模式，bb就是一个外模式。