Tutorial Numpy: Creación de arrays en Numpy

¿Qué es un array de Numpy?

Un array de Numpy es una estructura de datos fundamental provista por la biblioteca Numpy, que es ampliamente usada en el ámbito de la computación científica y análisis de datos en Python. 

A diferencia de las listas de Python, los arrays de Numpy son más eficientes en términos de memoria y permiten realizar operaciones matemáticas de manera más rápida y flexible.

Los arrays de Numpy son homogéneos, lo que significa que todos los elementos deben ser del mismo tipo de datos, lo que facilita realizar cálculos matemáticos de manera vectorizada y optimizada. 

La base de un array de Numpy es la clase numpy.ndarray, la cual provee numerosas funcionalidades avanzadas para la manipulación de datos.

La estructura básica de un array de Numpy está compuesta por:

1. Forma (shape): La forma de un array se define por el número de elementos, filas y columnas que posee. Se describe mediante una tupla de enteros.
2. Dimensiones: Los arrays pueden tener una o más dimensiones. Por ejemplo, un array 1D con 5 elementos, un array 2D de 3x4, y arrays multidimensionales.
3. Tipo de dato (dtype): Define el tipo de los elementos almacenados en el array, como float64, int32, entre otros.

Para crear un array básico se puede usar la función numpy.array(), que toma como argumento una secuencia (como una lista o una tupla) y devuelve un objeto ndarray.

import numpy as np

# Crear un array 1D
arr_1d = np.array([1, 2, 3, 4])

# Crear un array 2D
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])

# Crear un array 3D
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

Además, los arrays de Numpy proporcionan métodos y propiedades para obtener información sobre su estructura y contenido, como shape, size, ndim, dtype y muchas más, lo que permite una manipulación y análisis eficientes de los datos.

# Información del array 1D
print(arr_1d.shape)  # (4,)
print(arr_1d.size)   # 4
print(arr_1d.ndim)   # 1
print(arr_1d.dtype)  # dtype('int64')

Gracias a estas características, los arrays de Numpy son la base para trabajar con datos numéricos en muchos campos de la ciencia y la ingeniería, otorgando una amplia capacidad para realizar cálculos vectorizados, trabajar con matrices, y realizar operaciones matemáticas y estadísticas de manera rápida y eficiente.

Diferencia entre listas de Python y arrays de Numpy

Las listas de Python y los arrays de Numpy son útiles para gestionar colecciones de datos, pero tienen diferencias fundamentales que los hacen adecuados para distintos tipos de tareas.

Homogeneidad vs heterogeneidad

Las listas de Python pueden contener elementos de diferentes tipos (heterogéneas), permitiendo una gran flexibilidad pero sacrificando eficiencia. En cambio, los arrays de Numpy son homogéneos, es decir, todos sus elementos deben ser del mismo tipo de dato (int, float, bool, etc.). Esta homogeneidad permite que Numpy optimice el almacenamiento y las operaciones matemáticas sobre los datos.

Almacenamiento en memoria

Las listas de Python almacenan referencias a los objetos que contienen, lo que implica mayor consumo de memoria y menos eficiencia. En cambio, los arrays de Numpy almacenan los datos de manera contigua en memoria, lo que reduce el overhead y permite un acceso más rápido y eficiente.

import numpy as np

# Ejemplo de una lista de Python
lista = [1, 2.5, 'a', [5, 6]]
print(lista)

# Ejemplo de un array de Numpy
array = np.array([1.0, 2.0, 3.0, 4.0])
print(array)

Rendimiento

Los arrays de Numpy están optimizados para realizar operaciones numéricas y vectorizadas, permitiendo ejecutar cálculos a gran velocidad. Esto se debe a que los arrays de Numpy tomaron mucho del rendimiento de la capa inferior escrita en C. Las listas de Python, por otro lado, no están optimizadas para operaciones numéricas masivas y pueden ser ineficientes en estos casos.

import time

# Operación sobre una lista de Python
python_list = list(range(1000000))
start_time = time.time()
python_list = [x * 2 for x in python_list]
print("Tiempo con lista de Python:", time.time() - start_time)

# Operación sobre un array de Numpy
numpy_array = np.arange(1000000)
start_time = time.time()
numpy_array = numpy_array * 2
print("Tiempo con array de Numpy:", time.time() - start_time)

Funcionalidades y operaciones

Numpy proporciona una serie de funciones y operadores especializados para manejar arrays. Estas incluyen operaciones matemáticas avanzadas (como sumas, productos, transformadas, etc.) y manipulación de datos (como reshaping, slicing, transposing). Las listas de Python no tienen estas funcionalidades incorporadas y requieren bucles explícitos para realizar operaciones element-wise, incrementando el código y potencialmente los tiempos de ejecución.

# Operación matemática sobre un array de Numpy
array1 = np.array([1, 2, 3, 4])
array2 = np.array([5, 6, 7, 8])
result = array1 + array2  # Vector addition
print(result)  # Output: [ 6  8 10 12]

En resumen, los arrays de Numpy están diseñados para un procesamiento y manipulación de datos numéricos de alta eficiencia, lo que los hace más adecuados para aplicaciones científicas y de ingeniería que requieren operaciones matemáticas complejas y cálculos sobre grandes conjuntos de datos. Las listas de Python, aunque más flexibles en términos de tipos de datos, no pueden igualar el rendimiento y la capacidad de los arrays de Numpy en estos contextos.

Todas las formas posibles de crear arrays en Numpy

Numpy proporciona diversas maneras para crear arrays, cada una adecuada según el caso de uso y la situación específica. 

A continuación, se describen todas las formas posibles de crear arrays en Numpy.

1. Desde una lista o tupla:

La forma más directa de crear un array es a partir de una lista o tupla de Python usando la función np.array().

import numpy as np

# Array desde lista
arr1 = np.array([1, 2, 3, 4])

# Array desde tupla
arr2 = np.array((1, 2, 3, 4))

2. Utilizando funciones predefinidas:

Numpy ofrece varias funciones para generar arrays con valores determinados.

• np.zeros(shape): crea un array de ceros con la forma especificada.
• np.ones(shape): crea un array de unos con la forma especificada.
• np.full(shape, fill_value): crea un array lleno con el valor especificado.

# Array de ceros
zeros_array = np.zeros((2, 3))

# Array de unos
ones_array = np.ones((2, 3))

# Array lleno con un valor específico
full_array = np.full((2, 3), 7)

3. Rango de valores:

Hay funciones diseñadas para crear arrays con valores secuenciales.

• np.arange(start, stop, step): crea un array con valores en un rango especificado, similar a range() de Python.
• np.linspace(start, stop, num): genera un array de números equidistantes entre dos valores especificados.

# Array con rango de valores
range_array = np.arange(0, 10, 2)

# Array con valores equidistantes
linspace_array = np.linspace(0, 1, 5)

4. Arrays vacíos:

Numpy permite crear arrays sin inicializar los valores, lo que puede ser útil para grandes arrays cuando los valores serán inmediatamente reasignados. Se usa np.empty(shape).

# Array vacío (sin inicializar)
empty_array = np.empty((2, 3))

5. Creación de arrays a partir de otras estructuras:

• np.asarray(): convierte listas, tuplas u otros arrays en un array de Numpy.

# Convertir una lista a array
list_to_array = np.asarray([1, 2, 3])

6. Arrays de identidad y matrices diagonales:

• np.eye(N): crea una matriz identidad (cuadrada) de N×N.
• np.identity(n): matriz identidad también de n×n.
• np.diag(v): crea una matriz diagonal con los elementos de v en la diagonal.

# Matriz identidad
identity_array = np.eye(3)

# Matriz diagonal
diagonal_array = np.diag([1, 2, 3])

7. Arrays aleatorios:

NumPy proporciona funciones para crear arrays con valores aleatorios utilizando la clase Generator, que es parte de la interfaz moderna recomendada para la generación de números aleatorios.

• rng.random(size): Genera un array de la forma especificada con valores aleatorios uniformemente distribuidos entre 0 y 1.
• rng.standard_normal(size): Genera un array con valores aleatorios que siguen una distribución normal estándar (media 0 y desviación estándar 1).
• rng.integers(low, high, size): Genera enteros aleatorios en un intervalo especificado.

seed = 42
rng = np.random.default_rng(seed)

# Array con valores aleatorios uniformes
random_array_uniform = rng.random((2, 3))

# Array con valores aleatorios distribuidos normalmente
random_array_normal = rng.standard_normal((2, 3))

# Array de enteros aleatorios
random_integers = rng.integers(0, 10, size=(2, 3))

8. Arrays con patrones geométricos o logarítmicos:

Utiliza numpy.geomspace(start, stop, num) y numpy.logspace(start, stop, num) para generar arrays con progresiones geométricas o logarítmicas.

# Array con progresión geométrica
geom_array = np.geomspace(1, 1000, num=4)

# Array con progresión logarítmica
log_array = np.logspace(0, 3, num=4)

Estas opciones ofrecen una amplia gama de formas para crear arrays en Numpy, adaptándose a diversas necesidades computacionales y de análisis de datos.

Leer datos de CSV

Si en lugar de crear un array queremos cargar datos externos a un array con numpy, es posible leer datos de archivos CSV sin necesidad de utilizar librerías externas.

Ejemplo.

Partiendo de un CSV con la siguiente estructura:

calificacion_examen1
7.97
4.95
8.73
7.28

Es posible cargarlo a un array de numpy con el siguiente código:

calificaciones = np.genfromtxt('calificaciones.csv', delimiter=',', skip_header=1)

No obstante, para una mejor funcionalidad en la lectura, especialmente si los CSV tienen múltiples columnas se recomienda usar Pandas.