Numpy4_数学函数及逻辑函数_Datawhale十月组队学习

柔光的暖阳◎ 2023-10-07 15:01 64阅读 0赞

## Numpy学习|数学函数及逻辑函数 ##

#### 文章目录 ####

*  Numpy学习|数学函数及逻辑函数
 *  
 *  1.加减乘除取余乘幂
 *  2.平方根平方
 *  3.三角函数
 *  4.指数对数
 *  5.加法函数乘法函数
 *  6.逻辑函数

--------------------

##  ##

涉及更改形状、维度；数组组合、拆分、平铺；添加删除操作等

## 1.加减乘除取余乘幂 ##

--------------------

numpy.add（x1，x2，\* args，\*\* kwargs） \# 逐元素加上参数。  
numpy.subtract（x1，x2，\* args，\*\* kwargs）\# 逐元素减去参数。  
numpy.multiply（x1，x2，\* args，\*\* kwargs）\# 对元素逐个乘法参数。  
numpy.divide（x1，x2，\* args，\*\* kwargs） \#按元素返回输入的真实除法。  
numpy.floor\_divide（x1，x2，\* args，\*\* kwargs）\#返回小于或等于输入除法的最大整数。  
numpy.power（x1，x2，\* args，\*\* kwargs） \# 将第一个数组元素从第二个数组提升为幂

import numpy as np
    x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
    y = x // 2
    print(y)
    print(np.floor_divide(x, 2))
    # [0 1 1 2 2 3 3 4]
    y = x ** 2
    print(y)
    print(np.power(x, 2))
    # [ 1 4 9 16 25 36 49 64]

import numpy as np
    x = np.array([
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20],
    [21, 22, 23, 24, 25],
    [26, 27, 28, 29, 30],
    [31, 32, 33, 34, 35]])
    z = x ** np.full([1, 5], 2)
    # 返回具有给定形状和类型的新数组，并用fill_value填充。
    print(z)
    print(np.power(x, np.full([5, 5], 2)))
    # [[ 121 144 169 196 225]
    # [ 256 289 324 361 400]
    # [ 441 484 529 576 625]
    # [ 676 729 784 841 900]
    # [ 961 1024 1089 1156 1225]]

## 2.平方根平方 ##

--------------------

1.  numpy.sqrt（x，\* args，\*\* kwargs）按元素返回数组的非负平方根。
2.  numpy.square（x，\* args，\*\* kwargs）返回输入的按元素平方。

import numpy as np
    x = np.arange(1, 5)
    print(x) # [1 2 3 4]
    y = np.sqrt(x)
    print(y)
    # [1. 1.41421356 1.73205081 2. ]
    print(np.power(x, 0.5))
    # [1. 1.41421356 1.73205081 2. ]

## 3.三角函数 ##

--------------------

1.  numpy.sin（x，\* args，\*\* kwargs）三角正弦，逐元素。
2.  numpy.cos（x，\* args，\*\* kwargs）余弦元素方式。
3.  numpy.tan（x，\* args，\*\* kwargs）按元素计算切线。
4.  numpy.arcsin（x，\* args，\*\* kwargs）反正弦，逐元素。
5.  numpy.arccos（x，\* args，\*\* kwargs）三角反余弦，逐元素。
6.  numpy.arctan（x，\* args，\*\* kwargs）三角反切线，逐元素

通用函数（universal function）通常叫作ufunc，它对数组中的各个元素逐一进行操作。这表明，通用函数分别处理输入数组的每个元素，生成的结果组成一个新的输出数组。输出数组的大小跟输入数组相同

## 4.指数对数 ##

--------------------

1.  numpy.exp（x，\* args，\*\* kwargs）计算输入数组中所有元素的指数。
2.  numpy.log（x，\* args，\*\* kwargs）自然对数，逐元素。
3.  numpy.exp2（x，\* args，\*\* kwargs）为输入数组中的所有p计算2 \*\* p。
4.  numpy.log2（x，\* args，\*\* kwargs）x的以2为底的对数。
5.  numpy.log10（x，\* args，\*\* kwargs）以元素为单位返回输入数组的以10为底的对数

## 5.加法函数乘法函数 ##

--------------------

1.  numpy.sum(a\[, axis=None, dtype=None, out=None, …\]) Sum of array elements over a given axis.

通过不同的 axis ，numpy 会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果 axis=0 ，则沿着纵轴进行操作； axis=1 ，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设 axis=i ，则 numpy 沿着第 i 个下标变化的方向进行操作

import numpy as np
    x = np.array([
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20],
    [21, 22, 23, 24, 25],
    [26, 27, 28, 29, 30],
    [31, 32, 33, 34, 35]])
    y = np.sum(x)
    print(y) # 575
    y = np.sum(x, axis=0)
    print(y) # [105 110 115 120 125]
    y = np.sum(x, axis=1)
    print(y) # [ 65 90 115 140 165]

1.  numpy.cumsum(a, axis=None, dtype=None, out=None) Return the cumulative sum of the elements along a given axis.  
    聚合函数 是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因而，求数组所有元素之和的函数就是聚合函数。ndarray 类实现了多个这样的函数。

y = np.cumsum(x)
    print(y)
    # [ 11 23 36 50 65 81 98 116 135 155 176 198 221 245 270 296 323 351
    # 380 410 441 473 506 540 575]

1.  numpy.prod（a \[，axis = None，dtype = None，out = None，…\]）返回给定轴上数组元素的乘积。
2.  numpy.cumprod（a，axis = None，dtype = None，out = None）返回沿给定轴的元素的累积积。
3.  numpy.diff（a，n = 1，axis = -1，prepend = np.\_NoValue，append = np.\_NoValue）计算沿给定值的第n个离散差轴。一种。  
    a：输入矩阵  
    n：任选，代表要执行几次差值  
    轴：默认是最后一个  
    沿给定轴的第一个差异为out \[i\] = a \[i + 1\]-a \[i\]，通过递归使用diff计算更高的差异

import numpy as np
    A = np.arange(2, 14).reshape((3, 4))
    A[1, 1] = 8
    print(A)
    # [[ 2 3 4 5]
    # [ 6 8 8 9]
    # [10 11 12 13]]
    print(np.diff(A))
    # [[1 1 1]
    # [2 0 1]
    # [1 1 1]]
    print(np.diff(A, axis=0))
    # [[4 5 4 4]
    # [4 3 4 4]]

## 6.逻辑函数 ##

--------------------

1.  numpy.isnan（x，\* args，\*\* kwargs）对NaN逐元素进行测试，并以布尔数组形式返回结果
2.  numpy.logical\_not（x，\* args，\*\* kwargs）计算非x元素的真值。
3.  numpy.logical\_and（x1，x2，\* args，\*\* kwargs）计算x1和x2元素的真值。
4.  numpy.logical\_or（x1，x2，\* args，\*\* kwargs）计算x1或x2元素的真值。
5.  numpy.logical\_xor（x1，x2，\* args，\*\* kwargs）按元素计算x1 XOR x2的真值。
6.  numpy.greater（x1，x2，\* args，\*\* kwargs）逐元素返回（x1> x2）的真值。
7.  numpy.greater\_equal（x1，x2，\* args，\*\* kwargs）逐元素返回（x1> = x2）的真值。
8.  numpy.equal（x1，x2，\* args，\*\* kwargs）逐元素返回（x1 == x2）。
9.  numpy.not\_equal（x1，x2，\* args，\*\* kwargs）逐元素返回（x1！= x2）。
10. numpy.less（x1，x2，\* args，\*\* kwargs）逐元素返回（x1 <x2）的真值。
11. numpy.less\_equal（x1，x2，\* args，\*\* kwargs）逐元素返回（x1 = <x2）的真值。
12. numpy.isclose（a，b，rtol = 1.e-5，atol = 1.e-8，equal\_nan = False）返回一个布尔数组，其中两个数组在元素上相等，在公差范围内。
13. numpy.allclose（a，b，rtol = 1.e-5，atol = 1.e-8，equal\_nan = False）如果两个数组在a中按元素方式相等，则返回True公差。  
    numpy.allclose（）等价于numpy.all（isclose（a，b，rtol = rtol，atol = atol，equal\_nan = equal\_nan））。  
    公差值是正的，通常很小。 相对差（rtol \* abs（b））和绝对差atol相加一起比较a和b的绝对差。

判断是否为True的计算依据

np.absolute(a - b) <= (atol + rtol \* absolute(b))

*  atol：float，绝对公差。
 *  rtol：float，相对公差。

如果NaN位于同一位置并且equal\_nan = True，则将它们视为相等。 如果两个数组中的inf位于相同位置且具有相同符号，则将它们视为相等。

x = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
    print(x) # [ True True]
    x = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
    print(x) # True