python numpy数组操作2

数组的四则运算

在numpy模块中,实现四则运算的计算既可以使用运算符号,也可以使用函数,具体如下例所示:

#加法运算

import numpy as np
math = np.array([98,83,86,92,67,82])
english = np.array([68,74,66,82,75,89])
chinese = np.array([92,83,76,85,87,77])
tot_symbol = math+english+chinese
tot_fun = np.add(np.add(math,english),chinese) #add 加法
print('符号加法:\n',tot_symbol)
print('函数加法:\n',tot_fun)

#除法
height = np.array([165,177,158,169,173])
weight = np.array([62,73,59,72,80])
BMI_symbol = weight/(height/100)**2
BMI_fun = np.divide(weight,np.divide(height,100)**2) #divide 除法
print('符号除法:\n',BMI_symbol)
print('函数除法:\n',BMI_fun)

out:

符号加法:
 [258 240 228 259 229 248]
函数加法:
 [258 240 228 259 229 248]
符号除法:
 [22.77318641 23.30109483 23.63403301 25.20920136 26.7299275 ]
函数除法:
 [22.77318641 23.30109483 23.63403301 25.20920136 26.7299275 ]

四则运算中的符号分别是“+-*/”,对应的numpy模块函数分别是np.add np.subtract,np.multiply,np.divide.需要注意的是，函数只能接受两个对象的运算，如果需要多个对象的运算，就得使用嵌套方法。如上所示的符号假发和符号的除法。不管是符号方法还是函数方法，都必须保证操作的数组具有相同的形状，除了数组与标量之间的运算（如除法中的身高与100的商）。另外，还有三个数学运算符，分别是余数，整数和指数：

import numpy as np
arr7 = np.array([[1,2,10],[10,8,3],[7,6,5]])
arr8 = np.array([[2,2,2],[3,3,4],[4,4,4]])
print('数组arr7:\n',arr7)
print('数组arr8:\n',arr8)
print('求余计算:\n',arr7 % arr8)
print('整除:\n',arr7 // arr8)    #这里面要注意的就是  整除的时候 是  “//”而不是 "/"
print('计算指数:\n',arr7 ** arr8)

out:

数组arr7:
 [[ 1  2 10]
 [10  8  3]
 [ 7  6  5]]
数组arr8:
 [[2 2 2]
 [3 3 4]
 [4 4 4]]
求余计算:
 [[1 0 0]
 [1 2 3]
 [3 2 1]]
整除:
 [[0 1 5]
 [3 2 0]
 [1 1 1]]
计算指数:
 [[   1    4  100]
 [1000  512   81]
 [2401 1296  625]]

另外还可以使用np.fmod,np.modf和np.power，但是整除的函数应用会稍微复杂一点，需要写成np.modf(arr7/arr8)[1],因为modf可以返回

数值的小数部分和整数部分，而整数部分就是要取的整除值。

比较运算

处理数组的元素之间可以实现上面提到的数学运算，还可以做元素的比较运算。关于比较运算符如下：

符号	函数	含义
>	np.greater(arr1,arr2)	判断arr1的元素是否大于arr2的元素
>=	np.greater_equal(arr1,arr2)	判断arr1的元素是否大于等于arr2的元素
<	np.less(arr1,arr2)	判断arr1的元素是否小于arr2的元素
<=	np.less_equal(arr1,arr2)	判断arr1的元素是否小于等于arr2的元素
==	np.equal(arr1,arr2)	判断arr1的元素是否等于arr2的元素
!=	np.not_equal(arr1,arr2)	判断arr1的元素是否小等于arr2的元素

运用比较运算符可以返回bool类型的值，即True和False。有两种情况会普遍使用到比较运算符，一个是从数组中查询满足条件的元素，另一个是根据判断的结果执行不同的操作。例如：

import numpy as np
arr7 = np.array([[1,2,10],[10,8,3],[7,6,5]])
arr8 = np.array([[2,2,2],[3,3,2],[4,4,4]])
print(arr7)
print('从arr7中取出所有大于arr8的元素',arr7[arr7>arr8])    #取出的是所有arr7中对应的元素大于arr8中对应位置的元素
arr9 = np.array([3,10,23,7,15,9,17,22,4,8,16])
print('取出arr9中所有大于10的元素',arr9[arr9>10])   #得到的是一个一维数组  相当于每个数组中的元素都会跟10来进行比较

print(np.greater(arr7,arr8)) #输出的是原数组结构的布尔型元素的数组

out:

[[ 1  2 10]
 [10  8  3]
 [ 7  6  5]]
从arr7中取出所有大于arr8的元素 [10 10  8  3  7  6  5]
取出arr9中所有大于10的元素 [23 15 17 22 16]
[[False False  True]
 [ True  True  True]
 [ True  True  True]]

广播运算

上面介绍的是相同形状的数组，当数组形状不同时，也能够进行数学运算的功能成为数组的广播。数组的广播是有规则的，如果不满足这些规则就会出错；规则如下：

a.各输入数组的维度可以不相等，但必须确保从右到左维度值相等。

b.如果对应维度值不相等，就必须保证其中一个为1.

c.各输入数组都向其shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐

下面通过实例来加强理解

import numpy as np
arr10 = np.arange(12).reshape(3,4)                             #arange（12）表示生成从0-11总共12个数组元素组成的数组,然后通过reshape编                                                                                          #成3行4列的二维数组
arr11 = np.arange(101,113).reshape(3,4)                    #同上面arange(101,113)就是生成从 101到112的元素的数组
print('3x4的二维矩阵运算：\n',arr10 + arr11)
arr12 = np.arange(60).reshape(5,4,3)                          #这是个三维数组，我们可以理解为一个长5宽为4高为3的魔方
arr10 = np.arange(12).reshape(4,3)                             #4行3列的二维数组
print('维数不一致，但末尾的维度值一致:\n',arr12 + arr10)               #我们可以这么看，reshape(5,4,3)其实里面相当于包含了 5个                                                                                                                           #reshape（4，3）的二维数组，末尾两个维度相同，可以进行运算
arr12 = np.arange(60).reshape(5,4,3)
arr13 = np.arange(4).reshape(4,1)                                #这个里面末尾的维度虽然一个是‘’4，3‘’，一个是“4，1”因为后面的数组末尾维度                                                                                           #中其中一个是‘’1‘’，所以是可以进行运算的
print('维数不一致，维数值也不一致，但维度值至少一个为1：\n',arr12+arr13)              #就是在5个(4行3列)的数组中，每行的各个元素对                                                                                                                                          #应加0，1，2，3
arr14 = np.array([5,15,25])
print('arr14的维度自动补齐为(1,3): \n',arr10 + arr14)                                   #每行对应位置元素分别加上 5，15，25

out：

3x4的二维矩阵运算：
 [[101 103 105 107]
 [109 111 113 115]
 [117 119 121 123]]
维数不一致，但末尾的维度值一致:
 [[[ 0  2  4]
  [ 6  8 10]
  [12 14 16]
  [18 20 22]]

 [[12 14 16]
  [18 20 22]
  [24 26 28]
  [30 32 34]]

 [[24 26 28]
  [30 32 34]
  [36 38 40]
  [42 44 46]]

 [[36 38 40]
  [42 44 46]
  [48 50 52]
  [54 56 58]]

 [[48 50 52]
  [54 56 58]
  [60 62 64]
  [66 68 70]]]
维数不一致，维数值也不一致，但维度值至少一个为1：
 [[[ 0  1  2]
  [ 4  5  6]
  [ 8  9 10]
  [12 13 14]]

 [[12 13 14]
  [16 17 18]
  [20 21 22]
  [24 25 26]]

 [[24 25 26]
  [28 29 30]
  [32 33 34]
  [36 37 38]]

 [[36 37 38]
  [40 41 42]
  [44 45 46]
  [48 49 50]]

 [[48 49 50]
  [52 53 54]
  [56 57 58]
  [60 61 62]]]
arr14的维度自动补齐为(1,3):
 [[ 5 16 27]
 [ 8 19 30]
 [11 22 33]
 [14 25 36]]

以上的操作，根据备注去理解，平时多维数组方面的应用比较少，能理解这些规则是怎么来的就可以了，需要用到的时候再深究。