8 月 2021 - Page 2 of 2

numpy statistic functions 数组操作的基本函数入门(二)

NumPy 是 Python 科学计算的基础包。除去三角、算术函数等基础函数，基本的统计函数是必不可少的。
NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

1、最大最小及相关函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.ptp() 函数计算数组中元素最大值与最小值的差（最大值 – 最小值）

    a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
    print("a = ", a)
    # 求列最大
    print("np.amax(a, 0) = ", np.amax(a, 0))
    # 求行最大
    print("np.amax(a, 1) = ", np.amax(a, 1))
    # 求行最小
    print("np.amin(a, 1) = ", np.amin(a, 1))

    # numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
    # 所有元素最大-最小
    print("np.ptp(a) = ", np.ptp(a))
    # 按行/x轴/1轴求 最大-最小
    print("np.ptp(a, 1) = ", np.ptp(a, 1))
    # 按列/y轴/0轴 最大 -最小
    print("np.ptp(a, 0) = ", np.ptp(a, 0))

a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.amax(a, 0) =  [8 7 9]
np.amax(a, 1) =  [7 8 9]
np.amin(a, 1) =  [3 3 2]
np.ptp(a) =  7
np.ptp(a, 1) =  [4 5 7]
np.ptp(a, 0) =  [6 3 6]

2、百分比函数

np.percentile(a, q,axis)百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。
numpy.median() 函数用于计算数组 a 中元素的中位数（中值

    # a: 输入数组
    # q: 要计算的百分位数，在 0 ~ 100 之间
    # axis: 沿着它计算百分位数的轴
    print("np.percentile(a, 70) =", np.percentile(a, 70))
    print("np.percentile(a, 50, 1) =", np.percentile(a, 50, 1))
    print("np.percentile(a, 50, 0) =", np.percentile(a, 50, 0))
    # numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
    print("np.median(a) = ", np.median(a))
    print("np.median(a, 1) = ", np.median(a, 1))
    print("np.median(a, 0) = ", np.median(a, 0))

a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.percentile(a, 70) = 6.199999999999999
np.percentile(a, 50, 1) = [5. 4. 4.]
np.percentile(a, 50, 0) = [3. 4. 5.]
np.median(a) =  4.0
np.median(a, 1) =  [5. 4. 4.]
np.median(a, 0) =  [3. 4. 5.]

3、均值、方差

numpy.mean() 函数返回数组中元素的算术平均值。如果提供了轴，则沿其计算。
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

    # 算术平均值是沿轴的元素的总和除以元素的数量。
    print("np.mean(a) = ", np.mean(a))
    print("np.mean(a, 1) =", np.mean(a, 1))
    print("np.mean(a, 0) = ", np.mean(a, 0))

    # numpy.average() 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
    # 如果没有轴参数，权重元素个数必须与数组展开后元素的个数相同，否则会报错
    # 数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。
    # 加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)
    # 不指定权重时相当于 mean 函数
    # 如果 returned 参数设为 true，则返回权重的和
    print(np.average(a))
    print(np.average(a, weights=np.array([4, 3, 2]), axis=1, returned=True))
    # 标准差是一组数据平均值分散程度的一种度量。
    # 标准差是方差的算术平方根。标准差公式如下：
    # std = sqrt(mean((x - x.mean())**2))
    # 如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
    print(np.std([1, 2, 3, 4]))
    # 统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。
    # 换句话说，标准差是方差的平方根。
    print(np.var([1, 2, 3, 4]))

a =  [[3 7 5]
 [8 4 3]
 [2 4 9]]
np.mean(a) =  5.0
np.mean(a, 1) = [5. 5. 5.]
np.mean(a, 0) =  [4.33333333 5.         5.66666667]
5.0
(array([4.77777778, 5.55555556, 4.22222222]), array([9., 9., 9.]))
1.118033988749895
1.25

numpy array functions 数组操作的基本函数入门(一)

NumPy 是 Python 科学计算的基础包。之前的文章中我们也numpy的数据类型，基本结构做了入门的讲解，本篇开始介绍numpy 数组相对应的操作函数。

NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。

三角函数

    # 标准的三角函数：sin()、cos()、tan();
    # arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。
    # 函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度
    a = np.array([0, 30, 45, 60, 90])
    print("a = ", a)
    print("正弦： np.sin(a * np.pi /180) = ", np.sin(a * np.pi/180))
    print("余弦： np.cos(a * np.pi / 180) = ", np.cos(a * np.pi / 180))
    sin = np.sin(a * np.pi/180)
    inv = np.arcsin(sin)
    print("sin = np.sin(a * np.pi/180)", "\n", "inv = np.arcsin(sin)")
    print("反正弦(弧度)：np.arcsin(sin) = ", inv)
    deg = np.degrees(inv)
    print("角度：np.degrees(inv) ", deg)

输出的结果：
a =  [ 0 30 45 60 90]
正弦： np.sin(a * np.pi /180) =  [0.         0.5        0.70710678 0.8660254  1.        ]
余弦： np.cos(a * np.pi / 180) =  [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]
sin = np.sin(a * np.pi/180) 
 inv = np.arcsin(sin)
反正弦(弧度)：np.arcsin(sin) =  [0.         0.52359878 0.78539816 1.04719755 1.57079633]
角度：np.degrees(inv)  [ 0. 30. 45. 60. 90.]

舍入函数

    # numpy.around(a,decimals) 函数返回指定数字的四舍五入值。
    # a: 数组
    # decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
    a = np.array([1.0, 5.55, 123, 0.567, 25.532])
    print("原始 a = ", a)
    print("np.around(a, decimals=1) = ", np.around(a, decimals=1))
    print("np.around(a, decimals=-1) = ", np.around(a, decimals=-1))

    # numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。
    # numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。
    a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
    print('提供的数组：', a)
    print('np.floor(a) = ', np.floor(a))
    print("np.ceil(a) = ", np.ceil(a))

输出结果：
原始 a =  [  1.      5.55  123.      0.567  25.532]
np.around(a, decimals=1) =  [  1.    5.6 123.    0.6  25.5]
np.around(a, decimals=-1) =  [  0.  10. 120.   0.  30.]
提供的数组： [-1.7  1.5 -0.2  0.6 10. ]
np.floor(a) =  [-2.  1. -1.  0. 10.]
np.ceil(a) =  [-1.  2. -0.  1. 10.]
a = np.arange(9, dtype=np.float_).reshape(3, 3)
b = np.array([10., 5., 1.])

算术函数

    # 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
    a = np.arange(9, dtype=np.float_).reshape(3, 3)
    b = np.array([10., 5., 1.])
    print("a = np.arange(9, dtype=np.float_).reshape(3, 3)")
    print("b = np.array([10., 5., 1.])")
    print("a = ", a)
    print("np.add(a, b) = ", np.add(a, b))
    print("np.subtract(a, b) =", np.subtract(a, b))
    print("np.multiply(a, b) = ", np.multiply(a, b))
    print("np.divide(a, b) = ", np.divide(a, b))

    # numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
    # numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
    print("np.reciprocal(b) = ", np.reciprocal(b))
    a = np.array([10, 100, 1000])
    print("a = np.array([10,100,1000])")
    print("np.power(a, 2) = ", np.power(a, 2))

    # numpy.mod()/numpy.remainder()  计算输入数组中相应元素的相除后的余数
    a = np.array([10, 20, 30])
    b = np.array([3, 5, 7])
    print("np.mod(a, b) = ", np.mod(a, b))
    print("np.remainder(a, b) = ", np.remainder(a, b))

输出结果：
a = np.arange(9, dtype=np.float_).reshape(3, 3)
b = np.array([10., 5., 1.])
a =  [[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
np.add(a, b) =  [[10.  6.  3.]
 [13.  9.  6.]
 [16. 12.  9.]]
np.subtract(a, b) = [[-10.  -4.   1.]
 [ -7.  -1.   4.]
 [ -4.   2.   7.]]
np.multiply(a, b) =  [[ 0.  5.  2.]
 [30. 20.  5.]
 [60. 35.  8.]]
np.divide(a, b) =  [[0.  0.2 2. ]
 [0.3 0.8 5. ]
 [0.6 1.4 8. ]]
np.reciprocal(b) =  [0.1 0.2 1. ]
a = np.array([10,100,1000])
np.power(a, 2) =  [    100   10000 1000000]
np.mod(a, b) =  [1 0 2]
np.remainder(a, b) =  [1 0 2]