3、Numpy中的通用函数

      

目录

数学运算

三角函数

比较函数

位运算函数

统计函数

布尔/逻辑函数

浮点函数

排序、搜索和计数函数


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

数学运算

  • np.add:元素级的数组加法。
  • np.subtract:元素级的数组减法。
  • np.multiply:元素级的数组乘法。
  • np.divide:元素级的数组除法。
  • np.sqrt:数组中每个元素的平方根。
  • np.power:将数组中的元素提升到指定的幂。
  • np.exp:计算数组中所有元素的指数 e^x。
  • np.lognp.log2np.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.arcsinnp.arccosnp.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.greaternp.greater_equal:逐元素比较两个数组(>, >=)。
  • np.lessnp.less_equal:逐元素比较两个数组(<, <=)。
  • np.equalnp.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.minnp.max:查找数组中的最小值和最大值。
  • np.argminnp.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_andnp.logical_ornp.logical_notnp.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.isfinitenp.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.argmaxnp.argmin:找到最大值和最小值的索引。
  • np.nonzero:找到数组中非零元素的索引。
  • np.where:根据指定条件返回元素索引。

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

你可能感兴趣的:(numpy,python,numpy,python)