Tabla de contenido
Tres funciones trigonométricas
| función | descripción | uso |
|---|---|---|
| abs fabs |
Calcular el valor absoluto de un número entero / flotante / complejo. Calcular el valor absoluto de la versión rápida sin números complejos |
np.abs () np.fabs () |
| sqrt | Calcula la raíz cuadrada del elemento. Equivalente a matriz ** 0.5 | np.sqrt () |
| cuadrado | Calcula el cuadrado del elemento. Equivalente a matriz ** 2 | por ejemplo, squart () |
| Exp | Calcule la potencia a la base de la constante natural e | np.exp () |
| log log10 log2 log1p |
Logaritmo natural (e) Logaritmo basado en 10 Logaritmo basado en 2 Logaritmo basado en log (1 + x) |
np.log () np.log10 () np.log2 () np.log1p () |
| firmar | El signo del elemento calculado: 1: número positivo 0: 0 -1: número negativo | np.sign () |
| hacer techo | Calcular el número entero más pequeño mayor o igual que un elemento | np.ceil () |
| suelo | Calcule el entero más grande menor o igual que un elemento | np.floor () |
| rint | Redondea números de punto flotante al número entero más cercano, pero no cambias el tipo de números de punto flotante | p. ej., print () |
| modf | Devuelve una matriz de las partes enteras y fraccionarias de un número de punto flotante, respectivamente | por ejemplo, modf () |
| isnan | Devuelve una matriz booleana que identifica qué elementos son NaN (no un número) | np.isnan () |
| isfinite isinf |
Devuelve una matriz booleana que identifica qué elementos son finitos (no inf, no NaN) o infinitos | e.g.isfiniter () por ejemplo isinf () |
| cos, cosh, pecado sinh, bronceado, tanh | Funcion trigonometrica | |
| arccos, arccosh, arcsin, arcsinh, arctan, arctanh | Función trigonométrica inversa | |
| lógico_y / o / no / xor | AND / OR / NOT / XOR lógico es equivalente a '&' '|' '!' '^' | Prueba ver a continuación |
# 逻辑与
>>> np.logical_and(True, False)
False
>>> np.logical_and([True, False], [False, False])
array([False, False], dtype=bool)
>>> x = np.arange(5)
>>> np.logical_and(x>1, x<4)
array([False, False, True, True, False], dtype=bool)
# 逻辑或
>>> np.logical_or(True, False)
True
>>> np.logical_or([True, False], [False, False])
array([ True, False], dtype=bool)
>>> x = np.arange(5)
>>> np.logical_or(x < 1, x > 3)
array([ True, False, False, False, True], dtype=bool)
# 逻辑非
>>> np.logical_not(3)
False
>>> np.logical_not([True, False, 0, 1])
array([False, True, True, False], dtype=bool)
>>> x = np.arange(5)
>>> np.logical_not(x<3)
array([False, False, False, True, True], dtype=bool)
# 逻辑异或
>>> np.logical_xor(True, False)
True
>>> np.logical_xor([True, True, False, False], [True, False, True, False])
array([False, True, True, False], dtype=bool)
>>> x = np.arange(5)
>>> np.logical_xor(x < 1, x > 3)
array([ True, False, False, False, True], dtype=bool)
>>> np.logical_xor(0, np.eye(2))
array([[ True, False],
[False, True]], dtype=bool)
Uno, vectorización y difusión
Los dos conceptos de vectorización y difusión son la base de la implementación interna de numpy. Con la vectorización, no es necesario utilizar bucles explícitos al escribir código. Estos bucles no se pueden omitir en realidad, sino que se implementan internamente y se reemplazan por otras estructuras en el código. La aplicación de la vectorización hace que el código sea más conciso y legible, también se puede decir que el código que usa el método de vectorización se ve más "Pythonic".
El mecanismo de difusión describe cómo numpy maneja matrices de diferentes formas durante las operaciones aritméticas, lo que permite que las matrices más pequeñas se "difundan" en matrices más grandes para que tengan formas compatibles. No todas las dimensiones deben ser compatibles entre sí para cumplir con los requisitos del mecanismo de transmisión, pero deben cumplir ciertas condiciones.
Si las dimensiones de las dos matrices son compatibles, es decir, cada dimensión de las dos matrices tiene la misma longitud, o una de las matrices es unidimensional, entonces el mecanismo de difusión es aplicable. Si no se cumplen estas dos condiciones, numpy lanzará una excepción diciendo que las dos matrices son incompatibles.
En resumen, hay tres reglas para la transmisión:
- Si las dimensiones atenuadas de las dos matrices no son las mismas, entonces la forma de la matriz de dimensiones pequeñas se rellenará con 1 a la izquierda.
- Si la dimensión de la forma no coincide, pero una dimensión es 1, entonces la dimensión de la dimensión 1 se puede expandir para que coincida con otra matriz;
- Si las dimensiones de la forma no coinciden, pero ninguna de las dimensiones es 1, la coincidencia provocará un error;
二维数组加一维数组
import numpy as np
x = np.arange(4)
y = np.ones((3, 4))
print(x.shape) # (4,)
print(y.shape) # (3, 4)
print((x + y).shape) # (3, 4)
print(x + y)
# [[1. 2. 3. 4.]
# [1. 2. 3. 4.]
# [1. 2. 3. 4.]]两个数组均需要广播
import numpy as np
x = np.arange(4).reshape(4, 1)
y = np.ones(5)
print(x.shape) # (4, 1)
print(y.shape) # (5,)
print((x + y).shape) # (4, 5)
print(x + y)
# [[1. 1. 1. 1. 1.]
# [2. 2. 2. 2. 2.]
# [3. 3. 3. 3. 3.]
# [4. 4. 4. 4. 4.]]
x = np.array([0.0, 10.0, 20.0, 30.0])
y = np.array([1.0, 2.0, 3.0])
z = x[:, np.newaxis] + y
print(z)
# [[ 1. 2. 3.]
# [11. 12. 13.]
# [21. 22. 23.]
# [31. 32. 33.]]不匹配报错的例子
import numpy as np
x = np.arange(4)
y = np.ones(5)
print(x.shape) # (4,)
print(y.shape) # (5,)
print(x + y)
# ValueError: operands could not be broadcast together with shapes (4,) (5,) 2. Funciones matemáticas
Operaciones aritmeticas
numpy.add
numpy restar
numpy.multiply
numpy.divide
numpy.floor_divide
numpy.power
numpy.add(x1, x2, *args, **kwargs)Agregue argumentos por elementos.numpy.subtract(x1, x2, *args, **kwargs)Resta argumentos por elementos.numpy.multiply(x1, x2, *args, **kwargs)Multiplica los argumentos por elementos.numpy.divide(x1, x2, *args, **kwargs)Devuelve una verdadera división de las entradas, por elementos.numpy.floor_divide(x1, x2, *args, **kwargs)Devuelve el entero más grande, menor o igual a la división de las entradas.numpy.power(x1, x2, *args, **kwargs)Primeros elementos de la matriz elevados a potencias desde la segunda matriz, por elementos.
Las funciones anteriores están sobrecargadas en número y los operadores son a nivel de elemento . En otras palabras, solo se usan entre elementos con la misma posición y el resultado de la operación se forma en una nueva matriz.
注意 numpy 的广播规则。
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x + 1
print(y)
print(np.add(x, 1))
# [2 3 4 5 6 7 8 9]
y = x - 1
print(y)
print(np.subtract(x, 1))
# [0 1 2 3 4 5 6 7]
y = x * 2
print(y)
print(np.multiply(x, 2))
# [ 2 4 6 8 10 12 14 16]
y = x / 2
print(y)
print(np.divide(x, 2))
# [0.5 1. 1.5 2. 2.5 3. 3.5 4. ]
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]注意 numpy 的广播规则。
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 = x + 1
print(y)
print(np.add(x, 1))
# [[12 13 14 15 16]
# [17 18 19 20 21]
# [22 23 24 25 26]
# [27 28 29 30 31]
# [32 33 34 35 36]]
y = x - 1
print(y)
print(np.subtract(x, 1))
# [[10 11 12 13 14]
# [15 16 17 18 19]
# [20 21 22 23 24]
# [25 26 27 28 29]
# [30 31 32 33 34]]
y = x * 2
print(y)
print(np.multiply(x, 2))
# [[22 24 26 28 30]
# [32 34 36 38 40]
# [42 44 46 48 50]
# [52 54 56 58 60]
# [62 64 66 68 70]]
y = x / 2
print(y)
print(np.divide(x, 2))
# [[ 5.5 6. 6.5 7. 7.5]
# [ 8. 8.5 9. 9.5 10. ]
# [10.5 11. 11.5 12. 12.5]
# [13. 13.5 14. 14.5 15. ]
# [15.5 16. 16.5 17. 17.5]]
y = x // 2
print(y)
print(np.floor_divide(x, 2))
# [[ 5 6 6 7 7]
# [ 8 8 9 9 10]
# [10 11 11 12 12]
# [13 13 14 14 15]
# [15 16 16 17 17]]
y = x ** 2
print(y)
print(np.power(x, 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]]注意 numpy 的广播规则。
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.arange(1, 6)
print(y)
# [1 2 3 4 5]
z = x + y
print(z)
print(np.add(x, y))
# [[12 14 16 18 20]
# [17 19 21 23 25]
# [22 24 26 28 30]
# [27 29 31 33 35]
# [32 34 36 38 40]]
z = x - y
print(z)
print(np.subtract(x, y))
# [[10 10 10 10 10]
# [15 15 15 15 15]
# [20 20 20 20 20]
# [25 25 25 25 25]
# [30 30 30 30 30]]
z = x * y
print(z)
print(np.multiply(x, y))
# [[ 11 24 39 56 75]
# [ 16 34 54 76 100]
# [ 21 44 69 96 125]
# [ 26 54 84 116 150]
# [ 31 64 99 136 175]]
z = x / y
print(z)
print(np.divide(x, y))
# [[11. 6. 4.33333333 3.5 3. ]
# [16. 8.5 6. 4.75 4. ]
# [21. 11. 7.66666667 6. 5. ]
# [26. 13.5 9.33333333 7.25 6. ]
# [31. 16. 11. 8.5 7. ]]
z = x // y
print(z)
print(np.floor_divide(x, y))
# [[11 6 4 3 3]
# [16 8 6 4 4]
# [21 11 7 6 5]
# [26 13 9 7 6]
# [31 16 11 8 7]]
z = x ** np.full([1, 5], 2)
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]]Tres funciones trigonométricas
numpy.sin
numpy.cos
numpy.tan
numpy.arcsin
numpy.arccos
numpy.arctan
numpy.sin(x, *args, **kwargs)Seno trigonométrico, elemento-sabio.numpy.cos(x, *args, **kwargs)Elemento coseno sabio.numpy.tan(x, *args, **kwargs)Calcule la tangente por elementos.numpy.arcsin(x, *args, **kwargs)Seno inverso, elemento-sabio.numpy.arccos(x, *args, **kwargs)Coseno inverso trigonométrico, elemento-sabio.numpy.arctan(x, *args, **kwargs)Tangente inversa trigonométrica, elemento-sabio.
La función universal ( función universal) generalmente se llama ufunc, que opera en cada elemento de la matriz uno por uno. Esto muestra que la función general procesa cada elemento de la matriz de entrada por separado y el resultado generado forma una nueva matriz de salida. La matriz de salida tiene el mismo tamaño que la matriz de entrada.
Muchas operaciones matemáticas, como las funciones trigonométricas, se ajustan a la definición de funciones generales, como funciones para calcular raíces cuadradas, sqrt()funciones para tomar logaritmos y log()funciones para encontrar valores sinusoidales sin().
import numpy as np
x = np.linspace(start=0, stop=np.pi / 2, num=10)
print(x)
# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463
# 1.04719755 1.22173048 1.3962634 1.57079633]
y = np.sin(x)
print(y)
# [0. 0.17364818 0.34202014 0.5 0.64278761 0.76604444
# 0.8660254 0.93969262 0.98480775 1. ]
z = np.arcsin(y)
print(z)
# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463
# 1.04719755 1.22173048 1.3962634 1.57079633]
y = np.cos(x)
print(y)
# [1.00000000e+00 9.84807753e-01 9.39692621e-01 8.66025404e-01
# 7.66044443e-01 6.42787610e-01 5.00000000e-01 3.42020143e-01
# 1.73648178e-01 6.12323400e-17]
z = np.arccos(y)
print(z)
# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463
# 1.04719755 1.22173048 1.3962634 1.57079633]
y = np.tan(x)
print(y)
# [0.00000000e+00 1.76326981e-01 3.63970234e-01 5.77350269e-01
# 8.39099631e-01 1.19175359e+00 1.73205081e+00 2.74747742e+00
# 5.67128182e+00 1.63312394e+16]
z = np.arctan(y)
print(z)
# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463
# 1.04719755 1.22173048 1.3962634 1.57079633]Cuatro, función lógica
Prueba de la verdad
numpy.todos
numpy.any
numpy.all(a, axis=None, out=None, keepdims=np._NoValue)Pruebe si todos los elementos de la matriz a lo largo de un eje dado se evalúan como Verdadero.numpy.any(a, axis=None, out=None, keepdims=np._NoValue)Pruebe si algún elemento de la matriz a lo largo de un eje dado se evalúa como Verdadero.-
import numpy as np a = np.array([0, 4, 5]) b = np.copy(a) print(np.all(a == b)) # True print(np.any(a == b)) # True b[0] = 1 print(np.all(a == b)) # False print(np.any(a == b)) # True print(np.all([1.0, np.nan])) # True print(np.any([1.0, np.nan])) # True a = np.eye(3) print(np.all(a, axis=0)) # [False False False] print(np.any(a, axis=0)) # [ True True True]
matriz content¶
numpy.isnan
numpy.isnan(x, *args, **kwargs)Pruebe el elemento en busca de NaN y devuelva el resultado como una matriz booleana.
a=np.array([1,2,np.nan])
print(np.isnan(a))
#[False False True]operación lógica
numpy.logical_not
numpy.logical_and
numpy.logical_or
numpy.logical_xor
numpy.logical_not(x, *args, **kwargs)Calcule el valor de verdad de NOT x elemento-sabio.numpy.logical_and(x1, x2, *args, **kwargs)Calcule el valor de verdad de x1 Y x2 por elementos.numpy.logical_or(x1, x2, *args, **kwargs)Calcule el valor de verdad de x1 O x2 por elementos.numpy.logical_xor(x1, x2, *args, **kwargs)Calcule el valor de verdad de x1 XOR x2, por elementos.
计算非x元素的真值。
import numpy as np
print(np.logical_not(3))
# False
print(np.logical_not([True, False, 0, 1]))
# [False True True False]
x = np.arange(5)
print(np.logical_not(x < 3))
# [False False False True True]计算x1 AND x2元素的真值。
print(np.logical_and(True, False))
# False
print(np.logical_and([True, False], [True, False]))
# [ True False]
print(np.logical_and(x > 1, x < 4))
# [False False True True False]逐元素计算x1 OR x2的真值。
print(np.logical_or(True, False))
# True
print(np.logical_or([True, False], [False, False]))
# [ True False]
print(np.logical_or(x < 1, x > 3))
# [ True False False False True]计算x1 XOR x2的真值，按元素计算。
print(np.logical_xor(True, False))
# True
print(np.logical_xor([True, True, False, False], [True, False, True, False]))
# [False True True False]
print(np.logical_xor(x < 1, x > 3))
# [ True False False False True]
print(np.logical_xor(0, np.eye(2)))
# [[ True False]
# [False True]]Cinco, control
numpy.greater
numpy.greater_equal
numpy.equal
numpy.not_equal
numpy.less
numpy.less_equal
numpy.greater(x1, x2, *args, **kwargs)Devuelve el valor de verdad de (x1> x2) por elementos.numpy.greater_equal(x1, x2, *args, **kwargs)Devuelve el valor de verdad de (x1> = x2) por elementos.numpy.equal(x1, x2, *args, **kwargs)Devuelve (x1 == x2) elemento-sabio.numpy.not_equal(x1, x2, *args, **kwargs)Devuelve (x1! = X2) elemento-sabio.numpy.less(x1, x2, *args, **kwargs)Devuelve el valor de verdad de (x1 <x2) por elementos.numpy.less_equal(x1, x2, *args, **kwargs)Devuelve el valor de verdad de (x1 = <x2) por elementos.
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x > 2
print(y)
print(np.greater(x, 2))
# [False False True True True True True True]
y = x >= 2
print(y)
print(np.greater_equal(x, 2))
# [False True True True True True True True]
y = x == 2
print(y)
print(np.equal(x, 2))
# [False True False False False False False False]
y = x != 2
print(y)
print(np.not_equal(x, 2))
# [ True False True True True True True True]
y = x < 2
print(y)
print(np.less(x, 2))
# [ True False False False False False False False]
y = x <= 2
print(y)
print(np.less_equal(x, 2))
# [ True True False False False False False False]numpy.isclose
numpy.allclose
numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)Devuelve una matriz booleana donde dos matrices son iguales en elementos dentro de una tolerancia.numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)Devuelve True si dos matrices son iguales en elementos dentro de una tolerancia.
numpy.allclose() Es equivalente a numpy.all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)).
Los valores de tolerancia son positivos, normalmente números muy pequeños. La diferencia relativa ( rtol * abs(b)) y la diferencia absoluta atol se suman para comparar con la diferencia absoluta entre a y b.
La base de cálculo para juzgar si es Verdadero:
np.absolute(a - b) <= (atol + rtol * absolute(b))
- atol：float，绝对公差。
- rtol：float，相对公差。np.absolute (a-b) <= (atol + rtol * absolute (b)) -atol: flotante, tolerancia absoluta. -rtol: flotación, tolerancia relativa.
Los NaN se tratan como iguales si están en el mismo lugar y si equal_nan=True. Los inf se tratan como iguales si están en el mismo lugar y tienen el mismo signo en ambas matrices.
比较两个数组是否可以认为相等。
import numpy as np
x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])
print(x) # [ True False]
x = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])
print(x) # False
x = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])
print(x) # [ True True]
x = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])
print(x) # True
x = np.isclose([1e10, 1e-8], [1.0001e10, 1e-9])
print(x) # [False True]
x = np.allclose([1e10, 1e-8], [1.0001e10, 1e-9])
print(x) # False
x = np.isclose([1.0, np.nan], [1.0, np.nan])
print(x) # [ True False]
x = np.allclose([1.0, np.nan], [1.0, np.nan])
print(x) # False
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) # TrueSeis, índice y logaritmo
numpy.exp
numpy.log
numpy.exp2 ¶
numpy.log2
numpy.log10
numpy.exp(x, *args, **kwargs)Calcule el exponencial de todos los elementos en la matriz de entrada.numpy.log(x, *args, **kwargs)Logaritmo natural, por elementos.numpy.exp2(x, *args, **kwargs)Calcule2**ppara todospen la matriz de entrada.numpy.log2(x, *args, **kwargs)Logaritmo en base 2 dex.numpy.log10(x, *args, **kwargs)Devuelve el logaritmo en base 10 de la matriz de entrada, por elementos.
The natural logarithm log is the inverse of the exponential function, so that log(exp(x)) = x. The natural logarithm is logarithm in base e.
import numpy as np
x = np.arange(1, 5)
print(x)
# [1 2 3 4]
y = np.exp(x)
print(y)
# [ 2.71828183 7.3890561 20.08553692 54.59815003]
z = np.log(y)
print(z)
# [1. 2. 3. 4.]