1 Numpy-科学计算

在Python中，使用list可以保存一组值，可以作为数组使用，但是比较浪费内存和时间。类似的array模块，不支持多维，也没有各种函数运算，因此也极其不方便。

为解决这一问题，Python提供了Numpy模块，支持N维数组运算、处理大型矩阵、广播函数库、矢量运算等。

1.1函数库的导入

在使用这个库的第一步，先导入numpy模块，根据Python社区的习惯，代码如下：

>>>import numpy as np 

1.2数组创建

1.2.1Array函数

一般情况下，我们可以使用array函数把Python中的列表或元组转换成数字，Array(x) 所需的 x参数是一个用逗号隔开的值表。如果不提供参数，则创建一个长度为 0 的数组。

示例代码如下：

>>>np.array((1,2,3,4))  #列表转换为数组
[1 2 3 4]
 
>>>np.array(range(4)) #range对象转换成数组
[0 1 2 3]

注明：带>>>表示输入代码，其余的是print的结果，下文中不再说明

1.2.2常用生成数组的方法

有时候，我们可能需要创建一些比较规则的数组，比如1到100的等差为1的数组，如果使用上面的方法显得太麻烦，这时候，我们可以使用arange(a,b,c)函数，其中a,b,c参数分别对应起始数值和元素差值，但取值时不取到b，示例代码如下：

>>>np.arange(0, 2, 0.5)
[0.  0.5 1.  1.5]

有时不一定知道元素之间精确的差值，而又想获取一个范围内某长度的数组，用linspace(a,b,c)函数就可以完成这个任务，其中a,b,c分别对应起始数值和元素个数，示例代码如下：

>>>np.linspace(0,2,5)
[0.  0.5 1.  1.5 2. ]

logspace函数和linspace函数类似，a,b是起始数值，c指取值个数，假设x是a到b的其中一个值，则元素取值为10^x，也就是说，假设a,b分别取值为0和2时，对应的首尾元素是1（10^0）和100（10^2），示例代码如下：

>>>np.logspace(0,2,10)
[  1.           1.66810054   2.7825594    4.64158883   7.74263683
  12.91549665  21.5443469   35.93813664  59.94842503 100.        ]

还有生成随机数数组，范围是0到1，示例如下：

>>>np.random.rand(10)
[0.33234665 0.81082701 0.36265294 0.52809782 0.14785796 0.42038477
 0.43077405 0.10493567 0.59562374 0.64912364]

1.2.3生成常用矩阵

一般情况下，使用矩阵可能需要全零全一这类的矩阵作为初始值，类似matlab，python也有这样的函数可以调用，下面分别示例全0，全1，单位矩阵和空矩阵的代码：

>>>np.zeros((3,3))  #全0二维数组
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
 
>>>np.ones((3,3))  #全1二位数组
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
 
>>>np.identity(3)  #单位矩阵
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
 
>>>np.empyt((3,3))  #空数组，只申请空间，元素值不确定，每次运行结果可能不同
 [[0.00000000e+000 2.35636847e-310 2.35636847e-310]
 [2.35636847e-310 2.35636847e-310 2.35636847e-310]
 [2.35636847e-310 2.35636847e-310 3.95252517e-322]]

1.3数组操作

1.3.1获取数组属性

>>>a=np.array(([1,2,3],[4,5,6]))
>>>a
[[1 2 3]
 [4 5 6]]
>>>a.ndim  #数组的维数
2
>>>a.shape  #数组的维度，返回一个元素，相当于行和列
(2, 3)
>>>a.size  #数组元素个数
6
>>>a.itemsize #数组中每个元素字节大小
8
>>>a.data  #缓冲区，一般不需要用
<memory at 0x2b7990872e48>

1.3.2改变数组大小

当已知一个一维数组时，可以用下面方法改变数组的维度

>>>a=np.array(range(10))
>>>a
[0 1 2 3 4 5 6 7 8 9]
>>>a.shape=2,5  #改成2行5列
>>>a
[[0 1 2 3 4]
 [5 6 7 8 9]]
>>>a.shape=5,-1  #改成5行，自动计算列
>>>a
 [[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
>>>b=a.reshape(2,5)  #改变a的行列并返回新数组
>>>b
[[0 1 2 3 4]
 [5 6 7 8 9]]

1.3.3访问元素

访问元素一般比较简单，代码如下：

>>>a=np.arange(1,10,1).reshape(3,3)
>>>a
[[1 2 3]
 [4 5 6]
 [7 8 9]]
>>>a[0]  #第0行
[1 2 3]
>>>a[:,0]  #第0行
[1 4 7]
>>>a[0][0]  #第0行0列的元素
1

元素也可以同时访问多个，也可以修改多个，代码如下

>>>a=np.arange(1,10,1)
>>>a
[1 2 3 4 5 6 7 8 9]
>>>index=np.array([1,5])
index
[1 5]
>>>a[index]  #查看多个元素值
[2 6]
>>>a[index]=[11,13]  #修改多个元素值
>>>a
[ 1 11  3  4  5 13  7  8  9]

这里再介绍一个切片操作，代码如下：

>>>a=np.arange(10)
>>>a
[0 1 2 3 4 5 6 7 8 9]
>>>a[::-1]  #反向切片
[9 8 7 6 5 4 3 2 1 0]
>>>a[::2]  #隔一个取一个
[0 2 4 6 8]
>>>a[:4]  #前4个元素
[0 1 2 3]

1.4数组运算

1.4.1数组与数值的运算

python的数值计算中，基本运算有加、减、乘、除、整除、幂运算、余数等，这些运算在数组中同样适用。数组和数值的运算，是数组中每一位元素分别和数值做计算，本文选用加法和乘法示例，其他的不再一一列举，代码如下：

>>>x=np.array(range(5))
>>>x
[0 1 2 3 4]
>>>x+2
[2 3 4 5 6]
>>>x*2
[0 2 4 6 8]

1.4.2数组和数组的运算

数组间的运算，如c=a*b，表示a中每一位元素乘以b中的每一列元素，下面示例乘法和加法的代码：

>>>a=np.arange(1,4,1)
>>>a
[1 2 3]
>>>b=np.arange(1,10,1).reshape(3,3)
>>>b
[[1 2 3]
 [4 5 6]
 [7 8 9]]
>>>a*b   #乘法运算
[[ 1  4  9]
 [ 4 10 18]
 [ 7 16 27]]
>>>a+b   #加法运算
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]

1.4.3向量内积

一维向量求内积非常简单，将对应元素相乘后求和，一维数组也可以和二维数组求内积，内积调用代码为a.dot(b)或np.dot(a,b)，示例代码如下：

>>>a=np.array((1,2,3))
>>>b=np.array((3,3,3))
>>>c=np.arange(1,10,1).reshape(3,3)
>>>np.dot(a,b)  #向量内积
18
>>>np.dot(c,a)  #c中的每一行和a计算内积
[14 32 50]
>>>np.dot(a,c)  #a和c中的每一列计算内积
[30 36 42]

多维数组之间也可以求内积，设有多维数组a和多维数组b，若a（如3*2）的列和b（2*4）的行一致，则可计算内积，得到新的数组c（3*4），c的行列分别为a的行和b的列，c中的第i行j列的元素值是a中i行和b中j列的向量做内积求得的。代码如下：

>>>a=np.arange(1,9,1).reshape(2,4)
>>>b=np.arange(1,7,1).reshape(3,2)
>>>b
[[1 2]
 [3 4]
 [5 6]]
>>>a
[[1 2 3 4]
 [5 6 7 8]]
>>>np.dot(b,a)
[[11 14 17 20]
 [23 30 37 44]
 [35 46 57 68]]

1.4.4数组转置

二维数组转置后行列位置发生变化，一维不变，这里只示例二维转置的效果，代码如下：

>>>a=np.arange(1,10,1).reshape(3,3)
>>>a
[[1 2 3]
 [4 5 6]
 [7 8 9]]
>>>a.T
[[1 4 7]
 [2 5 8]
 [3 6 9]]

1.5调用函数

1.5.1计算所有元素值

设x是一个任意维数组，则一般有以下函数可以使用，调用后对每个元素值都做计算

• np.sin(x)  求正弦值
• np.cos(x)  求余弦值
• np.round(x)  四舍五入
• np.floor(x)  向下取整
• np.ceil(x)  向上取整

本文示例第一个和最后一个函数

>>>a=np.arange(1,10,1).reshape(3,3)
>>>b=np.sin(a)*10
>>>np.sin(a)  #a求正弦值
[[ 0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155 ]
 [ 0.6569866   0.98935825  0.41211849]]
>>>b
[[ 8.41470985  9.09297427  1.41120008]
 [-7.56802495 -9.58924275 -2.79415498]
 [ 6.56986599  9.89358247  4.12118485]]
>>>np.ceil(b)   #b向上取整
[[ 9. 10.  2.]
 [-7. -9. -2.]
 [ 7. 10.  5.]]

1.5.2不同维度上的元素进行计算

介绍函数前，先说明几个变量，x表示数组，axis=0表示纵向或者说每列，axis=1表示横向或者每行。以下列举一些用法类似的函数，并选择其中一个函数用代码示例

• np.sum  #求和
• np.mean  #求算术平均值
• np.average  #求平均值，如果参数加上权重则为加权平均值
• np.max  #求最大值
• np.std  #求标准差
• np.var  #求方差
• np.sort  #排序，不标明axis的值时，默认axis为1

>>>a=np.array(([1,2,3],[4,5,6]))
>>>np.sum(a)  #全部元素和
21
>>>np.sum(a,0)  #纵向求和
[5 7 9]
>>>np.sum(a,axis=1)  #横向求和
[6 15]

1.6广播

ufunc是一种能对数组的每个元素进行操作的函数，如前面提到的np.sin等函数。当我们使用ufunc函数对两个数组进行计算时，ufunc函数会对这两个数组的对应元素进行计算，因此它要求这两个数组有相同的大小(shape相同)。如果两个数组的shape不同的话，会进行如下的广播(broadcasting)处理：

1. 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
2. 输出数组的shape是输入数组shape的各个轴上的最大值 (数组的维数称为秩，秩是描述轴的数量，轴表示一个线性数组)
3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
4. 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

上述4条规则理解起来可能比较费劲，让我们来看一个实际的例子。

>>>a=np.arange(0, 60, 10).reshape(-1, 1)
>>>b=np.arange(0,6)
>>>a
[[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
>>>b
[0 1 2 3 4 5]
>>>a+b  #广播
[[ 0  1  2  3  4  5]
 [10 11 12 13 14 15]
 [20 21 22 23 24 25]
 [30 31 32 33 34 35]
 [40 41 42 43 44 45]
 [50 51 52 53 54 55]]
>>>a*b
[[  0   0   0   0   0   0]
 [  0  10  20  30  40  50]
 [  0  20  40  60  80 100]
 [  0  30  60  90 120 150]
 [  0  40  80 120 160 200]
 [  0  50 100 150 200 250]]