Tratamiento de arrays con NUMPY
Python tiene listas, enteros, punto flotante, etc. Para cálculo numérico necesitamos más... allí aparece Numpy. Numpy es un paquete que provee a Python arreglos multidimensionales de alta eficiencia y diseñados para cálculo científico. Contiene entre otras cosas:
- Un gran definición de N-dimensiones array object
- Funciones de bradcasting sofisticadas
- Herramientas para la integración de código C / C ++ y Fortran.
- Álgebra lineal útil, transformada de Fourier y capacidades de números aleatorios.
Además de sus obvios usos científicos, NumPy también se puede usar como un eficiente contenedor multidimensional de datos genéricos. Es muy útil a la hora de crear datos aleatorios para test. Esto permite que NumPy se integre a la perfección con una amplia variedad de bases de datos.
import numpy as np
1.- NUMPY, Introducción¶
Podemos empezar con un definición básica del array numpy. Crearemos nuestro primer array con la función np.array().
Una operación muy utilizada, ya que muchas veces no sabemos que tipo de datos estamos tratando es .shape qué nos devuelve las dimensiones del array actual.
a = np.array([1, 2, 3]) # Crear 1D Numpy Array
print(type(a)) # Prints "<class 'numpy.ndarray'>"
print(a.shape) # Prints "(3)”, 1D x 3 Len
print(a[0], a[1], a[2]) # Prints "1 2 3"
a[0] = 5
print(a) # Prints "[5, 2, 3]"
Array indexing. También una de las características más agradecidas es el rápido y versátil acceso a estos numpy arrays como podemos ver:
nums = np.array([0, 1, 2, 3, 4])
print(nums) # prints "[0, 1, 2, 3, 4]"
print(nums[2:4]) # prints "[2, 3]"
print(nums[2:]) # prints "[2, 3, 4]"
print(nums[:2]) # prints "[0, 1]"
print(nums[:]) # prints "[0, 1, 2, 3, 4]"
print(nums[:-1]) # prints "[0, 1, 2, 3]"
nums[2:4] = [8, 9] # Assign a new sublist to a slice
print(nums) # Prints "[0, 1, 8, 9, 4]"
a = np.array([[ 1 , 2 , 3 , 4], [ 5 , 6 , 7 , 8], [ 9 , 10 , 11 , 12]])
b = a[:2, 1:3]
print(b)
Podemos crear arrays de varias dimensiones fácilmente, esta es una de las partes más útil, por ejemplo, para pruebas. Con las funciones como .full, .zeros o .reshape podemos crear fácilmente array multidimensionales.
b = np.array([[1,2,3],[4,5,6]]) # Crear 2D Numpy Array
print(b.shape) # Prints "(2, 3)”, 2D x 3 len
print(b[0, 0], b[0, 1], b[1, 0])
2.- Operaciones básicas¶
Podemos encontrar múltiples de operaciones que nos pueden salvar unas cuantas líneas más de una vez. Algunos de los más utilizados son los de creación de arrays, tenemos unas cuantas operaciones que nos pueden servir.
Crear array de ceros
a = np.zeros((2,2)) # Create an array of all zeros
print(a)
Crear array de unos
b = np.ones((1,2)) # Create an array of all ones
print(b)
Crear un array con el número especificado
c = np.full((2,2), 7) # Create a constant array
print(c)
Crear una matriz identidad, Muy útiles para operaciones algebraicas.
d = np.eye(2) # Create a 2x2 identity matrix
print(d)
Crear una matriz con randoms
e = np.random.random((2,2)) # Create an array filled with random values
print(e)
Matrices únicas
Z = np.diag(np.arange(1,5),k=-1)
También tenemos ciertas operaciones que nos pueden servir para ordenar, o chequear ciertas condiciones.
devolver al revés
b = np.arange(10, 20)[::-1]
Comparaciones
print(np.isnan(c))
Ceros, saltos...
chess = np.zeros((8,8),dtype="int")
chess[0::2,0::2] = 1
chess[1::2,1::2] = 1
Sortear
print(np.sort(a, axis=0)[::-1])
Sacar los únicos
Z1 = np.random.randint(0,10,10)
print(np.unique(Z1))
3.- Operaciones con matrices¶
Numpy nos ofrece una buena solución para el tratamiento de operaciones con matrices. Las más típicas como multiplicaciones, división o suma aplican con la leyes de operaciones entre matrices.
x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)
Suma
print(x + y)
print(np.add(x, y))
Resta
print(x - y)
print(np.subtract(x, y))
Multiplicación
print(x * y)
print(np.multiply(x, y))
División
print(x / y)
print(np.divide(x, y))
Raíz cuadrada
print(np.sqrt(x))
Traspuesta
x = np.array([[1,2], [3,4]])
print(x.T)
Pegado horizontal
a = np.array([[1], [2], [3]])
b = np.array([[3, 4], [5, 6], [7, 8]])
c = np.hstack((a, b))
print(c)
Pegado vertical
a = np.array([1, 2, 3])
b = np.array([[4, 5, 6], [7, 8, 9]])
a = np.vstack((a, b))
print(a)
Convertir en columna
np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
Generar un array con las tres primeras columnas de a y las tres últimas
b = np.hstack((a[:,:3], a[:,-3:]))
print(b)
Intercambiar las columnas 1 y 2
a[:, [1,2]] = a[:, [2,1]]
print(a)
4.- Reshapes¶
La función de reshape cambia las dimensiones del array, esta es una opción muy requerida cuando tenemos que tratar con matrices, si queremos hacer operaciones como multiplicaciones será muy probable que necesitemos ajustar las dimensiones de los operandos. Para ellos numpy nos ofrece una de las opciones más interesante el reshape.
Primero veamos una operaciones de consultas, que bien nos pueden servir para ver la información de los arrays.
Dimensiones
x3 = np.random.randint(10, size=(3, 4, 5)) # Three-dimensional array
print("x3 ndim: ", x3.ndim)
Shape
print("x3 shape:", x3.shape)
Size
print("x3 size: ", x3.size)
a = np.arange(6).reshape((3, 2))
print(a) # array([[0, 1], [2, 3], [4, 5]])
a = np.arange(36)
b = a.reshape((6,6))
print(b)
a = np.arange(6)
print(np.reshape(a, (2, 3))) #array([[0, 1, 2], [3, 4, 5]])
print(np.reshape(np.ravel(a), (2, 3))) # array([[0, 1, 2],[3, 4, 5]])
print(np.reshape(a, (2, 3), order='F')) # array([[0, 4, 3], [2, 1, 5]])
print(np.reshape(np.ravel(a, order='F'), (2, 3), order='F')) #array([[0, 4, 3], [2, 1, 5]])
Comentar