python：Numpy（3）

• 一元函数

三角函数

sin、cos、tan 普通的正弦、余弦、正切函数
sinh、cosh、tanh 双曲正弦、双曲余弦、双曲正切
arcsin、arccos、arctan 反正弦、反余弦、反正切函数
arcsinh、arccosh、arctanh 反双曲正弦、反双曲余弦、反双曲正切

arr0 = np.array([1 / 6, 2 / 6, 3 / 6, 4 / 6, 5 / 6]) * np.pi
print(arr0)
arr0_sin=np.sin(arr0)
print(arr0_sin)
arr0_cos=np.cos(arr0)
print(arr0_cos)
arr0_tan=np.tan(arr0)
print(arr0_tan)

[0.52359878 1.04719755 1.57079633 2.0943951  2.61799388]
[0.5       0.8660254 1.        0.8660254 0.5      ]
[ 8.66025404e-01  5.00000000e-01  6.12323400e-17 -5.00000000e-01
 -8.66025404e-01]
[ 5.77350269e-01  1.73205081e+00  1.63312394e+16 -1.73205081e+00
 -5.77350269e-01]

数值修约函数

around 返回指定数字的四舍五入值。
floor 返回小于或者等于指定表达式的最大整数，即向下取整。
ceil 返回大于或者等于指定表达式的最小整数，即向上取整。
rint 将各元素四舍五入到最接近的整数。

numpy.around(a,decimals)
a 输入数组
decimals 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
其他函数的用法基本类似。

arr = np.random.normal(loc=0, scale=10, size=(3, 3))
print(arr)
print(np.around(arr))
print(np.around(arr, 2))  # 四舍五入到2位小数
print(np.around(arr, -1))  # 四舍五入到小数点左侧一位
print(np.floor(arr))  # 向下取整

[[ 11.14949223  28.94304219  14.75050649]#print(arr)
 [  7.65175113  -3.7854703  -12.45890921]
 [ -3.97174212  -6.71138378   1.18974617]]
[[ 11.  29.  15.]#print(np.around(arr))
 [  8.  -4. -12.]
 [ -4.  -7.   1.]]
[[ 11.15  28.94  14.75]#print(np.around(arr, 2))
 [  7.65  -3.79 -12.46]
 [ -3.97  -6.71   1.19]]
[[ 10.  30.  10.]#print(np.around(arr, -1))
 [ 10.  -0. -10.]
 [ -0. -10.   0.]]
[[ 11.  28.  14.]#print(np.floor(arr))  
 [  7.  -4. -13.]
 [ -4.  -7.   1.]]

数值运算

abs 计算整数、浮点数的绝对值
sqrt 计算各元素的平方根
square 计算各元素的平方
exp 计算各元素的指数ex
log、log10、log2、log1p 分别位自然对数（底数为e）、底数为10 的log、底数为2的log、log（1+x）

arr = np.random.normal(loc=0, scale=10, size=(3, 3))
print(arr)
print(np.abs(arr))

[[ -3.22392532 -15.86874      3.76030106]
 [ -6.18744157  -7.24463068  -5.22079892]
 [ -2.95109932   0.6518834   -0.85140759]]
[[ 3.22392532 15.86874     3.76030106]
 [ 6.18744157  7.24463068  5.22079892]
 [ 2.95109932  0.6518834   0.85140759]]

判断空值

isnan该函数返回一个表示哪些值是NaN的布尔型数组。

arr2 = np.array([1, 2, np.nan, 4])
print(np.isnan(arr2))

[False False  True False]

• 二元函数

常用算术运算

add 加法运算
subtract 减法运算，从第一个数组中减去第二个数组
multiply 数组元素相乘
divide 除法运算
numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
numpy.mod() 函数，是元素级的求余数计算，传参方式跟 power 函数类似。

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([10, 20, 30, 40])
print(np.add(arr1, arr2))
print(np.subtract(arr1,arr2))
print(np.power(arr1,3))
print(np.power(arr2,arr1))
print(np.mod(arr1,2))
print(np.mod(arr2,arr1))

[11 22 33 44]
[ -9 -18 -27 -36]
[ 1  8 27 64]
[     10     400   27000 2560000]
[1 0 1 0]
[0 0 0 0]

比较运算

maximum、fmax 元素级的最大值计算，fmax将忽略NaN
minimum、fmin 元素级的最小值计算，fmin将忽略NaN
greater、greater_equal 相当于运算符：>、≥
less、less_equal 相当于运算符：＜、≤
equal、not_equal 相当于运算符：==、！=

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([10, 20, 30, 40])
print(np.maximum(arr1,arr2))
print(np.minimum(arr1,arr2))
print(np.greater(arr1,3))
print(np.not_equal(arr1,arr2))

[10 20 30 40]
[1 2 3 4]
[False False False  True]
[ True  True  True  True]

• 统计函数

聚合函数

sum 对数组中的全部或沿着轴向的元素求和。
mean、median 求数组的算术平均值、中位数
std、var 分别为标准差和方差
min、max 最小值和最大值
argmin、argmax 分别为最小和最大元素的索引
cumsum 所有元素的累计和
cumprod 所有元素的累计积
percentile 计算数组的百分比分位数

arr0 = np.arange(16).reshape(4, 4)
print(arr0)
print("数组求和结果为：", np.sum(arr0))
print("数组求平均结果为：", np.mean(arr0))
print("数组求中位数结果为：", np.median(arr0))
print("数组求方差结果为：", np.var(arr0))
print("数组求标准差结果为：", np.std(arr0))
print("数组求最小值为：", np.min(arr0))
print("数组求最大值为：", np.max(arr0))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
数组求和结果为： 120
数组求平均结果为： 7.5
数组求中位数结果为： 7.5
数组求方差结果为： 21.25
数组求标准差结果为： 4.6097722286464435
数组求最小值为： 0
数组求最大值为： 15

也可以这样写：

print("数组求和结果为：", arr0.sum())
print("数组求平均结果为：", arr0.mean())
print("数组求方差结果为：", arr0.var())
print("数组求标准差结果为：", arr0.std())
print("数组求最小值为：", arr0.min())
print("数组求最大值为：", arr0.max())

print("数组求和结果为：", arr0.sum())
print("数组求平均结果为：", arr0.mean())
print("数组求方差结果为：", arr0.var())
print("数组求标准差结果为：", arr0.std())
print("数组求最小值为：", arr0.min())
print("数组求最大值为：", arr0.max())

注意，中位数 median 求解无法用上述方法调用。

对于二维数组，最外层的轴（也即垂直方向）记为axis=0，内层的轴（也即水平方向）记为axis=1。在调用统计函数的时候，可以通过指定axis来明确聚合的方向。

arr0 = np.arange(16).reshape(4, 4)
print(arr0)
print("数组水平方向求和结果为：", np.sum(arr0, axis=1))
print("数组水平方向求平均结果为：", np.mean(arr0, axis=1))
print("数组水平方向求中位数结果为：", np.median(arr0, axis=1))
print("数组水平方向求方差结果为：", np.var(arr0, axis=1))
print("数组水平方向求标准差结果为：", np.std(arr0, axis=1))
print("数组水平方向求最小值为：", np.min(arr0, axis=1))
print("数组水平方向求最大值为：", np.max(arr0, axis=1))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
数组水平方向求和结果为： [ 6 22 38 54]
数组水平方向求平均结果为： [ 1.5  5.5  9.5 13.5]
数组水平方向求中位数结果为： [ 1.5  5.5  9.5 13.5]
数组水平方向求方差结果为： [1.25 1.25 1.25 1.25]
数组水平方向求标准差结果为： [1.11803399 1.11803399 1.11803399 1.11803399]
数组水平方向求最小值为： [ 0  4  8 12]
数组水平方向求最大值为： [ 3  7 11 15]

同样地，实例调用方法也可以实现上述效果：

arr0 = np.arange(16).reshape(4, 4)
print(arr0)
print("数组垂直方向求和结果为：", arr0.sum(axis=1))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
数组垂直方向求和结果为： [ 6 22 38 54]

其他函数运算

numpy.cumsum()累计和
numpy.cumprod()累计积

arr0 = np.arange(16).reshape(4, 4)
print(arr0)
print(np.cumsum(arr0))
print("计算水平方向的累计和", arr0.cumsum(axis=1))
print("计算垂直方向的累计积", arr0.cumprod(axis=0))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[  0   1   3   6  10  15  21  28  36  45  55  66  78  91 105 120]
计算水平方向的累计和 [[ 0  1  3  6]
 [ 4  9 15 22]
 [ 8 17 27 38]
 [12 25 39 54]]
计算垂直方向的累计积 [[   0    1    2    3]
 [   0    5   12   21]
 [   0   45  120  231]
 [   0  585 1680 3465]]

百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数 numpy.percentile() 接受以下参数。
numpy.percentile(a, q, axis)
a 输入数组
q 要计算的百分位数，在 0 ~ 100 之间
axis 沿着它计算百分位数的轴
第 q 个百分位数是这样一个值，它使得至少有 q% 的数据项小于或等于这个值，且至少有 (100-q)% 的数据项大于或等于这个值。

arr0 = np.arange(16).reshape(4, 4)
print(arr0)
print(np.percentile(arr0,50,axis=1))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[ 1.5  5.5  9.5 13.5]

• 数组操作

修改数组形状

常用的修改数组形状的函数有：
reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel 返回展开数组

numpy.reshape(arr, newshape, order=‘C’)
arr 待修改形状的数组
newshape 整数或者整数数组，新的形状应当兼容原有形状
order ‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

生成一维数组，并利用 reshape 进行数组形状的重整：

arr0 = np.arange(8).reshape(2, 4)
print(arr0)

[[0 1 2 3]
 [4 5 6 7]]

numpy.ndarray.flat 是一个数组元素迭代器，可以利用for循环对迭代器进行遍历。

arr0 = np.arange(8).reshape(2, 4)
for element in arr0.flat:
    print(element)

0
1
2
3
4
5
6
7

numpy.ndarray.flatten返回一份数组拷贝，并折叠为一维的数组。对拷贝所做的修改不会影响原始数组。

arr0 = np.arange(8).reshape(2, 4)
print("将arr0以行顺序展开：", arr0.flatten(order='C'))
print("将arr0以列顺序展开：", arr0.flatten(order='F'))

将arr0以行顺序展开： [0 1 2 3 4 5 6 7]
将arr0以列顺序展开： [0 4 1 5 2 6 3 7]

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view），修改会影响原始数组。

arr0 = np.arange(8).reshape(2, 4)
arr0_c=np.ravel(arr0,order='C')
print(arr0_c)

[0 1 2 3 4 5 6 7]

反转数组

arr0 = np.arange(8).reshape(2, 4)
print(np.transpose(arr0))

[[0 4]
 [1 5]
 [2 6]
 [3 7]]

也可以：

arr0 = np.arange(8).reshape(2, 4)
print(arr0.T)

[[0 4]
 [1 5]
 [2 6]
 [3 7]]

格式转换

借助于 tolist()，可以快速把 ndarray 格式的数组，转变为列表，方便在某些情况下使用。

arr0 = np.arange(8).reshape(2, 4)
print(arr0.tolist())

[[0, 1, 2, 3], [4, 5, 6, 7]]

小结：

1.一元函数

numpy.sin()
sin,cos,tan,sinh,cosh,tanh,arcsin,arccos,arctan,arcshinh,arccosh,arctanh。有h的是双曲
numpy.around(a,decimals)。a是数组，decimals是舍入的小数位数。默认是整数。
numpy.floor()向下取整
numpy.ceil()向上取整
numpy.rint()取到最接近的整数,不是四舍五入
numpy.abs()计算绝对值
numpy.sqrt()计算平方根
numpy.square()计算平方
numpy.exp()计算指数
numpy.log\log10\log2\log1p()计算以e为底，以10为底，以2为底，以（1+x）为底。
numpy.isnan()判断哪些值是NaN，返回布尔类型。

2.二元函数

numpy.add(arr1,arr2)加法
numpy.subtract(arr1,arr2)减法
numpy.multiply(arr1,arr2)乘法
numpy.divide(arr1,arr2)除法
numpy.power()幂运算
numpy.mod()取余
numpy.maximum（）最大值
maximum、fmax （fmax将忽略NaN）
minimum、fmin （fmin将忽略NaN）
greater、greater_equal
less、less_equal
equal、not_equal

3.统计函数

sum 对数组中的全部或沿着轴向的元素求和。
mean、median 求数组的算术平均值、中位数
std、var 分别为标准差和方差
min、max 最小值和最大值
argmin、argmax 分别为最小和最大元素的索引
cumsum 所有元素的累计和
cumprod 所有元素的累计积
percentile 计算数组的百分比分位数
有两种调用方法：
numpy.sum(arr)
arr.sum()
对二维数组来说，列是axis=0，行axis=1。
也是两种调用方法。
numpy.sum(arr,axis=1)
arr.sum(axis=1)
numpy.cummum()累计和
numpy.cumprod()累计差
同样可以传如axis
numpy.percentile(a, q, axis)百分数

4.数组操作

numpy.reshape 函数可以在不改变数据的条件下修改形状。
numpy.ndarray.flat 是一个数组元素迭代器，可以利用for循环对迭代器进行遍历。
numpy.ndarray.flatten返回一份数组拷贝，并折叠为一维的数组。对拷贝所做的修改不会影响原始数组。
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view），修改会影响原始数组。
numpy.transpose 函数用于对换数组的维度。
tolist()可以快速把 ndarray 格式的数组，转变为列表，方便在某些情况下使用。