numpy的基础运算-【老鱼学numpy】

概述

本节主要讲解numpy数组的加减乘除四则运算。
np.array()返回的是numpy的数组，官方称为：ndarray，也就是N维数组对象（矩阵）,N-dimensional array object。
这个对象的特性跟矩阵的特性也比较接近，因此我这里有时就将其混称为数组/矩阵了。

数组加法

例如：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = np.arange(4)
print("b:", b)

c = a + b
print("c=a+b:", c)

输出结果为：

a: [10 20 30 40]
b: [0 1 2 3]
c=a+b: [10 21 32 43]

从例子中我们可以看出数组/矩阵的加法就是把两个数组/矩阵中对应的元素进行相加，组成一个新的数组/矩阵。
那如果两个数组/矩阵的维度不一样，可否进行相加呢？
比如在上面的例子中，我们如果把b数组的数据修改成自由3个元素的，我们来看下会发生什么事情：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = np.arange(3)
print("b:", b)

c = a + b
print("c=a+b:", c)

输出为：

a: [10 20 30 40]
b: [0 1 2]
Traceback (most recent call last):
  File "E:/learn/numpy/lesson3/main.py", line 8, in <module>
    c = a + b
ValueError: operands could not be broadcast together with shapes (4,) (3,) 

直接报错了，也就是如果两个数组/矩阵不是相同维度的，则不能进行相加。

我们再来看个例子：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = 4
print("b:", b)

c = a + b
print("c=a+b:", c)

输出为：

a: [10 20 30 40]
b: 4
c=a+b: [14 24 34 44]

在这个例子中，我们用一个数组/矩阵加上一个数字，结果是这个数组/矩阵中的元素分别加上了这个数字组成一个新的数组/矩阵。
那这里这个数字的形状跟a数组/矩阵的形状其实是不一样的，但结果还是能够相加，这是怎么回事呢？

其实，numpy会自动尝试把数字或矩阵进行broadcast操作，以便于尽可能地进行矩阵计算，这里就把单个数字扩展成了跟a数组/矩阵一样形状的数组/矩阵，然后进行数组/矩阵的相加。
而之前那个报错的例子中是因为两个数组/矩阵无法进行扩展成相同的形状而进行数组/矩阵的相加。

数组/矩阵的减法

数组/矩阵减法跟数组/矩阵的加法一样，这里就不重复了。

数组的乘法

看例子：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = np.arange(4)
print("b:", b)

c = a * b
print("c=a*b:", c)

输出为：

a: [10 20 30 40]
b: [0 1 2 3]
c=a*b: [  0  20  60 120]

看起来乘法也不难，就是两个数组中对应元素的相乘，可以认为是矩阵的数乘。
在上面的例子中，如果b=4，则numpy会用用广播(broadcast)方式把数字4扩展成跟a相同维度但其元素都为4的数组，然后再进行对应元素相乘的方式。
具体实现为：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = 4
print("b:", b)

c = a * b
print("c=a*b:", c)

输出为：

a: [10 20 30 40]
b: 4
c=a*b: [ 40  80 120 160]

学过线性代数的都知道，在矩阵中有两种乘法：点乘和叉乘。
向量：u=(u1,u2,u3) v=(v1,v2,v3)
点积公式：u * v = u1v1+u2v2+u3v33=lul * lvl * COS(U,V)
叉积公式：u x v = { u2 * v3 - v2 * u3, u3 * v1 - v3 * u1, u1 * v2 - u2 * v1}
这里点乘就是把两个向量中的对应元素相乘后再进行相加，其结果是一个数，在物理上可以用来计算物体在力F的作用下移动位移后所做的功，在几何中可以用来计算两个矢量的夹角，尤其是可以用来证明是否垂直。
用numpy来计算这个矢量的点积就非常方便，例如：

import numpy as np
a = np.array([10, 20, 30, 40])
print("a:", a)

b = np.array([1, 2, 3, 4])
print("b:", b)

c = np.dot(a, b)
print("c=a * b:", c)

这个例子中矢量的点积就是：(10, 20, 30, 40) * (1, 2, 3, 4)=10 * 1 + 20 * 2 + 30 * 3 + 40 * 4=300
输出结果为：

a: [10 20 30 40]
b: [1 2 3 4]
c=a * b: 300

对于叉积，这里有一个数学上的例子：

对应的numpy实现方式为：

import numpy as np
a = np.array([[1, 2, 3],
             [4, 5, 6]])
print("a:")
print(a)

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

c = np.dot(a, b)
print("c=a x b:")
print(c)

输出为：

a:
[[1 2 3]
 [4 5 6]]
b:
[[1 4]
 [2 5]
 [3 6]]
c=a x b:
[[14 32]
 [32 77]]

我们可以发现，numpy中可以用np.dot()函数来同时处理点积和叉积的运算。当输入部分是两个一维数组时，np.dot()就是点积操作，当输入部分是两个二维数组时，进行的就是叉积操作。
其实，点积和叉积的运算规则基本类似的，都是把某批元素同另一批元素进行相乘并求和，这也就是为何numpy可以用dot函数来实现点积和叉积。

数组的n次方

python中的n次方表达为a**n，比如2的10次方：

print(2**10)

输出为：

1024

同理，在numpy数组中，也可以用**n的方式对数组中的每个元素进行n次方的操作，例如：

import numpy as np
a = np.array([1, 2, 3, 4])
print("a=", a)

b = a ** 2
print("b = a ** 2=", b)

输出为：

a= [1 2 3 4]
b = a ** 2= [ 1  4  9 16]

数组中的三角函数计算

直接上例子：

import numpy as np
a = np.array([1, 2, 3, 4])
print("a=", a)

b = np.sin(a)
print("b = sin(a)=", b)

输出为：

a= [1 2 3 4]
b = sin(a)= [ 0.84147098  0.90929743  0.14112001 -0.7568025 ]

看到这里，我们大体也能知道numpy中数组的运算方式大体都是对数组中的每个元素进行相同的数学运算，从而达到批量处理的效果。

数组同数值比较

直接上例子：

import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a<3)

输出为：

[ True  True False False False]

其运算结果相当于把数组中每个元素同相应的数进行比较，结果数组中的元素就返回True或False。

生成随机数

import numpy as np
a = np.random.random((3, 2))
print(a)

b = np.random.rand(3, 2)
print(b)

输出0-1之间的随机数：

[[ 0.55981126  0.39507502]
 [ 0.49826522  0.64111042]
 [ 0.25806207  0.78056224]]
[[ 0.36580962  0.48456239]
 [ 0.55941715  0.5660371 ]
 [ 0.13974611  0.97547935]]

矩阵求和、最小、最大值

import numpy as np
a = np.array([1, 2, 3, 4, 5])
print("a=", a)

print("sum=", np.sum(a))

print("min=", np.min(a))

print("max=", np.max(a))

输出结果：

a= [1 2 3 4 5]
sum= 15
min= 1
max= 5

对于二维矩阵，我们也可以通过制定求和的轴来指定到底是按行求和还是按列求和。
其中axis=0为按列求和，axis=1为按行求和。例如：

import numpy as np
a = np.array([[5, 10, 15],
              [20, 25, 30]])
print("a=")
print(a)
# 列求和
print("axis=0(列求和):", a.sum(axis=0))
# 行求和
print("axis=1(行求和):", a.sum(axis=1))

输出结果：

a=
[[ 5 10 15]
 [20 25 30]]
axis=0(列求和): [25 35 45]
axis=1(行求和): [30 75]

对于求最小值和最大值也有同样的axis参数，表示到底是在行中求最小(大)值还是列中求最小(大)值。