系列文章：Numpy系列文章-CSDN博客
目录
在 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：根据指定条件返回元素索引。
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
