转载!python 中 Numpy包

Numpy是Python的一个能快速处理矩阵运算的数学库,如果你从事的是数据科学,或者机器学习领域的话,Numpy是一项最基本的技能。他不仅简化了我们在处理矩阵运算时需要编写的代码,而且,许多Numpy的底层函数用C编写,我们能获得在用普通Python自带的列表结构时,所无法达到的运算速度。

下面,我将就Numpy的一些基本用法,做个简单的介绍,当然,一来Numpy库本身会不断更新,二来,我本人的认知也会随时间改变,所以,这部分内容也会随时更新。当然一些我认为不太常用的方法、结构,不会出现在本文中,使得本文尽量简洁明了。

因为Numpy并不是Python本身自带的库,所以,使用之前,当然需要先安装,具体的方法,百度一下会有很多,我在此就略了。所以,我默认所有对这部分内容感兴趣的人都已经安装好了Numpy,并且有一定的Python语言基础。需要注意的是,为了使得文中的代码尽量简洁,所有出现的代码都默认已经引入了Numpy库,并简写为np。也就是说,所有代码都默认在它们之前导入了numpy库:import numpy as np

创建数组

  1. np.array() 函数创建数组

Numpy为我们提供的创建数组的方法可以说非常丰富,针对某些特殊类型的数组还有专门的函数,但是基本上讲,有以下三种:

(1) Numpy中的数组类型——ndarray

a = np.array([1, 2, 3]) # >>> [1 2 3]
b = np.array((1, 2, 3.5)) # >>> [1. 2. 3.5]
print(type(a), type(b)) # >>>

定义函数,这里的函数只有1个参数

def foo1(i):
return i % 2

注意fromfunction()中,第2个参数shape的输入形式是元组

a = np.fromfunction(foo1, (2,)) # >>> [ 0. 2.]

b = np.fromfunction(lambda x, y: x + y, (2, 3)) # >>> [[ 0. 1. 2.]
[ 1. 2. 3.]]
1
2
3
4
5
6
7
8
9
(5)np.zeros(),np.ones(),np.eye()等方法可以构造特定的矩阵

上面这3个函数分别用来构造零矩阵;元素全为1的矩阵,以及单位矩阵(主对角线为1,其余元素为0)。他们的作用是帮助我们对这些特殊的矩阵实现快速构造。

参数为数组形状

a = np.zeros((2, 3)) # >>> [[ 0. 0. 0.]
[ 0. 0. 0.]]
b = np.ones((2, 3)) # >>> [[ 1. 1. 1.]
[ 1. 1. 1.]]

参数为方阵的行数(列数)

c = np.eye(3) # >>> [[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
1
2
3
4
5
6
7
8
9
10
3. 给矩阵添加行或列

有时,需要我们在已有的矩阵中,添加一行,或者一列。这里主要介绍2种实现方法。

(1)np.r_[]和np.c_[]分别添加行和列,生成新的矩阵:

如下代码所示,现在要在矩阵a中添加一行

a1 = np.array([[1, 2, 3], [4, 5, 6]])
b1 = np.array([[0, 0, 0]])

print(np.r_[a1, b1]) # >>>[[1 2 3]
[4 5 6]
[0 0 0]]
1
2
3
4
5
6
注意此时b1的写法,也是一个二维矩阵,且列数与a相等。再比如,添加一列:

a1 = np.array([[1, 2], [3, 4], [5, 6]])
b1 = np.array([[0], [0], [0]])

print(np.c_[a1, b1]) # >>>[[1 2 0]
[3 4 0]
[5 6 0]]
1
2
3
4
5
6
同样,需要注意此时b1的写法。

(2)np.row_stack()和np.column_stack()分别添加行和列,生成新的矩阵:

还有两个与np.r_[]和np.c_[]类似的函数:np.row_stack()和np.column_stack()。但是它们的用法更加自由,所添加的行或列,要求只要是序列(也就是说列表,元组皆可)就行,不需要像np.r_[]和np.c_[]那样严格要求添加的东西必须是数组了。具体用法网上容易查到,此处省略。

此外,还有一些别的创建数组的方法,限于篇幅,不再介绍了,若遗漏了重要的方法,会随时补充。

访问数组

  1. 切片

与列表的性质类似,通过切片的形式,可以访问已经构建好的数组。

比如对于一维数组:

a = np.arange(5) # >>> [0 1 2 3 4]
print(a[2:3]) # >>> [2]
print(a[::2]) # >>> [0 2 4]
1
2
3
语法规则与列表中的切片一致,包含起始点,且不包含终止点。需要注意的是,这种数组切片返回的是原始数组的一个视图,与原始数组共享相同的内存空间,而并没有建立新的数组。

a = np.arange(5) # >>> [0 1 2 3 4]
print(id(a[2])) # >>> 4366848312
print(id(a[2:3][0])) # >>> 4366848312
1
2
3
2. 访问矩阵的行与列

在切片的方法中,我要特别强调一个细节,就是对矩阵行、列的访问。因为这个知识点经常用到,所以特地列一小节出来。但是基本方法就是切片了。

访问矩阵的行
a = np.array([[1, 2, 3], [4, 5, 6]])

访问矩阵第0行

print(a[0]) # >>> [1 2 3]

访问矩阵第0行的0,1两列

print(a[0][:2]) # >>> [1 2]
1
2
3
4
5
6
7
访问矩阵的列
a = np.array([[1, 2, 3], [4, 5, 6]])

取矩阵a第2列

print(a[:, 2]) # >>> [3 6]
1
2
3
4
当然,这是取全列,你也可以根据切片控制某一列中,行的范围,具体做法跟上面的取一行时一致。

  1. for循环遍历矩阵

如果要遍历整个矩阵,for循环是非常合适的选择。

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

for循环遍历行

for row in a:
print(row) # >>> [1 2 3]
# >>> [4 5 6]
# >>> [7 8 9]

for循环遍历列

for col in np.transpose(a):
print(col) # >>> [1 4 7]
# >>> [2 5 8]
# >>> [3 6 9]
1
2
3
4
5
6
7
8
9
10
11
12
13
np.transpose()是计算矩阵转置的函数,这个后面会说。

  1. 使用整数序列访问

其实最简单的访问数组单个元素的做法是通过元素的下标(包括多维数组也是一样)。这一点我在上面虽然没有强调,但是早开始这么用了。但是当现在的任务变成访问数组中个别几个位置的元素,而这些位置又是毫无规律的(不太方便使用切片),那也可以方便地使用整数序列作为下标解决这个问题。

a = np.arange(0, 20, 2) # >>> [ 0 2 4 6 8 10 12 14 16 18]

直接通过数组np.array([1, 4, 5, 7]),访问1, 4, 5, 7位的元素

print(a[np.array([1, 4, 5, 7])]) # >>> [ 2 8 10 14]
1
2
3
4
也可以通过列表建立要访问的下标序列,但是需要先通过一个名称引用这个列表

b = np.array([[1, 2, 3], [4, 5, 6]]) # 二维数组

访问第一行的第0列,第1列;访问第2行的第1列,第2列

index = [[0, 1], [1, 2]]
print(b[index]) # >>> [2 6]
1
2
3
4
5
然而需要注意一下,这里不能用ndarray型对象的引用作为下标,因为解释器会认为应该在数组的第一行取值

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

index1 = np.array([[0, 1], [1, 2]])
index2 = np.array([[0, 1], [1, 0]])
index3 = [[0, 1], [1, 0]]

print(b[index1]) # >>> wrong!因为范围超了,index1中的元素2会让解释器寻找b的第2行,找不到

print(b[index2]) # >>> [[[1 2 3]
[4 5 6]]

                    [[4 5 6]
                     [1 2 3]]]

print(index3) # >>> [2 4],第0行第1列,以及第1行,第0列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
上面的东西看上去“规矩”很多,其实用的时候最好直接引用建立好的列表就行,这样最方便。再者,就是临时写个小脚本试一下,最稳妥。

  1. 通过布尔数组访问

这是一种非常特殊的方法,举个例子来说,如下:

a = np.arange(12).reshape(3, 4) # 建立了一个3 x 4的矩阵

b是一个布尔数组,这个布尔数组与a形状相同,其中每个元素表示a中对应位置的元素是否比4大

b = a > 4 # >>> b = [[False False False False]
[False True True True]
[ True True True True]]
print(a[b]) # >>> [ 5 6 7 8 9 10 11]
1
2
3
4
5
6
7
也可以通过布尔数组来选择一个数组的行和列

a = np.arange(12).reshape(3, 4)
b1 = np.array([False, True, True])
b2 = np.array([False, True, True, False])

按bool属性取行

print(a[b1,:]) # >>> [[ 4 5 6 7]
[ 8 9 10 11]]

按bool属性取列

print(a[,:b2]) # >>> [[ 1 2]
[ 5 6]
[ 9 10]]
1
2
3
4
5
6
7
8
9
10
11
12
线性代数运算

这是Numpy最吸引人的地方了。我们常见的矩阵、向量的运算基本在Numpy中都能找到现成的函数,为快速开发提供了可能。操作中,”ndarray”型对象既然可以表示多维数组,那么当然也可以表示我们最常用的矩阵。实际上,Numpy中,我们对矩阵操作时,用”ndarray”型对象的频率甚至高过了标准的矩阵对象”np.matrix()”.

1. 矩阵转置

ndarray.transpose()函数直接生成转置矩阵

a = np.array([[1, 2],[3, 4]])

print(a.transpose()) # [[1 3]
[2 4]]
1
2
3
4

2. 矩阵的迹

np.trace()函数输出矩阵的迹,即方阵主对角线上元素之和。若所要计算迹的矩阵非方阵,则计算行列序相等的元素之和。

a = np.array([[1, 2],[3, 4]])
b = np.array([[1, 2, 3],[4, 5, 6]])

print(np.trace(a)) # >>> 5
print(np.trace(b)) # >>> 6(由1 + 5生成的)
1
2
3
4
5

3. 矩阵乘法

np.dot(a, b)表示两个矩阵之间的乘法,在Python3中,一个更简单的符号@表示矩阵之间的乘运算。注意:符号*不能表示ndarray对象之间相乘。

a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[1, 2], [3, 4], [5, 6]])
print(np.dot(a, b)) # >>> [[22 28]
[49 64]]
print(np.transpose(b) @ np.transpose(a)) # >>> [[22 49]
[28 64]]
1
2
3
4
5
6

4. 矩阵的加减、数乘

+, -, *, /这些运算符能直接执行矩阵的基本运算,当然,都是按元素进行的。其中乘法特指数乘,跟我们用的最多的矩阵乘法不同。

a = np.array([[1, 2, 3],[4, 5, 6]])
b = np.array([[6, 5, 4],[3, 2, 1]])

矩阵对应元素做加减
print(a + b) # >>> [[7 7 7]
[7 7 7]]

print(a - b) # >>> [[-5 -3 -1]
[ 1 3 5]]

矩阵所有元素与某数相乘
print(a * 2) # >>> [[ 2 4 6]
[ 8 10 12]]

矩阵所有元素的次幂
print(a ** 2) # >>> [[ 1 4 9]
[16 25 36]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
5. 随机矩阵

子库random用于生成随机的数组、矩阵等等。这里我简略举2个例子,用法跟标准库中的random模块类似,具体可以查阅相关文档。

np.random.rand(a, b)函数用来生成a行b列的矩阵,矩阵中每个元素都是随机的浮点数,范围在[0,1)。
a = np.random.rand(2, 3) # >>> [[ 0.23600569 0.62347282 0.84519854]
[ 0.85702323 0.10537731 0.59344112]]
1
2
np.random.randint(low, high, size)函数用来生成形状为size的随机矩阵,其中,矩阵的每一个元素都是整数,且范围在[low,high)之间。
a = np.random.randint.rand(0, 10, (2, 3)) # >>> [[7 0 9]
[5 4 7]]
1
2

5. 矩阵的逆与计算行列式

Numpy的线性代数子库linalg也是需要了解一下的,它有两个特别重要的应用:求取矩阵的逆;计算行列式

矩阵求逆:np.linalg.inv(ndarray)
a = np.random.randint(0, 10, (3, 3)) # >>> [[7 1 5]
[7 8 1]
[0 3 0]]

print(np.linalg.inv(a)) # >>> [[-0.03571429 0.17857143 -0.46428571]
[ 0. 0. 0.33333333]
[ 0.25 -0.25 0.58333333]]
1
2
3
4
5
6
7
计算行列式:np.linalg.det(ndarray)
a = np.random.randint(0, 10, (3, 3)) # >>> [[2 6 3]
[8 5 4]
[2 8 0]]

print(np.linalg.det(a)) # >>> 146
1
2
3
4
5

6. 向量的最大最小值、加和、平均值、范数

实现这些对向量的运算代码如下:

a = np.random.randint(0, 10, (1,)) # >>> [6 5 1 4 5 9 8 9 0 0]

print(np.sum(a)) # >>> 47
print(np.max(a)) # >>> 9
print(np.min(a)) # >>> 0
print(np.average(a)) # >>> 4.7
print(np.linalg.norm(a)) # >>> 18.1383571472
1
2
3
4
5
6
7
其实,最后一项范数的计算,我们当然可以令这个向量与自身做内积,再开根号。当然,上面代码中的写法却是更加简洁方便。

有些时候我们想要一次性求得矩阵每一行或者每一列的最大最小值,加和,平均值等等,这个时候,“轴”参数的设置就显现出作用了。

a = np.random.randint(0, 10, (3, 3)) # >>> [[3 7 1]
[1 0 3]
[3 6 2]]

print(np.sum(a, axis=0)) # >>> [ 7 13 6]
print(np.sum(a, axis=1)) # >>> [11 4 11]

如果直接求sum,得到的会是全部元素的加和
print(np.sum(a)) # >>> 26
1
2
3
4
5
6
7
8
9

7. 向量内积

其实,这个东西可以用矩阵乘法解决,但是对于一维数组来说,还有个专门的函数np.inner(v1, v2),因为我在工作中经常会用到这种一维数组计算内积的情况,故在此列出:

v1 = np.array([1, 2, 3])
v2 = np.array([2, 3, 4])

print(np.inner(v1, v2)) # >>> 20
1
2
3
4
关于Numpy基础知识,我暂时想到的就是以上这些了。因为Numpy的内容实在太多,所以我写的一定不全。还希望读者们有什么好的提议尽可提出,我再添加。这篇博客将在未来,不定时更新。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值