función matemática
Vectorización y Broadcasting
Los dos conceptos de vectorización y transmisión son fundamentales para la implementación interna de numpy. Con la vectorización, no necesita usar bucles explícitos al escribir su código. En realidad, estos bucles no se pueden omitir, pero se implementan internamente y se reemplazan por otras construcciones en el código. La aplicación de la vectorización hace que el código sea más conciso y más 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 transmisión describe cómo numpy maneja matrices con diferentes formas durante las operaciones aritméticas, permitiendo que las matrices más pequeñas se "transmitan" sobre matrices más grandes para que tengan formas compatibles. No todas las dimensiones tienen que ser compatibles entre sí para calificar como 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 se aplica el mecanismo de difusión. Si no se cumplen estas dos condiciones, numpy lanzará una excepción diciendo que las dos matrices no son compatibles.
En resumen, hay tres reglas para la transmisión:
- Si el número de dimensiones dim de las dos matrices es diferente, 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 hay una dimensión de 1, entonces la dimensión de la dimensión 1 se puede extender para que coincida con otra matriz;
- Si las dimensiones de la forma no coinciden, pero ninguna de las dimensiones es 1, la coincidencia genera un error;
Matriz bidimensional más matriz unidimensional
import numpy as np
x = np.arange(4)
y = np.ones((3,4))
print(x+y)
[[1. 2. 3. 4.]
[1. 2. 3. 4.]
[1. 2. 3. 4.]]
Ambas matrices necesitan transmisión
import numpy as np
x = np.arange(4).reshape(4,1)
y = np.ones(5)
print(x+y)
[[1. 1. 1. 1. 1.]
[2. 2. 2. 2. 2.]
[3. 3. 3. 3. 3.]
[4. 4. 4. 4. 4.]]
función matemática
cálculo
- numpy.add(x1, x2, *args, **kwargs) Agrega.
import numpy as np
x = np.array([1,2,3,4,5,6,7,8])
print(np.add(x,1))
[2 3 4 5 6 7 8 9]
- numpy resta (x1, x2, *args, **kwargs) definido.
print(x)
print("++++++++++++++")
print(np.multiply(x,2))
imprimir(x)
imprimir("++++++++++++++")
imprimir(np.multiplicar(x,2))
imprimir(x)
imprimir("++++++++++ +++++")
imprimir(np.multiplicar(x,2))
[1 2 3 4 5 6 7 8]
++++++++++++++
[ 2 4 6 8 10 12 14 dieciséis]
- numpy .divide ( x 1 , x2 , * argumentos , ** kwargs ) Dispositivo .
print(x)
print('++++++++++++++')
print(np.divide(x,2))
[1 2 3 4 5 6 7 8]
++++++++++++++
[0.5 1. 1.5 2. 2.5 3. 3.5 4. ]
- numpy.floor_divide(x1, x2, *args, **kwargs) Divide y redondea hacia abajo.
print(x)
print('+++++++++++++++')
print(np.floor_divide(x,2))
[1 2 3 4 5 6 7 8]
++++++++++++++++
[0 1 1 2 2 3 3 4]
- numpy .power ( x 1 , x2 , * args , ** kvargs ) return .
print(x)
print('++++++++++++++')
print(np.power(x,2))
[1 2 3 4 5 6 7 8]
++++++++++++++
[ 1 4 9 16 25 36 49 64]
- numpy.sqrt(x, *args, **kwargs) Raíz cuadrada.
x = np.arange(1,5)
print(np.sqrt(x))
[1. 1.41421356 1.73205081 2. ]
- numpy.square(x, *args, **kwargs) cuadrado.
print(x)
print('++++++++++++++')
print(np.square(x))
[1 2 3 4]
++++++++++++++
[ 1 4 9 16]
Funciones trigonométricas
- numpy.sin(x, *args, **kwargs) Seno trigonométrico, por elementos.
- numpy.arcsin(x, *args, **kwargs) Seno inverso, por elementos.
import numpy as np
x = np.linspace(start=0,stop=np.pi, num=10)
print(x)
print('++++++++++++++')
y = np.sin(x)
print(y)
print('+++++++++++++++')
print(np.arcsin(y))
[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925 2.0943951
2.44346095 2.7925268 3.14159265]
++++++++++++++++
[0.00000000e+00 3. 42020143e-01 6.42787610e-01 8.66025404e-01
9.84807753e-01 9.84807753e-01 8.66025404
1.3 9626340e
_
_
_ +00 1.39626340e+00 1.04719755e+00 6.98131701e-01
3.49065850e-01 1.22464680e-16]
- numpy.cos(x, *args, **kwargs) Elemento coseno sabio.
- numpy.arccos(x, *args, **kwargs) Coseno inverso trigonométrico, por elementos.
print(x)
print('++++++++++++++')
y = np.cos(x)
print(y)
print('+++++++++++++++')
print(np.arccos(y))
[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925 2.0943951
2.44346095 2.7925268 3.14159265]
++++++++++++++
[ 1. 0.93969262 0. 76604444 0,5 0,17364818 -0,17364818
-0,5 -0,76604444 -0,93969262 -1. ]
++++++++++++++++
[0. 0,34906585 0,6981317 1,04719755 1,3962634
1,74532925 2,0943951 2,44346095 2,7925268 3,14159265]
- numpy.tan(x, *args, **kwargs) Calcule la tangente por elementos.
- numpy.arctan(x, *args, **kwargs) Tangente inversa trigonométrica, por elementos.
print(x)
print('++++++++++++++')
y = np.tan(x)
print(y)
print('+++++++++++++++')
print(np.arctan(y))
[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925 2.0943951 2.44346095
2.7925268 3.14159265]
++++++++++++++++
[ 0.00000000e+00 3 .63970234e-01 8.39099631e-01 1.73205081e+00
5.67128182e+00 -5.67128182e+00 -1.73205081e+00 -8.39099631e-01
-3.63970234e-01 -1.22464680e-16]
++++++++++++++++
[ 0.00000000e+00 3.49065850e-01 6.98131701e-01 1.0471 9755 e+00
1.39626340e+00 -1.39626340e+00 -1.04719755e+00 -6.98131701e-01
-3.49065850e-01 -1.22464680e-16]
Exponencial y logarítmica
- numpy.exp(x, *args, **kwargs) Calcula la exponencial de todos los elementos en la matriz de entrada.
- numpy.log(x, *args, **kwargs) Logaritmo natural, por elementos.
- numpy.exp2(x, *args, kwargs) Calcula 2 p para todos los p en la matriz de entrada.
- numpy.log2(x, *args, **kwargs) Logaritmo en base 2 de x.
- numpy.log10(x, *args, **kwargs) Devuelve el logaritmo en base 10 de la matriz de entrada, por elementos.
Función de suma, función de multiplicación
- numpy.sum (a[, axis=Ninguno, dtype=Ninguno, out=Ninguno, …]) Suma total.
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)
print('+++++++++++++++')
y = np.sum(x, axis=0)
print(y)
print('+++++++++++++++')
y = np.sum(x, axis=1)
print(y)
575
++++++++++++++++
[105 110 115 120 125]
+++++++++++++++
[ 65 90 115 140 165]
- numpy.cumsum(a, axis=None, dtype=None, out=None) Una función agregada es una función que opera en un conjunto de valores (como una matriz) y devuelve un único valor como resultado. Por tanto, una función que suma todos los elementos de un arreglo es una función agregada. La clase ndarray implementa varias de estas funciones.
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.cumsum(x)
print(y)
print('+++++++++++++++')
y = np.cumsum(x, axis=0)
print(y)
print('+++++++++++++++')
y = np.cumsum(x, axis=1)
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]
+++++++++++++++
[[ 11 12 13 14 15]
[ 27 29 31 33 35]
[ 48 51 54 57 60]
[ 74 78 82 86 90]
[105 110 115 120 125]]
+++++++++++++++
[[ 11 23 36 50 65]
[ 16 33 51 70 90]
[ 21 43 66 90 115]
[ 26 53 81 110 140]
[ 31 63 96 130 165]]
- numpy.prod(a[, axis=Ninguno, dtype=Ninguno, out=Ninguno, …]) Ejemplo.
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.prod(x)
print(y)
print('+++++++++++++++')
y = np.prod(x, axis=0)
print(y)
print('+++++++++++++++')
y = np.prod(x, axis=1)
print(y)
- numpy.cumprod(a, axis=Ninguno, dtype=Ninguno, out=Ninguno)
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.cumprod(x)
print(y)
print('+++++++++++++++')
y = np.cumprod(x, axis=0)
print(y)
print('+++++++++++++++')
y = np.cumprod(x, axis=1)
print(y)
[ 11 132 1716 24024 360360 5765760 98017920 1764322560 -837609728
427674624 391232512 17180672 395155456
893796352 87007232 0 1147043840 905412608 -418250752 755630080 1194065920 -1638662144 -897581056 444596224
-2063597568
788529152]
+++++++++++++++
[[ 11 12 13 14 15]
[ 176 204 234 266 300]
[ 3696 4488 5382 6384 7500]
[ 96096 121176 150696 185136 225000]
[2978976 3877632 4972968 6294624 7875000]]
++++++++++++++++
[ [ 11 132 1716 24024 360360]
[ 16 272 4896 93024 1860480]
[ 21 462 10626 255024 6375600] [ 26
702 19656 570024 17100720]
[ 31 9 92 32736 1113024 38955840]]
- numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue) a: matriz de entrada n: opcional, que representa cuántas veces realizar diferencia eje: el valor predeterminado es el último
A = np.arange(2, 14).reshape((3, 4))
A[1, 1] = 8
print(A)
print('+++++++++++++++')
print(np.diff(A))
print('+++++++++++++++')
print(np.diff(A, axis=0))
[[ 2 3 4 5]
[ 6 8 8 9]
[10 11 12 13]]
+++++++++++++++
[[1 1 1]
[2 0 1]
[1 1 1 ]]
+++++++++++++++
[[4 5 4 4]
[4 3 4 4]]
redondeo
- numpy.around(a, decimals=0, out=None) redondea la matriz al número dado de lugares decimales
import numpy as np
x = np.random.rand(3, 3) * 10
print(x)
print('+++++++++++++++')
y = np.around(x)
print(y)
print('+++++++++++++++')
y = np.around(x, decimals=2)
print(y)
[[7.1548064 3.89050129 0.6841653 ]
[3.42990897 8.80920902 4.16570523]
[3.22147592 5.48891666 2.94508988]]
+++++++++++++++
[[7. 4. 1.]
[3. 9. 4.]
[3. 5. 3.]]
++++++++++++++++
[[7,15 3,89 0,68]
[3,43 8,81 4,17]
[3,22 5,49 2,95]]
- numpy.ceil (x, *args, **kwargs) Techo arriba.
- numpy.floor (x, *args, **kwargs) Piso abajo.
otro
- numpy.clip(a, a_min, a_max, out=Ninguno, **kwargs)
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.clip(x, a_min=20, a_max=30)
print(y)
[[20 20 20 20 20]
[20 20 20 20 20]
[21 22 23 24 25]
[26 27 28 29 30]
[30 30 30 30 30]]
- numpy.abs (x, *args, **kwargs) valor absoluto
x = np.arange(-5, 5)
print(x)
print('+++++++++++++++')
y = np.abs(x)
print(y)
[-5 -4 -3 -2 -1 0 1 2 3 4]
++++++++++++++++
[5 4 3 2 1 0 1 2 3 4]
- numpy.sign (x, *args, **kwargs) Devuelve una indicación de elementos del signo de un número
x = np.arange(-5, 5)
print(x)
print('+++++++++++++++')
print(np.sign(x))
[-5 -4 -3 -2 -1 0 1 2 3 4]
++++++++++++++++
[-1 -1 -1 -1 -1 0 1 1 1 1]
funcion logica
prueba de verdad
- numpy.all(a, axis=None, out=None, keepdims=np._NoValue) Verdadero si todo es verdadero.
- numpy.any(a, axis=None, out=None, keepdims=np._NoValue) es verdadero si alguno es verdadero.
import numpy as np
a = np.array([0,4,5])
b = np.copy(a)
print(np.all(a==b))
print(np.any(a==b))
b[0]=1
print(np.all(a==b))
print(np.any(a==b))
Verdadero
Verdadero
Falso
Verdadero
contenido de la matriz
- numpy.isnan(x, *args, **kwargs) Determinar si el elemento es NAN
a = np.array([1,2,np.nan])
print(np.isnan(a))
[Falso Falso Verdadero]
operación lógica
- numpy .logical_not (x, *args, **kwargs)非.
- numpy.logical_and (x1, x2, *args, **kwargs) uno.
- numpy .logical_or (x1, x2, *args, **kwargs) valor.
- numpy.logical_xor(x1, x2, *args, **kwargs) XOR.
print(np.logical_not([True,False,0,1]))
print(np.logical_and([True,False],[True,False]))
print(np.logical_or([True,False],[False,False]))
print(np.logical_xor([True,True,False,False],[True,False,True,False]))
[Falso Verdadero Verdadero Falso]
[Verdadero Falso]
[Verdadero Falso]
[Falso Verdadero Verdadero Falso]
control
- numpy.greater(x1, x2, *args, **kwargs) Mayor que
- numpy.greater_equal (x1, x2, *args, **kwargs) mayor o igual que
- numpy.equal(x1, x2, *args, **kwargs) Igual a.
- numpy.not_equal(x1, x2, *args, **kwargs) No es igual.
- numpy.less(x1, x2, *args, **kwargs) Menos que
- numpy.less_equal (x1, x2, *args, **kwargs) menor o igual que
x = np.array([1,2,3,4,5,6,7,8])
print(np.greater(x,2))
print(np.greater_equal(x,2))
print(np.equal(x,2))
print(np.not_equal(x,2))
print(np.less(x,2))
print(np.less_equal(x,2))
[Falso Falso Verdadero Verdadero Verdadero Verdadero Verdadero Verdadero]
[Falso Verdadero Verdadero Verdadero Verdadero Verdadero Verdadero Verdadero]
[Falso Verdadero Falso Falso Falso Falso Falso Falso
] [Verdadero Falso Verdadero Verdadero Verdadero Verdadero Verdadero Verdadero]
[Verdadero Falso Falso Falso Falso Falso]
[ Verdadero Verdadero Falso Falso Falso Falso Falso Falso]