Python SciPy statsmodels en la práctica: el código y los comandos que realmente importan

Python SciPy statsmodels: lo esencial en un artículo — código real, diagramas y pasos concretos, extractos de un curso de 37 lecciones.

Python SciPy statsmodels en la práctica: el código y los comandos que realmente importan

Sin teoría interminable aquí: abrimos la terminal y practicamos. Aquí lo esencial de Python SciPy statsmodels, extraído directamente de un curso completo de 37 lecciones — con código real que puedes copiar y pegar ahora.

tl;dr
  • Introducción e Instalación
  • Recordatorio de NumPy para SciPy
  • Descubrir SciPy
  • Estadísticas descriptivas con scipy.stats
  • Pruebas estadísticas con SciPy
~$ cat ./parcours.md # Python SciPy statsmodels — 10 capítulos
01
Introducción e Instalación
→ Presentación del curso→ Instalar Python y las bibliotecas+ 1 más lecciones
02
Recordatorio NumPy para SciPy
→ Las tablas NumPy, el bloque fundamental→ Lo que se puede hacer con una tabla NumPy+ 1 más lecciones
03
Descubrir SciPy
→ ¿Qué es SciPy y para qué sirve?→ Organización de los módulos scipy.stats+ 1 más lecciones
04
Estadísticas descriptivas con scipy.stats
→ Media, mediana y moda→ Varianza, desviación estándar y dispersión+ 1 más lecciones
05
Pruebas estadísticas con SciPy
→ Introducción a las pruebas estadísticas y al valor p→ Prueba t de Student — comparar dos medias+ 2 más lecciones
06
Introducción a Statsmodels
→ ¿Qué es Statsmodels y en qué se diferencia de SciPy?→ Cargar datos y explorar los conjuntos integrados+ 1 más lecciones
07
Regresión lineal con Statsmodels
→ Teoría de la regresión lineal explicada simplemente→ Regresión lineal simple con Statsmodels+ 2 más lecciones
08
Regresión logística con Statsmodels
→ Teoría de la regresión logística→ Regresión logística en práctica con Statsmodels+ 1 más lecciones
🏁
Proyecto final (+ 2 capítulos en camino)
→ Te marchas con un proyecto concreto y demostrable

Predecir el futuro con ARIMA

NOTELo que vas a aprender — ARIMA es un modelo que aprende de las tendencias del pasado para predecir el futuro. Vamos a ver cómo funciona, cómo configurarlo y cómo usarlo para generar una previsión.

Lo que vamos a ver en esta lección

¿Qué es ARIMA, en términos simples?

ARIMA es un algoritmo de previsión. Observa los valores del pasado e intenta deducir qué va a pasar en el futuro.

TIPAnalogía — Imagina un meteorólogo. Para predecir la temperatura de mañana, mira la temperatura de los últimos días. Si los 3 últimos días fueron 18, 20, 22 grados (tendencia al alza), probablemente predecirá 24 mañana. ARIMA hace lo mismo, pero usando matemáticas precisas.

El nombre completo es Auto-Regressive Integrated Moving Average. Es un nombre complicado, pero el concepto es simple: el modelo se basa en los valores pasados y los errores de previsión pasados para estimar el siguiente valor.

Los 3 parámetros de ARIMA: p, d, q

Se escribe ARIMA(p, d, q). Cada letra tiene un rol preciso.

ParámetroSignificadoEjemplo simple
p Cuántos valores pasados se usan para predecir p=2 : se miran los 2 últimos meses
d Cuántas veces se transforma la serie para estabilizarla d=1 : la mayoría de las veces, d=1 es suficiente
q Cuántos errores pasados se usan para corregir la previsión q=1 : se tiene en cuenta el último error
TIPConsejo para principiantes — Empieza siempre con ARIMA(1, 1, 1). Es el ajuste básico que funciona bien en la mayoría de los casos. Podrás probar otros valores más adelante si hace falta.
NOTE¿Para qué sirve d? — La mayoría de las series reales tienen una tendencia (las ventas aumentan cada año, por ejemplo). ARIMA necesita que la serie esté «estable» (sin tendencia) para funcionar. El parámetro d transforma la serie para que sea estable. d=1 significa que se calculan las diferencias entre valores consecutivos.

Construir el modelo ARIMA paso a paso

Retomamos nuestra serie de ventas mensuales de 4 años. Vamos a usar los 38 primeros meses para entrenar el modelo y los 10 últimos para comprobar si las previsiones son buenas.

output
import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA

# --- Recrear la serie de ventas mensuales ---
np.random.seed(42)
dates = pd.date_range(start="2020-01", periods=48, freq="ME")
tendance = np.arange(48) * 1.0
mois = dates.month
saisonnalite = 10 * np.sin(2 * np.pi * (mois - 3) / 12)
bruit = np.random.normal(0, 3, 48)
ventes = 100 + tendance + saisonnalite + bruit
serie = pd.Series(ventes, index=dates, name="Ventes")

# --- Dividir : 38 meses para aprender, 10 meses para probar ---
train = serie.iloc[:38]   # datos de entrenamiento
test  = serie.iloc[38:]   # datos de prueba (el futuro conocido)

print(f"Entrainement : {len(train)} mois")
print(f"Test         : {len(test)} mois")
output
# --- Crear y ajustar el modelo ---
# order=(p, d, q) = (1, 1, 1) : ajuste básico
modele = ARIMA(train, order=(1, 1, 1))
resultat = modele.fit()

# Mostrar un resumen corto
print(f"AIC du modele : {resultat.aic:.2f}")
print("Modele ajuste avec succes !")
TIPAIC = Akaike Information Criterion. Es una puntuación que mide la calidad del modelo. Cuanto más bajo, mejor. Se usa para comparar varios modelos ARIMA entre sí.

Generar una previsión

Ahora que hemos entrenado el modelo, le pedimos que prevea los 10 próximos meses.

output
# Generar una previsión para 10 meses
prevision = resultat.forecast(steps=10)

# Comparar previsión vs valores reales
comparaison = pd.DataFrame({
    "Reel"    : test.values.round(1),
    "Prevision": prevision.values.round(1),
    "Erreur"  : (test.values - prevision.values).round(1)
}, index=test.index)

print(comparaison)
NOTE¿Cómo leer esta tabla?
  • Reel : las ventas reales de esos meses (lo que se ocultó al modelo durante el entrenamiento)
  • Prevision : lo que el modelo ARIMA predijo
  • Erreur : la diferencia. Un error cercano a 0 es bueno. Un error grande significa que la previsión fue mala.

Medir la calidad de la previsión

Para saber si nuestro modelo prevé bien, calculamos el error medio absoluto (MAE). Es simplemente la media de los errores, sin tener en cuenta el signo (positivo o negativo).

output
mae = np.abs(test.values - prevision.values).mean()
print(f"Erreur moyenne absolue (MAE) : {mae:.1f} unites")
print(f"Moyenne des ventes reelles   : {test.mean():.1f} unites")
print(f"Erreur relative              : {mae / test.mean() * 100:.1f}%")
TIPInterpretación — El modelo se equivoca en media 9.1 unidades, sobre ventas medias de 141. Eso representa un error del 6.4%. Para un modelo básico ARIMA(1,1,1), es aceptable. Se podría mejorar probando otros valores de p y q.

Predecir el futuro más allá de los datos disponibles

En la vida real, no tienes datos de prueba para comparar. Solo quieres prever los próximos meses.

Primer script SciPy

NOTEObjetivo — Escribir y ejecutar tu primer script usando SciPy. Vas a calcular estadísticas simples sobre un conjunto de datos ficticio, ver cómo se usa SciPy y asegurarte de que todo funciona antes de seguir adelante.

Objetivos pedagógicos

TIPAl final de este módulo — Habrás ejecutado tu primer script SciPy, comprenderás la estructura de un script de análisis y estarás cómodo para pasar a los siguientes capítulos.

La estructura de un script de análisis típico

Todo script de análisis de datos en Python sigue un esquema similar. Aprender este esquema ahora te ayudará en todos los capítulos siguientes.

Esquema general

Escenario: analizar las notas de un curso

Eres profesor. Tienes las notas de 20 estudiantes sobre 100. Quieres entender:

Paso 1: las importaciones

Lo primero que hay que hacer en cualquier script es importar las bibliotecas. Aquí está por qué se importan con alias:

output
import numpy as np                   # np es más corto a ecrire que numpy
from scipy import stats              # on importe uniquement le module stats de SciPy
import matplotlib.pyplot as plt      # plt est l'alias standard pour tracer des graphiques
NOTE¿Por qué from scipy import stats y no import scipy? — SciPy está dividido en submódulos. Importar solo stats es más eficiente porque solo se carga lo que se necesita. Luego se escribe stats.mean() en lugar de scipy.stats.mean().

Paso 2: crear los datos

output
notes = np.array([
    72, 85, 91, 63, 78, 55, 88, 94, 70, 82,
    66, 79, 87, 61, 90, 75, 83, 68, 77, 95
])

print("Nombre d'etudiants :", len(notes))
print("Notes              :", notes)
TIPnp.array() — Esta función crea un array NumPy a partir de una lista Python. Un array NumPy se parece a una lista Python, pero es mucho más potente para los cálculos matemáticos. SciPy siempre trabaja con arrays NumPy.

Paso 3: calcular las estadísticas con scipy.stats

output
moyenne = np.mean(notes)
mediane = np.median(notes)
ecart_type = np.std(notes)
minimum = np.min(notes)
maximum = np.max(notes)

print(f"Moyenne    : {moyenne:.2f}")
print(f"Mediane    : {mediane:.2f}")
print(f"Ecart-type : {ecart_type:.2f}")
print(f"Minimum    : {minimum}")
print(f"Maximum    : {maximum}")

Paso 4: usar scipy.stats para ir más lejos

NumPy calcula las estadísticas básicas. SciPy va más lejos añadiendo medidas como la asimetría (skewness) y el aplanamiento (kurtosis), que indican la forma de la distribución.

output
asymetrie = stats.skew(notes)
aplatissement = stats.kurtosis(notes)
description = stats.describe(notes)

print(f"Asymetrie (skewness)   : {asymetrie:.4f}")
print(f"Aplatissement (kurt)   : {aplatissement:.4f}")
print()
print("Description complete par scipy.stats.describe() :")
print(description)

Paso 5: interpretar los resultados

EstadísticaValorQué significa
Moyenne77.95En media, los estudiantes tienen casi 78/100
Médiane78.50La mitad de los estudiantes tiene menos de 78.5 y la otra mitad más
Écart-type11.32Las notas varían aproximadamente 11 puntos alrededor de la media
Asymétrie (-0.25)LigeraLa distribución es casi simétrica (ligera concentración hacia las notas altas)
Aplatissement (-0.88)NegativoDistribución un poco más plana que la normal (platykurtique)
NOTEMedia vs mediana — La media (77.95) y la mediana (78.50) están muy cerca aquí. Esto indica que no hay valores extremos que «tiren» de la media hacia arriba o hacia abajo. Cuando la media y la mediana son muy diferentes, suele señalar valores atípicos (outliers).

Paso 6: visualizar (bonus)

output
plt.figure(figsize=(8, 4))
plt.hist(notes, bins=8, color='steelblue', edgecolor='white', alpha=0.8)
plt.axvline(moyenne, color='red', linestyle='--', label=f'Moyenne ({moyenne:.1f})')
plt.axvline(mediane, color='orange', linestyle='-', label=f'Mediane ({mediane:.1f})')
plt.xlabel("Note sur 100")
plt.ylabel("Nombre d'etudiants")
plt.title("Distribution des notes de la classe")
plt.legend()
plt.tight_layout()
plt.show()
TIPplt.axvline() — Esta función dibuja una línea vertical en el gráfico. Es útil para marcar la media o la mediana en un histograma.

Qué se puede hacer con un array NumPy

NOTELo que vas a aprender — Cómo leer un valor preciso en un array, cómo conservar solo ciertos valores y cómo hacer cálculos sobre todo un array de una sola vez.

Lo que vamos a ver en esta lección

Leer un valor preciso en un array

Imagina que tu array es una fila de casillas numeradas. La primera casilla está numerada 0, no 1. Es una convención en Python. La segunda casilla es 1, la tercera es 2, etc.

TIPAnalogía — Es como los pisos de un edificio en Europa: la planta baja es el piso 0. El primer piso es el 1. En Python se cuenta igual.

También se puede contar desde el final con números negativos. -1 da el último elemento, -2 el penúltimo, etc.

output
import numpy as np

# Un tableau de 7 temperatures de la semaine
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])
#                          [0]   [1]   [2]   [3]   [4]   [5]   [6]

print( temperatures[0] )   # 18.5  -> lundi (1ere valeur)
print( temperatures[2] )   # 19.8  -> mercredi (3e valeur)
print( temperatures[-1] )  # 23.4  -> dimanche (derniere valeur)
print( temperatures[-2] )  # 17.2  -> samedi (avant-derniere)

Seleccionar varios valores seguidos

Si quieres tomar un trozo del array, usa la notación inicio:fin. Atención: el valor de fin está excluido. Si escribes [1:4], obtienes las casillas 1, 2 y 3, pero no la 4.

TIPAnalogía — Es como cortar una barra de pan. Si dices «dame del trozo 1 al trozo 4», el panadero te da los trozos 1, 2 y 3. El trozo 4 se queda en la tienda.
output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Les 3 premiers jours (lundi, mardi, mercredi)
print( temperatures[:3] )     # debut omis = depuis le debut

# Du mardi au vendredi (index 1 a 4, 4 exclu)
print( temperatures[1:4] )

# Les 2 derniers jours
print( temperatures[-2:] )    # fin omise = jusqu'a la fin

# Un jour sur deux (lundi, mercredi, vendredi, dimanche)
print( temperatures[::2] )

Conservar solo los valores que cumplen una condición

Es una de las cosas más potentes de NumPy. Puedes decir «dame solo las temperaturas superiores a 21 grados» y NumPy hace la selección automáticamente.

Aquí está cómo funciona en 2 pasos:

output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Etape 1 : quel jour fait-il plus de 21 degres ?
masque = temperatures > 21
print("Masque :", masque)
# True la ou c'est superieur a 21, False sinon

# Etape 2 : garder seulement ces valeurs
print("Jours > 21 degres :", temperatures[masque])

# On peut aussi faire les deux etapes en une seule ligne :
print("Jours < 20 degres :", temperatures[temperatures < 20])
NOTE¿Cómo leer la máscara? — La máscara tiene el mismo tamaño que el array. Para cada valor del array, dice True (sí, este valor cumple la condición) o False (no). NumPy solo conserva después las posiciones marcadas con True.

Hacer cálculos matemáticos sobre todo el array

NumPy ofrece funciones matemáticas que se aplican a cada elemento al mismo tiempo. No hace falta un bucle. Escribes una sola línea y NumPy hace el cálculo sobre todos los valores.

output
data = np.array([4.0, 9.0, 16.0, 25.0])

# np.sqrt = racine carree de chaque valeur
print("Racine carree :", np.sqrt(data))

# np.log = logarithme naturel de chaque valeur
print("Logarithme    :", np.round(np.log(data), 2))

# np.abs = valeur absolue (enleve le signe negatif)
nombres = np.array([-3, 5, -7, 2])
print("Valeur absolue:", np.abs(nombres))

Calcular estadísticas sobre todo el array

Estas funciones resumen un array en un solo número:

output
ventes = np.array([1200, 850, 1500, 970, 1100, 1350, 780])

print("Total de la semaine :", np.sum(ventes))
print("Moyenne journaliere :", np.mean(ventes).round(1))
print("Journee la plus haute :", np.max(ventes))
print("Journee la plus basse :", np.min(ventes))

# cumsum : total cumulatif jour par jour
print("Cumul jour par jour  :", np.cumsum(ventes))
TIP¿Para qué sirve cumsum? — cumsum significa «suma acumulativa». Cada valor mostrado es el total desde el principio. Aquí: lunes = 1200, lunes+martes = 2050, lunes+martes+miércoles = 3550, etc. Útil para seguir una cifra de negocio que se acumula.

Aplicar un cálculo a todos los valores al mismo tiempo

En Python normal, si quieres añadir un 10% a cada precio de una lista, escribes un bucle. Con NumPy, no hace falta. Escribes la operación una sola vez y se aplica a todos los valores. Esto se llama broadcasting.

TIPAnalogía — Imagina un año de subida de precios. Todos los precios de tu lista se aumentan un 20%. Con NumPy, multiplicas el array entero por 1.20 en una sola línea. Sin NumPy, habrías tenido que escribir un bucle que recorra cada precio uno por uno.
va-plus-loin

Este artículo cubre los extractos más útiles — el curso completo Python SciPy statsmodels (11 capítulos, 37 lecciones, ejercicios corregidos y proyecto final) te lleva hasta el final.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

¿Cuánto tiempo se necesita para aprender Python SciPy statsmodels?
Con una progresión estructurada (11 capítulos, 37 lecciones cortas y prácticas), se alcanza un nivel operativo en unas semanas a razón de 30 a 60 minutos al día. Lo importante es practicar cada noción inmediatamente.
¿Se necesitan requisitos previos?
Basta con nociones básicas de informática. Si sabes usar una terminal y leer código simple, estás listo.
¿Por dónde empezar concretamente?
Reproduce los comandos de este artículo y sigue el curso completo Python SciPy statsmodels: encadena las 37 lecciones en orden, con ejercicios y proyecto final.

📬 ¿Quieres recibir este tipo de guía cada semana? Suscríbete gratis — código real, cero palabrería.