Data Analysis · Lección 13 de 19

NumPy Fundamentos

NumPy (Numerical Python) es la piedra angular de todo el ecosistema de Data Science en Python. Pandas, Matplotlib, Seaborn, scikit-learn — todos están construidos sobre NumPy. Cuando pandas calcula una media, por debajo está usando un array de NumPy. Entender NumPy te da el poder de escribir código numérico que es hasta 100x más rápido que los bucles de Python puro.

90–120 min Prerrequisitos: Lección 12 (EDA completo)

Concepto teórico

¿Por qué NumPy es tan rápido?

Una lista de Python es un contenedor genérico: cada elemento puede ser de cualquier tipo (int, string, lista…), y cada uno se almacena en una ubicación de memoria distinta. Un array de NumPy es un bloque contiguo de memoria donde todos los elementos son del mismo tipo. Esto permite:

Operaciones vectorizadas: en vez de recorrer elemento por elemento con un bucle, NumPy aplica la operación a todo el array de golpe (internamente usa C compilado).
Broadcasting: operaciones entre arrays de distinto tamaño se expanden automáticamente sin copiar datos.
Memoria eficiente: un array de 1 millón de enteros ocupa ~4MB. Una lista de Python con los mismos números ocupa ~28MB.

Analogía: una lista de Python es como un estante donde cada libro está envuelto en una caja individual con etiqueta de tipo. Un array de NumPy es como una estantería de libros del mismo tamaño, perfectamente alineados, sin cajas — podés recorrerlos con la mano de un solo movimiento.

ndarray: el objeto central

Todo en NumPy gira alrededor del ndarray (N-dimensional array). Sus atributos clave:

Atributo	Qué dice	Ejemplo
`.shape`	Dimensiones	`(3, 4)` → 3 filas × 4 columnas
`.ndim`	Número de dimensiones	`2` → es una matriz 2D
`.dtype`	Tipo de datos	`float64`, `int32`
`.size`	Total de elementos	`12` (3 × 4)
`.nbytes`	Memoria en bytes	`96` (12 × 8 bytes)

Formas de crear arrays

Función	Qué crea	Ejemplo
`np.array([1,2,3])`	Desde una lista	`[1, 2, 3]`
`np.zeros((3,4))`	Matriz de ceros	3×4 de 0.0
`np.ones((2,3))`	Matriz de unos	2×3 de 1.0
`np.arange(0, 10, 2)`	Secuencia con paso	`[0, 2, 4, 6, 8]`
`np.linspace(0, 1, 5)`	N puntos equidistantes	`[0, .25, .5, .75, 1]`
`np.random.normal(0,1,100)`	Distribución normal	100 valores con μ=0, σ=1
`np.eye(3)`	Matriz identidad	3×3 con 1s en la diagonal

Diferencia mortal con listas: las operaciones aritméticas funcionan distinto. [1,2,3] * 3 en Python da [1,2,3,1,2,3,1,2,3] (repetición). np.array([1,2,3]) * 3 da [3, 6, 9] (multiplicación elemento a elemento). Esto es fundamental y fuente de bugs cuando mezclas listas y arrays.

En el trabajo real: aunque trabajes principalmente con pandas, NumPy aparece constantemente: cuando usás np.where(), np.random para simulaciones, np.log() para transformaciones, o cuando un modelo de scikit-learn te devuelve un array de predicciones. Entender NumPy te hace más eficiente con todas estas herramientas.

Ejemplos explicados paso a paso

Ejemplo 1: Crear arrays y explorar sus atributos

Conocer la forma, tipo y tamaño de un array es como el .shape y .dtypes del EDA pero a nivel atómico.

ejemplo_01_crear.pyPython

import numpy as np

# Desde una lista
a = np.array([10, 20, 30, 40, 50])
print(f"1D: {a}")
print(f"   shape={a.shape}, ndim={a.ndim}, dtype={a.dtype}")

# Matriz 2D (3 filas × 4 columnas)
m = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])
print(f"\n2D:\n{m}")
print(f"   shape={m.shape}, ndim={m.ndim}, size={m.size}")

# Funciones de creación
print(f"\nzeros(2,3):\n{np.zeros((2, 3))}")
print(f"\narange(0,10,2): {np.arange(0, 10, 2)}")
print(f"linspace(0,1,5): {np.linspace(0, 1, 5)}")

# Random
np.random.seed(42)
normal = np.random.normal(100, 15, 5)
print(f"\nnormal(μ=100, σ=15): {normal.round(1)}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Operaciones vectorizadas — Adiós a los bucles

La gran ventaja de NumPy: aplicar operaciones matemáticas a millones de elementos sin escribir for loops.

ejemplo_02_vectorizadas.pyPython

import numpy as np

precios = np.array([100, 250, 80, 340, 190])
cantidades = np.array([5, 2, 10, 1, 3])

# Operaciones elemento a elemento (sin bucles)
totales = precios * cantidades
print(f"Precios:    {precios}")
print(f"Cantidades: {cantidades}")
print(f"Totales:    {totales}")
print(f"Gran total: ${totales.sum():,}")

# Funciones universales (ufuncs)
datos = np.array([10000, 50000, 100000, 500000, 1000000])
print(f"\nDatos originales: {datos}")
print(f"Log10:            {np.log10(datos)}")
print(f"Raíz cuadrada:    {np.sqrt(datos).round(1)}")

# Comparaciones vectorizadas → array de booleanos
print(f"\n¿Mayores a $200?: {precios > 200}")
print(f"Filtrado: {precios[precios > 200]}")

# Velocidad: 1M de operaciones
import time
arr = np.random.random(1_000_000)
t0 = time.time()
resultado = arr * 2 + 1
t1 = time.time()
print(f"\n1M de operaciones en {(t1-t0)*1000:.1f} ms (vectorizado)")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Indexación y slicing

NumPy extiende el slicing de Python con indexación avanzada: booleana, fancy indexing y slicing multidimensional.

ejemplo_03_indexacion.pyPython

import numpy as np

m = np.array([[10, 20, 30, 40],
              [50, 60, 70, 80],
              [90, 100, 110, 120]])

print("Matriz:")
print(m)

# Acceso básico
print(f"\nElemento [1,2]: {m[1, 2]}")         # fila 1, col 2 → 70
print(f"Fila 0:         {m[0]}")               # [10, 20, 30, 40]
print(f"Columna 1:      {m[:, 1]}")            # [20, 60, 100]
print(f"Submatriz:      \n{m[0:2, 1:3]}")      # [[20,30],[60,70]]

# Indexación booleana (filtrado)
print(f"\nMayores a 50:   {m[m > 50]}")

# Fancy indexing (seleccionar filas específicas)
print(f"Filas 0 y 2:\n{m[[0, 2]]}")

# np.where → equivalente a un IF vectorizado
arr = np.array([85, 42, 91, 67, 55])
resultado = np.where(arr >= 60, "Aprobado", "Desaprobado")
print(f"\nNotas: {arr}")
print(f"State: {resultado}")

Hacé clic en ▶ Ejecutar

Tip profesional — slicing 2D: la sintaxis m[filas, columnas] es la clave. m[:, 0] = todas las filas, columna 0. m[1:3, :] = filas 1 y 2, todas las columnas. Practicá esta notación hasta que sea natural — la vas a usar constantemente.

Ejemplo 4: Estadísticas y agregaciones

NumPy tiene funciones estadísticas optimizadas que son las mismas que pandas usa internamente. También podés agregar por eje (fila o columna).

ejemplo_04_estadisticas.pyPython

import numpy as np

np.random.seed(42)
# Matriz de ventas: 4 sucursales × 6 meses
ventas = np.random.randint(20000, 80000, size=(4, 6))
sucursales = ["CABA", "Rosario", "Córdoba", "Mendoza"]
meses = ["Ene", "Feb", "Mar", "Abr", "May", "Jun"]

print("Ventas (4 suc × 6 meses):")
print(ventas)

# Estadísticas globales
print(f"\nGlobal: media=${ventas.mean():,.0f}, std=${ventas.std():,.0f}")

# Por eje: axis=0 → por columna (cada mes), axis=1 → por fila (cada sucursal)
print(f"\nPromedio por sucursal (axis=1):")
for i, suc in enumerate(sucursales):
    print(f"  {suc}: ${ventas[i].mean():,.0f}")

print(f"\nTotal por mes (axis=0):")
totales_mes = ventas.sum(axis=0)
for j, mes in enumerate(meses):
    print(f"  {mes}: ${totales_mes[j]:,}")

# Funciones útiles
print(f"\nMax global: ${ventas.max():,} (suc {sucursales[ventas.max(axis=1).argmax()]})")
print(f"Min global: ${ventas.min():,}")
print(f"Percentil 90: ${np.percentile(ventas, 90):,.0f}")

Hacé clic en ▶ Ejecutar

axis=0 vs axis=1: esta es la confusión más común de NumPy/pandas. axis=0 opera a lo largo de las filas (el resultado tiene una columna). axis=1 opera a lo largo de las columnas (el resultado tiene una fila). Pensalo así: axis=0 "colapsa" las filas → resultado por columna. axis=1 "colapsa" las columnas → resultado por fila.

Ejemplo 5: Reshape y broadcasting

Reshape cambia la forma de un array sin copiar datos. Broadcasting permite operar arrays de distinto tamaño automáticamente.

ejemplo_05_reshape_broadcast.pyPython

import numpy as np

# Reshape: cambiar la forma sin cambiar los datos
a = np.arange(12)
print(f"Original (12,): {a}")
print(f"Reshape (3,4):\n{a.reshape(3, 4)}")
print(f"Reshape (4,3):\n{a.reshape(4, 3)}")
print(f"Reshape (2,6):\n{a.reshape(2, 6)}")

# Broadcasting: operar arrays de distinto tamaño
# Caso 1: array + escalar
precios = np.array([100, 200, 300])
con_iva = precios * 1.21
print(f"\nPrecios: {precios}")
print(f"Con IVA: {con_iva}")

# Caso 2: matriz + vector (el vector se "estira" automáticamente)
ventas = np.array([[100, 200, 300],
                   [150, 250, 350]])
descuento = np.array([0.10, 0.15, 0.20])  # diferente % por producto

neto = ventas * (1 - descuento)  # broadcasting: descuento se aplica a cada fila
print(f"\nVentas:\n{ventas}")
print(f"Descuento por producto: {descuento}")
print(f"Neto (con broadcasting):\n{neto}")

print("\nBroadcasting expandió el vector [0.10, 0.15, 0.20] a cada fila")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Función	Ejemplo
Crear array	`np.array()`	`np.array([1,2,3])`
Ceros / Unos	`np.zeros() / ones()`	`np.zeros((3,4))`
Secuencia	`np.arange() / linspace()`	`np.arange(0,10,2)`
Random	`np.random.normal()`	`np.random.normal(0,1,100)`
Forma	`.shape / .reshape()`	`a.reshape(3,4)`
Suma / Media	`.sum() / .mean()`	`a.mean(axis=0)`
Min / Max	`.min() / .max()`	`a.max(axis=1)`
Desv. std	`.std()`	`a.std()`
Filtro booleano	`a[a > 5]`	Elementos mayores a 5
IF vectorizado	`np.where(cond, si, no)`	`np.where(a>0,"pos","neg")`
Operaciones	`+ - * / **`	Elemento a elemento

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear un array y explorar atributos

Creá un array 2D de forma (3, 4) con np.arange(12).reshape(3,4). Imprimí su shape. Debe incluir (3, 4).

ejercicio_01.pyDebe incluir "(3, 4)"

import numpy as np

# Creá un array de 0 a 11, luego reshape a (3,4)
# Imprimí el array y su shape

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Operaciones vectorizadas

Calculá el total de ventas (precios * cantidades) y la suma total. Debe incluir 2300.

ejercicio_02.pyDebe incluir "2300"

import numpy as np

precios = np.array([100, 200, 300])
cantidades = np.array([5, 2, 3])

# Calculá totales = precios * cantidades, luego suma total

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Filtrado booleano

Filtrá los valores mayores a 50 del array. Imprimí cuántos son. Debe incluir 3.

ejercicio_03.pyDebe incluir "3"

import numpy as np

datos = np.array([10, 85, 42, 91, 30, 67])

# Filtrá > 50 y contá cuántos son

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Estadísticas con axis

Dada una matriz 3×4 de ventas, calculá el promedio por fila (axis=1). Imprimí el promedio de la primera fila, debe incluir 25.0.

ejercicio_04.pyDebe incluir "25.0"

import numpy as np

ventas = np.array([[10, 20, 30, 40],
                   [50, 60, 70, 80],
                   [15, 25, 35, 45]])

# Promedio por fila (axis=1) e imprimí el resultado

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: np.where() — IF vectorizado

Usá np.where() para clasificar notas en "Aprobado" (≥60) o "Desaprobado". Debe incluir Aprobado.

ejercicio_05.pyDebe incluir "Aprobado"

import numpy as np

notas = np.array([85, 42, 91, 55, 60, 38, 73])

# np.where para clasificar

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Broadcasting — aplicar IVA

Multiplicá un array de precios por 1.21 (IVA). Imprimí el primer precio con IVA. Debe incluir 121.0.

ejercicio_06.pyDebe incluir "121.0"

import numpy as np

precios = np.array([100, 250, 80, 340])

# Multiplicá por 1.21 (broadcasting con escalar)

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Slicing 2D

De una matriz 4×5, extraé la submatriz de las filas 1 a 2 y columnas 2 a 4 con slicing. Imprimí su shape. Debe incluir (2, 3).

ejercicio_07.pyDebe incluir "(2, 3)"

import numpy as np

m = np.arange(20).reshape(4, 5)
print(f"Matriz original:\n{m}")

# Extraé filas 1:3, columnas 2:5

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Generar datos aleatorios y estadísticas

Generá 1000 valores con distribución normal (μ=500, σ=100). Imprimí media, std y percentil 95. Debe incluir un valor cercano a 500.

ejercicio_08.pyDebe incluir algo cercano a "500"

import numpy as np
np.random.seed(42)

# Generá 1000 valores normales con μ=500, σ=100
# Imprimí media, std, percentil 95

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Reshape y operaciones por eje

Reshape un array de 12 elementos a (3,4). Calculá la suma por columna (axis=0). Imprimí el resultado. Debe incluir 15.

ejercicio_09.pyDebe incluir "15"

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

# Reshape a (3,4), sumá por columna

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Simulación Montecarlo del IVA

Simulá 10,000 ventas con precios aleatorios (normal μ=500, σ=200, mínimo 50). Calculá IVA (21%), filtrá ventas >$800 y contá qué porcentaje del total representan. Debe incluir %.

ejercicio_10_desafio.pyDebe incluir "%"

import numpy as np
np.random.seed(42)

# 1. Generá 10000 precios (normal, μ=500, σ=200)
# 2. Usá np.clip() para que mínimo sea 50
# 3. Calculá precios con IVA (* 1.21)
# 4. Filtrá los que superan $800
# 5. Imprimí qué % del total son

Hacé clic en ▶ Ejecutar

Resumen y conexión

NumPy arrays son bloques contiguos de memoria con tipo homogéneo → operaciones 10-100x más rápidas que listas.
Operaciones vectorizadas eliminan los bucles: a * b multiplica elemento a elemento sin for.
Broadcasting expande arrays de distinto tamaño automáticamente para operar juntos.
axis=0 colapsa filas (resultado por columna), axis=1 colapsa columnas (resultado por fila).
Indexación booleana (arr[arr > 50]) es la forma más eficiente de filtrar datos numéricos.
np.where() es el IF vectorizado — la base del np.where que usaste en pandas.

En la siguiente lección (14 · Intro a Machine Learning) vas a descubrir cómo las máquinas aprenden de los datos. NumPy es la base sobre la que se construyen todos los modelos — los datos siempre terminan como arrays numéricos.

Recursos: NumPy Quick Start · API Reference

Hecho con ❤️ por Rodri Gonzalez