Introducción a NumPy: La Base de la Computación Numérica en Python

¡Bienvenido al fascinante mundo de NumPy! En este tutorial te guiaré paso a paso para que aprendas los fundamentos de esta poderosa biblioteca que es la base de la computación numérica en Python.

Objetivo: Aprender los conceptos básicos de NumPy, incluyendo arrays, operaciones fundamentales y mejores prácticas para trabajar con datos numéricos.

Índice

• ¿Qué es NumPy?
• Instalación de NumPy
• Arrays de NumPy
• Creación de Arrays
• Tipos de Datos en NumPy
• Operaciones Básicas con Arrays
• Indexación y Slicing
• Proyecto Práctico - Análisis de Datos Básico
• Próximos Pasos
• Conclusión

¿Qué es NumPy?

NumPy (Numerical Python) es una biblioteca fundamental para la computación científica en Python. Proporciona soporte para arrays multidimensionales de gran tamaño, junto con una colección de funciones matemáticas para operar con estos arrays.

¿Por qué NumPy es tan importante?

• Eficiencia: Los arrays de NumPy son más eficientes que las listas de Python para operaciones numéricas
• Funciones matemáticas: Proporciona cientos de funciones matemáticas optimizadas
• Base de otras bibliotecas: Pandas, SciPy, scikit-learn y muchas otras se construyen sobre NumPy
• Sintaxis intuitiva: Similar a MATLAB, fácil de aprender para quienes vienen de otros lenguajes

# Comparación entre listas de Python y arrays de NumPy
import numpy as np

# Lista de Python
lista_python = [1, 2, 3, 4, 5]
print("Lista Python:", lista_python)

# Array de NumPy
array_numpy = np.array([1, 2, 3, 4, 5])
print("Array NumPy:", array_numpy)

Instalación de NumPy

NumPy se instala fácilmente usando pip:

pip install numpy

O si usas conda:

conda install numpy

Verificación de la instalación

import numpy as np
print("Versión de NumPy:", np.__version__)

Arrays de NumPy

Los arrays son la estructura de datos fundamental de NumPy. A diferencia de las listas de Python, los arrays de NumPy:

• Tienen un tamaño fijo al crearse
• Contienen elementos del mismo tipo
• Son más eficientes para operaciones numéricas
• Permiten operaciones vectorizadas

Diferencias clave con las listas de Python

Creación de Arrays

NumPy ofrece múltiples formas de crear arrays:

Desde listas de Python

import numpy as np

# Array 1D
arr_1d = np.array([1, 2, 3, 4, 5])
print("Array 1D:", arr_1d)
print("Forma:", arr_1d.shape)
print("Tipo de datos:", arr_1d.dtype)

# Array 2D (matriz)
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Array 2D:")
print(arr_2d)
print("Forma:", arr_2d.shape)

Arrays con valores específicos

# Array de ceros
ceros = np.zeros(5)
print("Array de ceros:", ceros)

# Array de unos
unos = np.ones(5)
print("Array de unos:", unos)

# Array vacío (valores aleatorios)
vacio = np.empty(5)
print("Array vacío:", vacio)

# Array con un valor específico
lleno = np.full(5, 7)
print("Array lleno:", lleno)

Secuencias numéricas

# Rango de números
rango = np.arange(10)
print("Rango 0-9:", rango)

# Rango con paso
rango_paso = np.arange(0, 10, 2)
print("Rango con paso 2:", rango_paso)

# Números espaciados uniformemente
espaciado = np.linspace(0, 1, 5)
print("5 números entre 0 y 1:", espaciado)

Arrays multidimensionales

# Matriz de ceros
matriz_ceros = np.zeros((3, 4))
print("Matriz 3x4 de ceros:")
print(matriz_ceros)

# Matriz de unos
matriz_unos = np.ones((2, 3))
print("Matriz 2x3 de unos:")
print(matriz_unos)

# Matriz identidad
identidad = np.eye(3)
print("Matriz identidad 3x3:")
print(identidad)

Tipos de Datos en NumPy

NumPy soporta una amplia variedad de tipos de datos numéricos:

# Tipos de datos comunes
entero = np.array([1, 2, 3], dtype=np.int32)
flotante = np.array([1.0, 2.0, 3.0], dtype=np.float64)
booleano = np.array([True, False, True], dtype=bool)
complejo = np.array([1+2j, 3+4j], dtype=complex)

print("Entero:", entero.dtype)
print("Flotante:", flotante.dtype)
print("Booleano:", booleano.dtype)
print("Complejo:", complejo.dtype)

Conversión de tipos

# Conversión automática
arr_int = np.array([1, 2, 3])
arr_float = arr_int.astype(np.float64)
print("Original:", arr_int.dtype)
print("Convertido:", arr_float.dtype)

# Conversión manual
arr_str = np.array(['1', '2', '3'])
arr_num = arr_str.astype(int)
print("String a int:", arr_num)

Operaciones Básicas con Arrays

NumPy permite realizar operaciones matemáticas de forma vectorizada:

Operaciones aritméticas

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

print("a =", a)
print("b =", b)

# Suma
print("a + b =", a + b)

# Resta
print("a - b =", a - b)

# Multiplicación elemento a elemento
print("a * b =", a * b)

# División
print("a / b =", a / b)

# Potencia
print("a ** 2 =", a ** 2)

Operaciones con escalares

arr = np.array([1, 2, 3, 4])

print("Array original:", arr)
print("Multiplicar por 2:", arr * 2)
print("Sumar 10:", arr + 10)
print("Dividir por 2:", arr / 2)

Funciones matemáticas

arr = np.array([0, np.pi/2, np.pi])

print("Array:", arr)
print("Seno:", np.sin(arr))
print("Coseno:", np.cos(arr))
print("Exponencial:", np.exp(arr))
print("Logaritmo:", np.log(arr + 1))  # +1 para evitar log(0)

Indexación y Slicing

Acceder a elementos específicos de un array:

Indexación básica

arr = np.array([10, 20, 30, 40, 50])

print("Array:", arr)
print("Primer elemento:", arr[0])
print("Último elemento:", arr[-1])
print("Tercer elemento:", arr[2])

Slicing (rebanado)

arr = np.array([10, 20, 30, 40, 50, 60, 70, 80])

print("Array completo:", arr)
print("Primeros 3 elementos:", arr[:3])
print("Elementos del índice 2 al 5:", arr[2:6])
print("Cada 2 elementos:", arr[::2])
print("Elementos en orden inverso:", arr[::-1])

Indexación en arrays multidimensionales

matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print("Matriz:")
print(matriz)
print("Elemento [0,0]:", matriz[0, 0])
print("Elemento [1,2]:", matriz[1, 2])
print("Primera fila:", matriz[0, :])
print("Segunda columna:", matriz[:, 1])
print("Submatriz 2x2:", matriz[:2, :2])

Proyecto Práctico - Análisis de Datos Básico

Vamos a crear un pequeño programa que analice datos de temperaturas:

import numpy as np

# Datos de temperaturas semanales (7 días, 4 semanas)
temperaturas = np.array([
    [25.5, 26.0, 24.8, 27.2, 28.1, 26.5, 25.9],  # Semana 1
    [24.3, 25.7, 26.8, 27.5, 28.9, 27.1, 26.4],  # Semana 2
    [23.8, 24.9, 25.6, 26.3, 27.8, 28.2, 27.5],  # Semana 3
    [26.1, 27.3, 28.0, 29.1, 30.2, 28.8, 27.9]   # Semana 4
])

print("=== ANÁLISIS DE TEMPERATURAS ===")
print("Datos de temperaturas (°C):")
print(temperaturas)

# Cálculos básicos
print(f"\nTemperatura máxima: {temperaturas.max():.1f}°C")
print(f"Temperatura mínima: {temperaturas.min():.1f}°C")
print(f"Temperatura promedio: {temperaturas.mean():.1f}°C")

# Análisis por semanas
print("\n=== ANÁLISIS POR SEMANAS ===")
for i, semana in enumerate(temperaturas, 1):
    print(f"Semana {i}:")
    print(f"  Máxima: {semana.max():.1f}°C")
    print(f"  Mínima: {semana.min():.1f}°C")
    print(f"  Promedio: {semana.mean():.1f}°C")

# Análisis por días de la semana
print("\n=== ANÁLISIS POR DÍAS ===")
dias = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
for i, dia in enumerate(dias):
    temp_dia = temperaturas[:, i]
    print(f"{dia}: {temp_dia.mean():.1f}°C (promedio semanal)")

# Días más calurosos
indices_max = np.unravel_index(temperaturas.argmax(), temperaturas.shape)
print(f"\nDía más caluroso: Semana {indices_max[0] + 1}, {dias[indices_max[1]]} con {temperaturas[indices_max]:.1f}°C")

# Estadísticas adicionales
print("
=== ESTADÍSTICAS ADICIONALES ===")
print(f"Desviación estándar: {temperaturas.std():.2f}°C")
print(f"Mediana: {np.median(temperaturas):.1f}°C")
print(f"Rango: {temperaturas.max() - temperaturas.min():.1f}°C")

Próximos Pasos

¡Felicidades! Has completado la introducción a NumPy. Ahora tienes las bases para:

1. Operaciones Avanzadas con Arrays: Manipulación de formas, broadcasting
2. Funciones Matemáticas y Estadísticas: Más operaciones numéricas
3. Integración con Pandas: Para análisis de datos más avanzado
4. Visualización: Usando Matplotlib con datos de NumPy

Tutoriales Recomendados

• NumPy - Operaciones con Arrays
• NumPy - Operaciones Matemáticas
• NumPy Avanzado
• NumPy para Data Science

Conclusión

NumPy es la base de la computación numérica en Python. Con sus arrays eficientes y sus funciones optimizadas, puedes realizar operaciones complejas de manera sencilla y rápida. Practica creando diferentes tipos de arrays y experimentando con las operaciones que has aprendido.

¡Sigue practicando y profundizando en NumPy para dominar la computación numérica en Python!

¡Sigue explorando el mundo de NumPy y la ciencia de datos!

💡 Tip Importante

📝 Mejores Prácticas con NumPy

• Usa arrays en lugar de listas cuando trabajes con datos numéricos
• Especifica el dtype cuando sea necesario para optimizar memoria
• Aprovecha las operaciones vectorizadas en lugar de bucles
• Usa funciones universales (ufuncs) para operaciones eficientes
• Documenta tu código con comentarios claros

📚 Recursos Recomendados:

• Documentación Oficial de NumPy
• NumPy Quickstart Tutorial
• SciPy Lectures - NumPy

¡Tu viaje con NumPy apenas comienza. Sigue adelante y nunca dejes de aprender!