Python干货-Numpy基础计算

numpy基础运算

import numpy as np

创建两个array用于运算

# 创建一个array，拥有四个元素
a = np.array([10, 20, 30, 40])
# 使用arange创建一个array，也是拥有四个元素
b = np.arange(4)

numpy中的减法运算

c = a - b

# 输出结果
print(a)
print('-'*20)
print(b)
print('-'*20)
print(c)

[10 20 30 40]
--------------------
[0 1 2 3]
--------------------
[10 19 28 37]

通过上例可以看出，两个array，形状一样，相减操作会将其对应位置进行减法计算，得到一个新的array

numpy中的加法运算

c = a + b

# 输出结果
print(a)
print('-'*20)
print(b)
print('-'*20)
print(c)

[10 20 30 40]
--------------------
[0 1 2 3]
--------------------
[10 21 32 43]

同理，两个形状一样的array之间相加，会将其对应位置的元素相加，得到一个新的array

numpy中的乘法与除法运算

这里的乘法与除法的运算与加减法的运算理论是一样的，就不再啰嗦，直接看代码

c = a * b
print(c)

[  0  20  60 120]

c = a / b
print(c)

[        inf 20.         15.         13.33333333]


/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in true_divide
  """Entry point for launching an IPython kernel.

这里出现了错误，是因为b中的元素有0，0做除数是会报错的，所以在写除法运算的时候一定要注意

array的乘方计算

两个星号表示乘方**

c = a**2
print(c)

[ 100  400  900 1600]

可以看出，新的array中的每个元素都是原来元素的平方

numpy中的三角函数

# sin函数
c = np.sin(a)
print(c)

[-0.54402111  0.91294525 -0.98803162  0.74511316]

# cos函数
c = np.cos(b)
print(c)

[ 1.          0.54030231 -0.41614684 -0.9899925 ]

# tan函数
c = np.tan(a)
print(c)

[ 0.64836083  2.23716094 -6.4053312  -1.11721493]

三角函数也计算每个array的元素对应的结果，然后返回一个新的array对象

numpy 中的比较运算符

c = a < 30
print(c)

[ True  True False False]

这里的<符号，用来判断array中每个元素是否小于30，如果是，则返回True，否则返回False，最终将返回一个都是布尔值的array

同理，<=/ >/ >=/ ==/ !=的用法都是一样的

c = b > 2
print(c)

[False False False  True]

c = b != 2
print(c)

[ True  True False  True]

矩阵的运算

定义运算用的数据

# 定义一个矩阵格式的array
a = np.array([[1, 2],
             [3, 4]])
# 定义一个一维array，然后再改变其形状为2行2列
b = np.arange(4).reshape(2,2)

print('a is: \n', a)
print('-'*10)
print('b is: \n', b)

a is: 
 [[1 2]
 [3 4]]
----------
b is: 
 [[0 1]
 [2 3]]

矩阵的乘法

c = a * b

print('a is: \n', a)
print('-'*10)
print('b is: \n', b)
print('-'*10)
print('c is: \n', c)

a is: 
 [[1 2]
 [3 4]]
----------
b is: 
 [[0 1]
 [2 3]]
----------
c is: 
 [[ 0  2]
 [ 6 12]]

从上例可以看出，两个矩阵相乘，会将其对应位置的元素相乘，然后得到一个新的矩阵；前提是相乘的两个矩阵形状是一样的

使用numpy的乘法函数dot

c = np.dot(a, b)

print('a is: \n', a)
print('-'*10)
print('b is: \n', b)
print('-'*10)
print('c is: \n', c)

a is: 
 [[1 2]
 [3 4]]
----------
b is: 
 [[0 1]
 [2 3]]
----------
c is: 
 [[ 4  7]
 [ 8 15]]

虽然都是两个矩阵相乘，但是使用numpy的dot()函数得到的结果并不一样；它的计算方式是真正的矩阵乘法运算，即每行的元素与对应每列的数两两相乘的和

也就是说，所得到的数组中的每个元素为，第一个矩阵中与该元素行号相同的元素与第二个矩阵与该元素列号相同的元素，两两相乘后再求和

图例

np.dot(a, b)的形式等于a.dot(b)

numpy中的运算函数

定义一个随机元素的矩阵

# random 会返回0.0 到 1.0 之间的随机数
# random((2, 4)) 可以告诉该函数生成2行4列的0.0 到 1.0 的随机数
a = np.random.random((2, 4))
print(a)

[[0.87734668 0.81386455 0.4823868  0.59230853]
 [0.67792381 0.68852432 0.61188049 0.74452105]]

print('求矩阵的和：', np.sum(a))
print('求矩阵中的最小值：', np.min(a))
print('求矩阵中的最大值：', np.max(a))

求矩阵的和： 5.488756232386159
求矩阵中的最小值： 0.48238679745409974
求矩阵中的最大值： 0.8773466797603833

上面的函数使用一看即会，但是如果想求出列的和或求出行的和呢？

print('求矩阵行的和：', np.sum(a, axis=1))
print('求矩阵列的和：', np.sum(a, axis=0))

求矩阵行的和： [2.76590656 2.72284967]
求矩阵列的和： [1.55527049 1.50238887 1.09426729 1.33682958]

axis=1 表示对行进行统计，上例可以看出，a有两行，所以分别得出了两行的和

axis=0 表示对列进行统计，上例可以看出，a有四列，所以分别得出了四列的和

再来看其他两个例子

print('求矩阵各行中的最小值：', np.min(a, axis=1))
print('求矩阵各列中的最小值：', np.min(a, axis=0))

求矩阵各行中的最小值： [0.4823868  0.61188049]
求矩阵各列中的最小值： [0.67792381 0.68852432 0.4823868  0.59230853]

print('求矩阵各行中的最大值：', np.max(a, axis=1))
print('求矩阵各列中的最大值：', np.max(a, axis=0))

求矩阵各行中的最大值： [0.87734668 0.74452105]
求矩阵各列中的最大值： [0.87734668 0.81386455 0.61188049 0.74452105]

numpy常用计算函数

# 通过np.arange(2, 14)创建一个从 2 到 13 的数列
# 再通过reshape((3, 4)) 将这个数列分成 3 行 4 列
a = np.arange(2, 14).reshape((3, 4))
print(a)

[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]

查看矩阵中最小值的索引

# argmin()得到矩阵中最小的元素，并返回其所在的索引值
print(np.argmin(a))

0

查看矩阵中最大值的索引

# argmax()得到矩阵中最大的元素，并返回其所在的索引值
print(np.argmax(a))

11

求矩阵元素的平均值

print(np.mean(a))
# 或者
print(np.average(a))

7.5
7.5

np.mean(a) 的效果等同于 a.mean()

求矩阵中的中位数

print(np.median(a))

7.5

求出所有元素的累加值

print(np.cumsum(a))

[ 2  5  9 14 20 27 35 44 54 65 77 90]

这里显示的累加值不是最终一个值，而是第个值与前面元素的累加值，结果中的元素个数与源数列的元素个数一样

求出所有元素的累差值

print(np.diff(a))

[[1 1 1]
 [1 1 1]
 [1 1 1]]

返回的结果与累加函数的结果形状不一样，每个元素与前一个元素之间差1

得出所有非None非0元素位置

print(np.nonzero(a))

(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))

对元素进行排序

# 正向的排序
print(np.sort(a))

[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]

矩阵旋转(行列转置)

print(np.transpose(a))
# 或者
print(a.T)

[[ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]
 [ 5  9 13]]
[[ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]
 [ 5  9 13]]

利用矩阵的旋转来做矩阵乘法

print(np.dot(a, a.T))

[[ 54 110 166]
 [110 230 350]
 [166 350 534]]

clip()函数

官方解释：Clip (limit) the values in an array.

[a_min, a_max] 里面的数被保留下来,外面的被截取为a_min或者a_max

例如，如果指定间隔为[0， 1]，则小于0的值赋值为0，并且大于1的值赋值为1 。

print(np.clip(a, 5, 9))

[[5 5 5 5]
 [6 7 8 9]
 [9 9 9 9]]

numpy 中的计算函数都可以指定参数 axis=0 来计算列，指定 axis=1 来计算行