Guia 100 numpy exercises

20230722

Este blog nace de la idea de hacer una breve guia de las funciones que se usan en 100 numpy exercises.

np.zeros -> Crea un array lleno de ceros.

arr = np.zeros((3, 4))
#output
# [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]

np.arange -> Crea un array con valores espaciados uniformemente dentro de un intervalo especificado.
```
arr = np.arange(1, 11, 2)
# [1 3 5 7 9]
```

np.reshape -> Cambia la forma (dimensiones) de un array sin modificar sus datos.

arr = np.arange(1, 11) 
reshaped_arr = arr.reshape(5, 2)
# [[ 1 2] [ 3 4] [ 5 6] [ 7 8] [ 9 10]]

np.nonzero -> Devuelve las coordenadas de los elementos no cero en un array.

arr = np.array([3, 0, 5, 0, 7, 0]) 
non_zero_indices = np.nonzero(arr)
# (array([0, 2, 4]),)

np.eye -> Crea una matriz identidad.

identity_matrix = np.eye(3)
# [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

np.random.random -> Genera un array de números aleatorios entre 0 y 1, distribuidos uniformemente.

random_array = np.random.random((2, 3))
# [[0.78556005 0.92418359 0.38019756] [0.26880225 0.06525144 0.98072087]]

np.diag -> Crea una matriz diagonal o extrae la diagonal de una matriz.

diag_matrix = np.diag([1, 2, 3])
# [[1 0 0] [0 2 0] [0 0 3]]
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
diagonal = np.diag(matrix)
# [1 5 9]

np.unravel_index -> Convierte índices planos a índices de coordenadas en una matriz multidimensional.

indices_planos = [2, 4, 7] 
shape = (3, 4)
coordenadas = np.unravel_index(indices_planos, shape)
# (array([0, 1, 1]), array([2, 0, 3]))
# (0, 2), (1, 0) y (1, 3)

np.tile -> Crea una nueva matriz repitiendo una matriz de entrada a lo largo de múltiples dimensiones.

original_array = np.array([1, 2, 3]) 
tiled_array = np.tile(original_array, (2, 3))
# [[1 2 3 1 2 3 1 2 3] [1 2 3 1 2 3 1 2 3]]

np.dtype -> Objeto que describe el tipo de datos de un array.
```
arr = np.array([1, 2, 3], dtype=np.float32)
```

np.random.uniform -> Genera números aleatorios de una distribución uniforme en un rango específico.

random_numbers = np.random.uniform(0, 1, 5)
# [0.45627391 0.80917334 0.16393647 0.77482249 0.38309002]

np.copysign -> Devuelve un array con los valores del primer array y los signos del segundo array.
```
arr1 = np.array([1, -2, 3]) 
arr2 = np.array([-1, 1, -1])
# [-1. 2. -3.]
```

np.intersect1d -> Encuentra los elementos comunes entre dos arrays y devuelve un nuevo array con los valores únicos en común.

arr1 = np.array([1, 2, 3, 4, 5]) 
arr2 = np.array([3, 4, 5, 6, 7]) 
intersection = np.intersect1d(arr1, arr2)
# [3 4 5]

np.datetime64 -> Es un tipo de datos en NumPy que se utiliza para representar fechas y horas con una precisión de nanosegundos.
```
fecha = np.datetime64('2023-07-22')
# 2023-07-23
fecha_futura = fecha + np.timedelta64(10, 'D')
# 2023-08-02
```

np.fromiter -> Crea un array NumPy a partir de un iterador.

my_iterator = range(5) 
arr = np.fromiter(my_iterator, dtype=int)
# [0 1 2 3 4]

np.linspace -> Genera un array de números espaciados uniformemente en un intervalo especificado.
```
arr = np.linspace(0, 1, 5)
# [0.   0.25 0.5  0.75 1.  ]
```
np.atleast_2d -> Convierte las entradas en matrices de al menos dos dimensiones.
```
arr1 = np.array([1, 2, 3]) 
arr2 = np.atleast_2d(arr1)
# [[1 2 3]]
```

np.ndenumerate -> Proporciona un iterador para recorrer un array multidimensional junto con sus índices y valores.

arr = np.array([[1, 2], [3, 4]])
for index, value in np.ndenumerate(arr): 
	print("Índice:", index, "Valor:", value)
# Índice: (0, 0) Valor: 1 
# Índice: (0, 1) Valor: 2 
# Índice: (1, 0) Valor: 3 
# Índice: (1, 1) Valor: 4

np.meshgrid -> Crea una cuadrícula de coordenadas a partir de arrays unidimensionales.

x = np.array([1, 2, 3]) 
y = np.array([4, 5])
X, Y = np.meshgrid(x, y)
# [[1 2 3] [1 2 3]] 
# [[4 4 4] [5 5 5]]

np.bincount -> Cuenta el número de ocurrencias de valores en un array no negativo.

arr = np.array([0, 1, 2, 2, 3, 3, 3]) 
bin_counts = np.bincount(arr)
# [1 1 2 3]

np.unique -> Encuentra los valores únicos en un array y los devuelve en orden ascendente.

arr = np.array([2, 1, 3, 2, 1, 4, 5, 4])
unique_values = np.unique(arr)
# [1 2 3 4 5]

np.linalg.svd-> Descompone una matriz en tres matrices mediante la descomposición de valores singulares (SVD).
```
A = np.array([[1, 2], [3, 4], [5, 6]]) 
U, S, Vt = np.linalg.svd(A)
```

np.tensordot -> Realiza una multiplicación de tensores a lo largo de ejes especificados y suma los resultados.

A = np.array([[1, 2], [3, 4]]) 
B = np.array([[5, 6], [7, 8]])
result = np.tensordot(A, B, axes=1)
# [[19 22] [43 50]]

np.cumsum -> Calcula la suma acumulativa de elementos a lo largo de un array.

arr = np.array([1, 2, 3, 4, 5]) 
cumulative_sum = np.cumsum(arr)
	# [ 1 3 6 10 15]

np.interp -> Realiza una interpolación unidimensional.

x = [1, 2, 3, 4, 5] 
y = [10, 20, 30, 40, 50] 
x_new = 2.5 
y_new = np.interp(x_new, x, y)
# 25.0