XieNaoban's Blog
0%

NumPy基础操作

发表于 更新于 阅读次数： 评论次数：
本文字数： 3.5k 阅读时长 ≈ 3 分钟

学机器学习做点小笔记，都是Python的NumPy库的基本小操作，图书馆借的书看到的，怕自己还了书后忘了，就记下来。

一般习惯导入numpy时使用 import numpy as np ，不要直接import，会有命名空间冲突。比如numpy的array和python自带的array。

numpy下有两个可以做矩阵的东西，一个叫matrix，一个叫array。matrix指定是二维矩阵，array任意维度，所以matrix是array的分支，但是这个matrix和matlab的矩阵很像，操作也很像：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> import numpy as np
>>> a=np.mat('4 3; 2 1')  # 使用字符串来初始化
>>> b=np.mat('1 2; 3 4')
>>> a
matrix([[4, 3],
        [2, 1]])
>>> b
matrix([[1, 2],
        [3, 4]])
>>> a+b  # 对应位置相加
matrix([[5, 5],
        [5, 5]])
>>> a*b  # 矩阵乘法，与matlab相同
matrix([[13, 20],
        [ 5,  8]])
>>> np.multiply(a,b)  # 对应位置乘法，相当于matlab的点乘 “.*”
matrix([[4, 6],
        [6, 4]])

而重点讲讲np.array。

#np.array操作 ###首先是初始化与属性查看 

1
2
3
4
5
6
7
8
9
10
11
12
>>> import numpy as np
>>> np.arange(10)  # 从零生成到10-1的一维矩阵
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a=np.array([0,1,2,3,4,5])  # 因为支持多维，所以用数组来初始化
>>> a
array([0, 1, 2, 3, 4, 5])
>>> a.ndim  # 查看维度
1
>>> a.shape  # 查看矩阵形状尺寸
(6,)
>>> a.dtype  # 查看类型
dtype('int32')

###reshape改变矩阵形状，可以改变维度，但是reshape后的数据还是共享原来那一份数据 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> b=a.reshape(3,2)
>>> b
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> b.ndim
2
>>> b.shape
(3, 2)

>>> b[1][0]=77
>>> b
array([[ 0,  1],
       [77,  3],
       [ 4,  5]])
>>> a
array([ 0,  1, 77,  3,  4,  5])  # 可见b和a其实用的同一个数据

###因而要产生的新矩阵不再关联，要使用copy()： 

1
2
3
4
5
6
7
8
9
10
11
12
>>> c=a.reshape(3,2).copy()
>>> c
array([[ 0,  1],
       [77,  3],
       [ 4,  5]])
>>> c[0][0]=233
>>> a
array([ 0,  1, 77,  3,  4,  5])
>>> c
array([[233,   1],
       [ 77,   3],
       [  4,   5]])

###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
28
29
30
31
32
33
34
35
36
37
38
39
40
>>> d=np.array([1,2,3,4,5])  # 一维矩阵运算
>>> d.T  # 转置矩阵
array([1, 2, 3, 4, 5])
>>> d*2  # 每个数据乘以2
array([ 2,  4,  6,  8, 10])
>>> d**2  # 每个数据二次方
array([ 1,  4,  9, 16, 25])
>>> d*d   # 按位置乘，与“d**2”等效，和mat正好相反
array([ 1,  4,  9, 16, 25])
>>> d.dot(d)  # 矩阵乘法，和mat相反
55


>>> x=np.array([[1,2],[3,4],[5,6]])  # 二维矩阵运算
>>> y=np.array([[6,5,4],[3,2,1]])
>>> x
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> y
array([[6, 5, 4],
       [3, 2, 1]])

>>> x.dot(y)  # 二维矩阵矩阵乘法
array([[12,  9,  6],
       [30, 23, 16],
       [48, 37, 26]])
>>> x= x.reshape(2,3)
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x*y  # 按位置乘，要求两个矩阵shape相同
array([[ 6, 10, 12],
       [12, 10,  6]])
>>> x.T  # 二维矩阵的转置矩阵
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> x.mean()  # 求平均值
3.5

###关于下标的运算：（这些挺有意思的） 

1
2
3
4
5
6
7
8
9
10
11
12
>>> a=np.array([5,4,3,233,9])
>>> a[np.array([2,4,3])]  # 列出对应下标的数值
array([  3,   9, 233])
>>> a>4
array([ True, False, False,  True,  True], dtype=bool)
>>> a[a>4]
array([  5, 233,   9])
>>> a[a>8]=8
>>> a
array([5, 4, 3, 8, 8])
>>> a.clip(4,5)  # 限定所有数据范围
array([5, 4, 4, 5, 5])

###还有一个关于nan的 

1
2
3
4
5
6
7
8
9
10
>>> a=np.array([1,2,0,3,4])
>>> a
array([1, 2, 0, 3, 4])
>>> b=np.array([1,2,np.NAN,3,4])
>>> b
array([  1.,   2.,  nan,   3.,   4.])  # 和a不同，虽然只改了一个nan，b每个数据后面有个“.”，说明变成float型了，说明nan其实是个float
>>> np.isnan(b)
array([False, False,  True, False, False], dtype=bool)
>>> b[~np.isnan(b)]
array([ 1.,  2.,  3.,  4.])

#与系统自带array的差异

###array的乘法 

1
2
3
4
>>> [1,2,3,4,5]*2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> [1,2,3,4,5]**2
(报错)

###运行时间 对array和np.array进行按元素平方并求和的运算，运算3000次统计时间。 

1
2
3
4
5
6
>>> timeit.timeit('sum(x*x for x in range(1000))',number=3000)
0.31559807779291305
>>> timeit.timeit('sum(na*na)', setup='import numpy as np; na=np.arange(1000)',number=3000)
0.37785958035067324
>>> timeit.timeit('na.dot(na)', setup='import numpy as np; na=np.arange(1000)',number=3000)
0.0069067372806728144
惊奇的发现系统级的array求和比np.array还快，说明np.array单个数据的访问还是比array较慢。但是用了矩阵乘法后，虽然效果一样，但这个速度就飞起来了。