Numpy 初认识

发表于   |   分类于

Numpy 最核心的就是 Numpy Array，在 python 中是没有数组类型的，而 Numpy 提供了一个数组类型，与 python 中的 List 类型非常相似。

Numpy Array 有啥用呢？

List 是列表，可通过索引查找数值，但不能对整个列表进行数值运算。Numpy Array 是数组，既可以通过索引值查找数据，也能对整个数组进行数值运算。

所以 Numpy Array 的计算速度要比 List 快很多，在需要使用 List 进行运算时，均可以使用 Numpy Array进行代替。

什么是 Numpy

举个栗子。下面是常见的关于 python 中 list 的一个写法：

1
2
3
4
5
6
7
8
import numpy as np

def main():
    lst = [[1,3,5],[2,4,6]]
    print(type(lst)) // <class 'list'>

if __name__ == "__main__":
    main()

list 在处理对象时会进行类型的判断，如果符合则进行xxx操作，不符合进行yyy操作。List 中的元素可以是不同类型的数据，缺点是维护成本高，速度较慢慢。

而 Numpy 为了提高运算速度，减少了存放数据的种类，只能存放唯一种类的数据。

1
2
3
4
5
lst = [[1,3,5],[2,4,6]]
print(type(lst))  #<class 'list'>
    
np_lst=np.array(lst)
print(type(np_lst)) #<class 'numpy.ndarray'>

Numpy 只能存储一种数据类型，定义方法如下：

1
np_lst=np.array(lst,dtype=np.float)

上述代码就定义了只能存储 float 类型的 Numpy 数组。此外，还可以存储多种类型，例如：

  • bool
  • int
  • int8/16/32/64/128
  • uint8/32/64/128
  • float16/32/64
  • complex64/128

Numpy Array 是 Numpy 中最基础的数据结构。

Numpy 数组常用属性

shape: 行列数
ndim: 数组维数
dtype: 数组中元素的数据类型
itemsize: 每个元素的字节大小
size：数组中的元素个数 

1
2
3
4
5
6
7
8
lst = [[1,3,5],[2,4,6]]
np_lst=np.array(lst)

np_lst.shape #(2,3)
np_lst.ndim #2
np_lst.dtype #float64
np_lst.itemsize #8
np_lst.size #6

Numpy 数组常用方法

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
28
29
30
31
32
33
34
35
36
# 值为0的数组
np.zeros([2,4])

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]
 
# 值为1的数组
np.ones([2,4]
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
 
# 值为随机数的数组(取值0-1之间)
np.random.rand(2,4)
[[0.40699653 0.48819092 0.55153841 0.78344092]
 [0.19476882 0.31611925 0.43682693 0.14378682]]

# 随机数
np.random.rand()
0.673129191973459

# 随机整数，参数分别为最小值、最大值、个数
np.random.randint(1,10,3)
[9 5 7]

# 正态分布随机数数组
np.random.randn(2,4)
[[-0.31813846 -0.20958807 -0.40196708 -1.75003327]
 [ 0.36915948  1.28419756  0.88562666  1.77710958]]
 
# 指定列表中的随机数
np.random.choice([10,20,30])
30

# 常见数据分布：贝塔分布、狄利克雷分布等
np.random.beta(1,10,3)
[8.41031036e-02 8.21348951e-05 1.85007007e-02]

Numpy 数组常用操作

可将 Numpy 数组进行操作，转换为需要的格式。

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
28
29
30
31
32
33
34
35
36
37
38
# 一维连续数组
np.arange(1,11)
// [ 1  2  3  4  5  6  7  8  9 10]

# 修改行列个数
np.arange(1,11).reshape([2,-1])
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
 
 
# 转换为自然指数形式
lst = np.arange(1,11).reshape([2,-1])
np.exp(lst)
[[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
  1.48413159e+02]
 [4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03
  2.20264658e+04]]
  
  
# 转换为以2为底的对数
np.exp2(lst) 
[[   2.    4.    8.   16.   32.]
 [  64.  128.  256.  512. 1024.]]

# 转换为平方形式
np.sqrt(lst)
[[1.         1.41421356 1.73205081 2.         2.23606798]
 [2.44948974 2.64575131 2.82842712 3.         3.16227766]]
 
# 转换为sin形式
np.sin(lst)
[[ 0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427]
 [-0.2794155   0.6569866   0.98935825  0.41211849 -0.54402111]]
 
# 转换为log底数形式
np.log(lst)
[[0.         0.69314718 1.09861229 1.38629436 1.60943791]
 [1.79175947 1.94591015 2.07944154 2.19722458 2.30258509]]

可将 Numpy 数组进行操作，转换为需要的格式。

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
28
29
30
31
32
33
34
lst = np.array([[[1, 2, 3, 4],
                 [4, 5, 6, 7]],
                [[7, 8, 9, 10],
                 [10, 11, 12, 13]],
                [[14, 15, 16, 17],
                 [18, 19, 20, 21]]])

# 求和
lst.sum()
252

# 求和，指定维数，axis代表维数，维数越高越深入(从外向内数)
lst.sum(axis=0)
[[22 25 28 31]
 [32 35 38 41]]
 
lst.sum(axis=1)
[[ 5  7  9 11]
 [17 19 21 23]
 [32 34 36 38]]

lst.sum(axis=2)
[[10 22]
 [34 46]
 [62 78]]
 
# 最大值/最小值
lst.max(axis=1)
[[ 4  5  6  7]
 [10 11 12 13]
 [18 19 20 21]]
lst.min(axis=0)
[[1 2 3 4]
 [4 5 6 7]]

多个数组操作：

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
lst1 = np.array([10, 20, 30, 40])
lst2 = np.array([4, 3, 2, 1])

# 加法
lst1+lst2
[14 23 32 41]

# 减法
lst1-lst2
[ 6 17 28 39]

# 乘法
lst1*lst2
[40 60 60 40]

# 除法
lst1/lst2
[ 2.5  6.66666667 15. 40. ]

# 平方
lst1**2
[ 100  400  900  1600 ]

# 矩阵点乘
np.dot(lst1.reshape([2,2]),lst2.reshape([2,2]))
[[ 80  50]
 [200 130]]

追加（类似 list 中的加法）、拼接与拆分元素，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
lst1 = np.array([10, 20, 30, 40])
lst2 = np.array([4, 3, 2, 1])

# 左右拼接
np,concatenate((lst1,lst2),axis=0)
[10 20 30 40  4  3  2  1]

np.hstack((lst1,lst2))
[10 20 30 40  4  3  2  1]

# 上下拼接
np.vstack((lst1,lst2))
[[10 20 30 40]
 [ 4  3  2  1]]
 
# 拆分
np.split(lst1,2)
[array([10, 20]), array([30, 40])]

# 拷贝
np.copy(lst1)
[10 20 30 40]

矩阵操作与线性方程组

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
from numpy.linalg import *

# 生成一个矩阵
np.eye(3)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
 
 
lst = np.array([[1., 2.],
                [3., 4.]])
# 逆矩阵
inv(lst)
[[-2.   1. ]
 [ 1.5 -0.5]]
 
# 转置矩阵
lst.transpose()
[[1. 3.]
 [2. 4.]]
 
# 行列式
det(lst)
-2.0

# 特征值和特征向量
eig(lst)
(array([-0.37228132,  5.37228132]), array([[-0.82456484, -0.41597356],
       [ 0.56576746, -0.90937671]]))

# 求解方程
lst = np.array([[1., 2.],
                [3., 4.]])
y=np.array([[5.],[7.]])

求解下列方程
x+2y = 5
3x+4y = 7

solve(lst,y)
[[-3.]
 [ 4.]]

Numpy 的其他应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# fft（信号处理领域）
np.fft.fft(np.array([1,1,1,1,1]))
[5.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]

# 皮尔逊相关系数
np.corrcoef([1,0,1],[0,2,1])
[[ 1.        -0.8660254]
 [-0.8660254  1.       ]]


# 生成一元多次函数
np.poly1d([2,1,3])
   2
2 x + 1 x + 3