3、Numpy中的通用函数

      

目录

数学运算

三角函数

比较函数

位运算函数

统计函数

布尔/逻辑函数

浮点函数

排序、搜索和计数函数

---

        在 NumPy 中，通用函数（通常称为ufunc）是一种对 ndarray 中的数据执行元素级运算的函数。这些函数是高度优化的、快速的向量化包装器，提供了简单的方法对数组中的所有元素执行相同的操作，而不需要编写循环语句。以下是一些常见的 NumPy 通用函数：

数学运算

• np.add：元素级的数组加法。
• np.subtract：元素级的数组减法。
• np.multiply：元素级的数组乘法。
• np.divide：元素级的数组除法。
• np.sqrt：数组中每个元素的平方根。
• np.power：将数组中的元素提升到指定的幂。
• np.exp：计算数组中所有元素的指数 e^x。
• np.log，np.log2，np.log10：分别计算自然对数、以2为底和以10为底的对数。

import numpy as np

# 创建两个数组用于演示加法、减法、乘法和除法
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

# 加法
add_result = np.add(a, b)
print("Addition:", add_result)  # 结果: [ 6  8 10 12]

# 减法
subtract_result = np.subtract(b, a)
print("Subtraction:", subtract_result)  # 结果: [4 4 4 4]

# 乘法
multiply_result = np.multiply(a, b)
print("Multiplication:", multiply_result)  # 结果: [ 5 12 21 32]

# 除法
divide_result = np.divide(b, a)
print("Division:", divide_result)  # 结果: [5.  3.  2.33333333  2.]

# 创建一个数组用于演示平方根和幂运算
c = np.array([1, 4, 9, 16])

# 平方根
sqrt_result = np.sqrt(c)
print("Square root:", sqrt_result)  # 结果: [1. 2. 3. 4.]

# 幂运算
power_result = np.power(c, 2)
print("Power:", power_result)  # 结果: [  1  16  81 256]

# 创建一个数组用于演示指数和对数运算
d = np.array([1, 2, 3, 4])

# 指数
exp_result = np.exp(d)
print("Exponential:", exp_result)  # 结果: [ 2.71828183  7.3890561  20.08553692 54.59815003]

# 自然对数
log_result = np.log(d)
print("Natural logarithm:", log_result)  # 结果: [0.         0.69314718 1.09861229 1.38629436]

# 以2为底的对数
log2_result = np.log2(d)
print("Logarithm to the base 2:", log2_result)  # 结果: [0.         1.         1.5849625  2.        ]

# 以10为底的对数
log10_result = np.log10(d)
print("Logarithm to the base 10:", log10_result)  # 结果: [0.         0.30103    0.47712125 0.60205999]

三角函数

• np.sin：数组元素的正弦。
• np.cos：数组元素的余弦。
• np.tan：数组元素的正切。
• np.arcsin，np.arccos，np.arctan：计算反三角函数。

import numpy as np

# 创建一个角度数组，以弧度为单位（numpy的三角函数默认接受弧度值）
angles_radians = np.array([0, np.pi/2, np.pi, 3*np.pi/2])

# 计算正弦、余弦和正切
sin_values = np.sin(angles_radians)
cos_values = np.cos(angles_radians)
tan_values = np.tan(angles_radians)

print("Sine values: ", sin_values)  # 结果：[0. 1. 0. -1.]
print("Cosine values: ", cos_values)  # 结果：[1. 0. -1. 0.]
print("Tangent values: ", tan_values)  # 结果：[0. nan inf -0.]

# 计算反三角函数，给定一些在-1到1之间的值
inverses = np.array([-1, 0, 0.5, 1])  # 这些值对应于-π/2, 0, π/6, π/2的角度

arcsin_values = np.arcsin(inverses)
arccos_values = np.arccos(inverses)
arctan_values = np.arctan(inverses)

# 转换回角度制并打印结果
degrees = np.degrees([arcsin_values, arccos_values, arctan_values])

print("Degrees for arcsin: ", degrees[0])  # 结果：[-90.   0.  30.  90.]
print("Degrees for arccos: ", degrees[1])  # 结果：[90.   0. 120.  0.]
print("Degrees for arctan: ", degrees[2])  # 结果：[-45.   0.  45.  90.]

# 注意：由于arctan(-1)的结果是-pi/4，所以转换为角度时为-45度
# 同样，由于arcsin或arccos在边界值（-1和1）处返回的是±π/2，因此转换为角度时得到±90度
# 对于arccos(1)，由于cos(0)=1，所以arccos(1)的结果是0弧度，即0度

比较函数

• np.greater，np.greater_equal：逐元素比较两个数组（>, >=）。
• np.less，np.less_equal：逐元素比较两个数组（<, <=）。
• np.equal，np.not_equal：逐元素比较两个数组的相等性（==, !=）。

import numpy as np

# 创建两个数组用于比较
x = np.array([1, 3, 5, 7])
y = np.array([2, 3, 4, 7])

# 使用 np.greater 检查 x 中的元素是否大于 y 中对应的元素
greater_result = np.greater(x, y)
print("Greater (>):", greater_result)
# 预期结果: [False False  True False]

# 使用 np.greater_equal 检查 x 中的元素是否大于等于 y 中对应的元素
greater_equal_result = np.greater_equal(x, y)
print("Greater or equal (>=):", greater_equal_result)
# 预期结果: [False  True  True  True]

# 使用 np.less 检查 x 中的元素是否小于 y 中对应的元素
less_result = np.less(x, y)
print("Less (<):", less_result)
# 预期结果: [ True False False False]

# 使用 np.less_equal 检查 x 中的元素是否小于等于 y 中对应的元素
less_equal_result = np.less_equal(x, y)
print("Less or equal (<=):", less_equal_result)
# 预期结果: [ True  True False  True]

# 使用 np.equal 检查 x 和 y 中对应元素是否相等
equal_result = np.equal(x, y)
print("Equal (==):", equal_result)
# 预期结果: [False  True False  True]

# 使用 np.not_equal 检查 x 和 y 中对应元素是否不等
not_equal_result = np.not_equal(x, y)
print("Not equal (!=):", not_equal_result)
# 预期结果: [ True False  True False]

位运算函数

• np.bitwise_and：数组元素的位与操作。
• np.bitwise_or：数组元素的位或操作。
• np.bitwise_xor：数组元素的位异或操作。
• np.bitwise_not：数组元素的位非操作。

统计函数

• np.sum：计算数组元素的总和。
• np.prod：计算数组元素的乘积。
• np.mean：计算数组元素的平均值。
• np.std：计算数组元素的标准差。
• np.var：计算数组元素的方差。
• np.min，np.max：查找数组中的最小值和最大值。
• np.argmin，np.argmax：查找数组中最小值和最大值的索引。

# np.sum()：此函数用于计算数组中所有元素的总和。
# 一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print(np.sum(arr1))  # 输出：15

# 二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(np.sum(arr2))  # 输出：21（所有元素之和）
print(np.sum(arr2, axis=0))  # 输出：[5, 7, 9]（每一列之和）
print(np.sum(arr2, axis=1))  # 输出：[6, 15]（每一行之和）

# np.prod()：此函数计算数组中所有元素的乘积。
arr3 = np.array([1, 2, 3, 4, 5])
print(np.prod(arr3))  # 输出：120（所有元素相乘）

arr4 = np.array([[1, 2], [3, 4]])
print(np.prod(arr4))  # 输出：24（所有元素相乘）
print(np.prod(arr4, axis=0))  # 输出：[3, 8]（对应位置元素相乘）
print(np.prod(arr4, axis=1))  # 输出：[2, 12]（每一行元素相乘）

# np.mean()：此函数计算数组元素的平均值。
arr5 = np.array([1, 2, 3, 4, 5])
print(np.mean(arr5))  # 输出：3.0（所有元素平均值）

arr6 = np.array([[1, 2], [3, 4]])
print(np.mean(arr6))  # 输出：2.5（所有元素平均值）
print(np.mean(arr6, axis=0))  # 输出：[2.0, 3.0]（每一列平均值）
print(np.mean(arr6, axis=1))  # 输出：[1.5, 3.5]（每一行平均值）

# np.std() 和 np.var()：这两个函数分别计算数组元素的标准差和方差。
arr7 = np.array([1, 2, 3, 4, 5])
print(np.std(arr7))  # 输出：1.4142135623730951（标准差）
print(np.var(arr7))  # 输出：2.0（方差）

arr8 = np.array([[1, 2], [3, 4]])
print(np.std(arr8))  # 输出：1.118033988749895（所有元素的标准差）
print(np.var(arr8))  # 输出：1.25（所有元素的方差）
print(np.std(arr8, axis=0))  # 输出：[1., 1.]（每一列的标准差）
print(np.var(arr8, axis=0))  # 输出：[1., 1.]（每一列的方差）

# np.min() 和 np.max()：这两个函数查找数组中的最小值和最大值。
arr9 = np.array([1, 2, 3, 4, 5])
print(np.min(arr9))  # 输出：1（最小值）
print(np.max(arr9))  # 输出：5（最大值）

arr10 = np.array([[1, 2], [3, 4]])
print(np.min(arr10))  # 输出：1（整个数组的最小值）
print(np.max(arr10))  # 输出：4（整个数组的最大值）
print(np.min(arr10, axis=0))  # 输出：[1, 2]（每一列的最小值）
print(np.max(arr10, axis=0))  # 输出：[3, 4]（每一列的最大值）

# np.argmin() 和 np.argmax()：这两个函数返回数组中最小值和最大值对应的索引。
arr11 = np.array([1, 2, 3, 4, 5])
print(np.argmin(arr11))  # 输出：0（最小值的索引）
print(np.argmax(arr11))  # 输出：4（最大值的索引）

arr12 = np.array([[1, 2], [3, 4]])
print(np.argmin(arr12))  # 输出：0（整个数组中最小值的索引）
print(np.argmax(arr12))  # 输出：3（整个数组中最大值的索引）
print(np.argmin(arr12, axis=0))  # 输出：[0, 0]（每一列最小值的索引）
print(np.argmax(arr12, axis=0))  # 输出：[1, 1]（每一列最大值的索引）

布尔/逻辑函数

• np.logical_and，np.logical_or，np.logical_not，np.logical_xor：逻辑运算。

import numpy as np

# 创建两个布尔数组用于逻辑运算
a = np.array([True, False, True, False])
b = np.array([True, True, False, False])

# 逻辑 AND 运算
logical_and_result = np.logical_and(a, b)
print("Logical AND:", logical_and_result)
# 预期结果: [ True False False False]

# 逻辑 OR 运算
logical_or_result = np.logical_or(a, b)
print("Logical OR:", logical_or_result)
# 预期结果: [ True  True  True False]

# 逻辑 NOT 运算
logical_not_result = np.logical_not(a)
print("Logical NOT:", logical_not_result)
# 预期结果: [False  True False  True]

# 逻辑 XOR 运算
logical_xor_result = np.logical_xor(a, b)
print("Logical XOR:", logical_xor_result)
# 预期结果: [False  True  True False]

        请注意，虽然这里的例子使用了布尔类型的数组，但逻辑运算函数也可以应用于非布尔类型的数组。在这种情况下，非零元素被视为 True，零元素被视为 False。 

浮点函数

• np.isfinite，np.isinf：检测元素是否是有限的或无限的。
• np.isnan：检测元素是否是 NaN（不是一个数字）。

import numpy as np

# 创建一个包含有限、无限和 NaN 值的数组
arr = np.array([1, np.inf, -np.inf, np.nan, 2])

# 检测元素是否是有限的
is_finite_result = np.isfinite(arr)
print("Is finite:", is_finite_result)
# 预期结果: [ True False False False  True]

# 检测元素是否是无限的
is_inf_result = np.isinf(arr)
print("Is infinite:", is_inf_result)
# 预期结果: [False  True  True False False]

# 检测元素是否是 NaN（不是一个数字）
is_nan_result = np.isnan(arr)
print("Is NaN:", is_nan_result)
# 预期结果: [False False False  True False]

排序、搜索和计数函数

• np.sort：对数组进行排序。
• np.argsort：返回排序的索引。
• np.argmax，np.argmin：找到最大值和最小值的索引。
• np.nonzero：找到数组中非零元素的索引。
• np.where：根据指定条件返回元素索引。

4、ndarray排序、搜索和计数函数-CSDN博客numpy其余常用函数参考：3、Numpy中的通用函数-CSDN博客在 NumPy 中，通用函数（通常称为ufunc）是一种对 ndarray 中的数据执行元素级运算的函数。这些函数是高度优化的、快速的向量化包装器，提供了简单的方法对数组中的所有元素执行相同的操作，而不需要编写循环语句。https://blog.csdn.net/sinat_34461199/article/details/135642638