矢量运算：相同大小的数组间运算应用在元素上
1. 矢量的( * ,+, - , /,)
import numpy as np
arr1 = np.array([[1,2,3],[3,4,5]])
#矢量的乘法
print(arr1 * arr1)
###############运算结果################
[[ 1 4 9]
[ 9 16 25]]
######################################
# 矢量的加法
print(arr1 + arr1)
###############运算结果################
[[ 2 4 6]
[ 6 8 10]]
######################################
# 矢量的减法
print(arr1 - arr1)
###############运算结果################
[[0 0 0]
[0 0 0]]
######################################
# 矢量的除法
print(arr1 / arr1)
###############运算结果################
[[ 1. 1. 1.]
[ 1. 1. 1.]]
######################################
2. 矢量和标量的运算
print( 3 * arr1)
###############运算结果################
[[ 3 6 9]
[ 9 12 15]]
######################################
print( arr1 / 3.0)
###############运算结果################
[[ 0.33333333 0.66666667 1. ]
[ 1. 1.33333333 1.66666667]]
######################################
3. 切片 -- 一维数组的切片
arr2 = np.arange(10)
print(arr2)
###############运算结果################
[0 1 2 3 4 5 6 7 8 9]
######################################
print(arr2[3])
###############运算结果################
3
######################################
arr3 = arr2[2:6]
print(arr3)
print(type(arr3))
###############运算结果################
[2 3 4 5]
<class 'numpy.ndarray'>
######################################
print(arr2[:7])
###############运算结果################
[0 1 2 3 4 5 6]
######################################
print(arr2[2:])
###############运算结果################
[2 3 4 5 6 7 8 9]
######################################
print(arr2[:-1])
###############运算结果################
[0 1 2 3 4 5 6 7 8]
######################################
print(arr2[-5:-1])
###############运算结果################
[5 6 7 8]
######################################
4. 切片 -- 多维数组的切片
arr4 = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
print(arr4)
###############运算结果################
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]
[16 17 18 19 20]
[21 22 23 24 25]]
######################################
print(arr4[1:3,1:3])
###############运算结果################
[[ 7 8]
[12 13]]
######################################
print(arr4[2:,1:])
###############运算结果################
[[12 13 14 15]
[17 18 19 20]
[22 23 24 25]]
######################################
print(arr4[0:3,0:3])
###############运算结果################
[[ 1 2 3]
[ 6 7 8]
[11 12 13]]
######################################
5. 条件索引
arr5 = np.array([[2016,2015,2017,2014],[2000,2005,2018,2012]])
print(arr5)
###############运算结果################
[[2016 2015 2017 2014]
[2000 2005 2018 2012]]
######################################
#查找2015以后拍摄的电影
arr_result = arr5 > 2015
print(arr_result)
print(arr_result.dtype)
###############运算结果################
[[ True False True False]
[False False True False]]
bool
######################################
arr_filtered = arr5[arr_result]
print(arr_filtered)
###############运算结果################
[2016 2017 2018]
######################################
# 查找2012年之后，2016年之前的电影
arr_result1 = (arr5 > 2012) & (arr5<2016)
print(arr_result1)
###############运算结果################
[[False True False True]
[False False False False]]
######################################
arr_filtered1 = arr5[arr_result1]
print(arr_filtered1)
###############运算结果################
[2015 2014]
######################################
6. 转置
arr6 = np.arange(12)
print(arr6)
arr7 = arr6.reshape(3,4)
print(arr7)
###############运算结果################
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
######################################
# 转置的操作，把3行4列的数组，转换成4行3列
print(arr7.transpose(1,0))
###############运算结果################
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
######################################
# 多维数组的转置
arr8 = arr6.reshape(2,3,2)
print(arr8)
print(arr8.shape)
###############运算结果################
[[[ 0 1]
[ 2 3]
[ 4 5]]
[[ 6 7]
[ 8 9]
[10 11]]]
(2, 3, 2)
######################################
arr9 = arr8.transpose(1,2,0)
print(arr9)
print(arr9.shape)
###############运算结果################
[[[ 0 6]
[ 1 7]]
[[ 2 8]
[ 3 9]]
[[ 4 10]
[ 5 11]]]
(3, 2, 2)
######################################
7. 元素的计算函数
arr10 = np.random.randn(3,4)
print(arr10)
###############运算结果################
[[-0.03158271 0.00856409 0.16429944 -0.39583693]
[ 0.5652739 0.89520627 -1.46548196 -0.83807298]
[-0.10149163 -0.3755329 -0.67948187 0.02619008]]
######################################
7.1ceil(): 向上最接近的整数，参数是 number 或 array
###############运算结果################
[[-0. 1. 1. -0.]
[ 1. 1. -1. -0.]
[-0. -0. -0. 1.]]
######################################
7.2 floor(): 向下最接近的整数，参数是 number 或 array
print(np.floor(arr10))
###############运算结果################
[[-1. 0. 0. -1.]
[ 0. 0. -2. -1.]
[-1. -1. -1. 0.]]
######################################
7.3 rint(): 四舍五入，参数是 number 或 array
print(np.rint(arr10))
###############运算结果################
[[-0. 0. 0. -0.]
[ 1. 1. -1. -1.]
[-0. -0. -1. 0.]]
######################################
7.4 isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
print(np.isnan(arr10))
###############运算结果################
[[False False False False]
[False False False False]
[False False False False]]
######################################
7.5 multiply(): 元素相乘，参数是 number 或 array
print(np.multiply(arr10,arr10))
###############运算结果################
[[ 9.97467645e-04 7.33436379e-05 2.69943052e-02 1.56686873e-01]
[ 3.19534580e-01 8.01394268e-01 2.14763737e+00 7.02366316e-01]
[ 1.03005518e-02 1.41024957e-01 4.61695610e-01 6.85920093e-04]]
######################################
7.6 divide(): 元素相除，参数是 number 或 array
# 元素相除，参数是 number 或 array
print(np.divide(arr10,arr10))
###############运算结果################
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
######################################
7.7 where(condition, x, y): 三元运算符，x if condition else y
print(np.where(arr10>0.2,1,0))
###############运算结果################
[[0 0 0 0]
[1 1 0 0]
[0 0 0 0]]
######################################
8. 元素统计函数
arr11 = np.arange(12)
arr12 = arr11.reshape(3,4)
print(arr12)
###############运算结果################
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
######################################
8.1 np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
print(np.mean(arr12))
print(np.sum(arr12))
###############运算结果################
66
5.5
######################################
8.2 np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
print(np.max(arr12))
print(np.min(arr12))
###############运算结果################
11
0
######################################
8.3 np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
print(np.argmax(arr12))
print(np.argmin(arr12))
###############运算结果################
11
0
######################################
8.4 np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
print(np.cumsum(arr12))
print(np.cumprod(arr12))
###############运算结果################
[ 0 1 3 6 10 15 21 28 36 45 55 66]
[0 0 0 0 0 0 0 0 0 0 0 0]
######################################
8.5 np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
print(np.std(arr12))
print(np.var(arr12))
###############运算结果################
3.45205252953
11.9166666667
######################################
9. 元素判断函数
arr13 = np.random.randn(3,4)
print(arr13)
###############运算结果################
[[ 0.69663422 -0.02838299 -0.97589683 1.27459694]
[-0.33179617 -0.1338825 0.41949947 0.81024728]
[ 0.25921633 -0.1173483 -0.10671398 0.7972912 ]]
######################################
9.1 np.any(): 至少有一个元素满足指定条件，返回True
# 判断arr13数组中是否有大于0的元素
print(np.any(arr13>0))
###############运算结果################
True
######################################
9.2 np.all(): 所有的元素满足指定条件，返回True
# 判断arr13数组中是否所有的元素都大于0
print(np.all(arr13>0))
###############运算结果################
False
######################################
9.元素去重排序函数
arr14 = np.array([[1,2,3],[2,3,4]])
print(arr14)
###############运算结果################
[[1 2 3]
[2 3 4]]
######################################
9.1 np.unique():找到唯一值并返回排序结果，类似于Python的set集合
print(np.unique(arr14))
###############运算结果################
[1 2 3 4]
######################################
