Introducción¶
Acerca de Numpy¶
Numpy s una biblioteca de Python que se utiliza para trabajar con matrices y vectores de datos numéricos. Proporciona un conjunto de funciones y métodos eficientes y optimizados para el procesamiento de datos numéricos, incluyendo operaciones matriciales, estadísticas, álgebra lineal, entre otras.
NumPy es ampliamente utilizado en áreas como la ciencia de datos, el aprendizaje automático, la ingeniería y la física, entre otras. Es una herramienta fundamental en el ecosistema de Python para el procesamiento y análisis de datos numéricos.
Algunas de las características principales de NumPy son:
- Arrays multidimensionales eficientes y optimizados para operaciones numéricas.
- Funciones y métodos para operaciones matemáticas y estadísticas.
- Integración con otras bibliotecas de Python para el procesamiento de datos, como Pandas y Matplotlib.
- Capacidad de procesar grandes conjuntos de datos numéricos de manera eficiente y escalable.
Python Lists vs Numpy Arrays¶
Las listas de Python y los arrays de NumPy son dos estructuras de datos diferentes que se utilizan para almacenar y manipular conjuntos de datos en Python.
Las listas de Python son una colección de elementos que pueden ser de diferentes tipos de datos, como enteros, flotantes, cadenas, etc. Pueden ser de longitud variable y se pueden modificar en tiempo de ejecución. Las listas de Python son más flexibles y versátiles que los arrays de NumPy, pero pueden ser más lentas para operaciones matemáticas y numéricas.
Los arrays de NumPy son una estructura de datos más especializada que se utiliza para trabajar con datos numéricos, como matrices y vectores. Son más rápidos y eficientes que las listas de Python para operaciones numéricas y matemáticas, y proporcionan muchas funciones y métodos útiles para el procesamiento de datos, como operaciones matriciales y de álgebra lineal. Los arrays de NumPy tienen una longitud fija y no se pueden modificar una vez creados.
Una pregunta común para principiantes es cuál es la verdadera diferencia aquí. La respuesta es el rendimiento. Las estructuras de datos de Numpy funcionan mejor en:
- Tamaño: las estructuras de datos de Numpy ocupan menos espacio
- Rendimiento: necesitan velocidad y son más rápidos que las listas
- Funcionalidad: SciPy y NumPy tienen funciones optimizadas, como las operaciones de álgebra lineal integradas.
Diferencias Tiempo - Memoria¶
Los principales beneficios del uso de matrices NumPy deberían ser un menor consumo de memoria y un mejor comportamiento en tiempo de ejecución.
Para las listas de Python podemos concluir de esto que para cada elemento nuevo, necesitamos otros ocho bytes para la referencia al nuevo objeto. El nuevo objeto entero en sí consume 28 bytes. El tamaño de una lista lst sin el tamaño de los elementos se puede calcular con:
64 + 8 * len (lst) + + len (lst) * 28
Los array NumPy ocupan menos espacio. Esto significa que una matriz entera arbitraria de longitud n en necesidades numpy se calcula por:
96 + n * 8 bytes
Veamos un ejemplo:
import numpy as np
import time
import sys
def arreglo_python(n):
t1 = time.time()
X = range(n)
Y = range(n)
Z = [X[i] + Y[i] for i in range(len(X)) ]
return (time.time() - t1,sys.getsizeof(Z) )
def arreglo_numpy(n):
t1 = time.time()
X = np.arange(n)
Y = np.arange(n)
Z = X + Y
return (time.time() - t1,sys.getsizeof(Z) )
# parametros
size_of_vec = 1000000
t1, size1 = arreglo_python(size_of_vec)
t2, size2 = arreglo_numpy(size_of_vec)
# generar varios casos
for size_of_vec in [10,100,1000,10000,100000,1000000]:
print(f"size of vector: {size_of_vec}")
#list vs numpy
t1, size1 = arreglo_python(size_of_vec)
t2, size2 = arreglo_numpy(size_of_vec)
# resultados
print(f"python list -- time: {round(t1,8)} seg, size: {size1} bytes")
print(f"numpy array -- time: {round(t2,8)} seg, size: {size2} bytes\n")
size of vector: 10 python list -- time: 0.0 seg, size: 184 bytes numpy array -- time: 0.0 seg, size: 152 bytes size of vector: 100 python list -- time: 0.0 seg, size: 920 bytes numpy array -- time: 0.0 seg, size: 512 bytes size of vector: 1000 python list -- time: 0.0 seg, size: 8856 bytes numpy array -- time: 0.0 seg, size: 4112 bytes size of vector: 10000 python list -- time: 0.00104094 seg, size: 85176 bytes numpy array -- time: 0.0 seg, size: 40112 bytes size of vector: 100000 python list -- time: 0.00922084 seg, size: 800984 bytes numpy array -- time: 0.0 seg, size: 400112 bytes size of vector: 1000000 python list -- time: 0.10304594 seg, size: 8448728 bytes numpy array -- time: 0.00200057 seg, size: 4000112 bytes