Tutorial Python: Módulo statistics

Medidas de tendencia central

Las medidas de tendencia central son valores representativos que nos permiten resumir un conjunto de datos en un solo número. Estas medidas nos ayudan a identificar el "centro" o valor típico de una distribución, facilitando la interpretación y comparación de diferentes conjuntos de datos.

El módulo statistics de Python, incluido en la biblioteca estándar, proporciona funciones para calcular estas medidas sin necesidad de instalar bibliotecas externas como NumPy o Pandas. Esto lo hace ideal para análisis estadísticos básicos o cuando queremos mantener nuestras dependencias al mínimo.

Media aritmética

La media (también conocida como promedio) es la suma de todos los valores dividida por el número total de valores. Es probablemente la medida de tendencia central más utilizada.

Para calcular la media con el módulo statistics, utilizamos la función mean():

import statistics

# Lista de calificaciones de estudiantes
calificaciones = [85, 90, 78, 92, 88, 76, 95, 89]

# Calculando la media
media = statistics.mean(calificaciones)
print(f"La media de las calificaciones es: {media}")

La salida sería:

La media de las calificaciones es: 86.625

La media es sensible a valores extremos (outliers), lo que puede ser una desventaja en ciertos casos. Por ejemplo:

# Temperaturas diarias en grados Celsius
temperaturas = [22, 24, 23, 25, 22, 100]  # 100°C es un valor atípico

# Calculando la media
media = statistics.mean(temperaturas)
print(f"La media de temperaturas es: {media}")

Esto daría:

La media de temperaturas es: 36.0

Como podemos ver, un solo valor extremo (100°C) ha elevado considerablemente la media, haciendo que no sea representativa del conjunto de datos.

Mediana

La mediana es el valor que ocupa la posición central cuando los datos están ordenados. Si el número de datos es par, la mediana es el promedio de los dos valores centrales.

La mediana es menos sensible a valores extremos que la media, lo que la hace útil cuando tenemos outliers:

# Calculando la mediana de las temperaturas
mediana = statistics.median(temperaturas)
print(f"La mediana de temperaturas es: {mediana}")

Resultado:

La mediana de temperaturas es: 23.5

La mediana (23.5°C) representa mejor la tendencia central de las temperaturas que la media (36°C), ya que no se ve tan afectada por el valor atípico de 100°C.

El módulo statistics también ofrece variantes de la mediana:

• median_low(): Devuelve el valor más bajo de los dos centrales cuando hay un número par de datos.
• median_high(): Devuelve el valor más alto de los dos centrales cuando hay un número par de datos.

datos_pares = [1, 3, 5, 7]

# Diferentes tipos de medianas
print(f"Mediana: {statistics.median(datos_pares)}")
print(f"Mediana baja: {statistics.median_low(datos_pares)}")
print(f"Mediana alta: {statistics.median_high(datos_pares)}")

Resultado:

Mediana: 4.0
Mediana baja: 3
Mediana alta: 5

Moda

La moda es el valor que aparece con mayor frecuencia en un conjunto de datos. Es especialmente útil para datos categóricos o discretos.

Para calcular la moda, utilizamos la función mode():

# Respuestas a una encuesta (1-5)
respuestas = [3, 4, 2, 5, 3, 4, 3, 3, 5, 2, 3]

# Calculando la moda
moda = statistics.mode(respuestas)
print(f"La moda de las respuestas es: {moda}")

Resultado:

La moda de las respuestas es: 3

En este caso, el valor 3 aparece cinco veces, más que cualquier otro valor.

A partir de Python 3.8, también está disponible la función multimode(), que devuelve todas las modas en caso de que haya más de una:

# Datos con múltiples modas
datos_bimodales = [1, 1, 2, 2, 3, 4, 5]

# Calculando todas las modas
modas = statistics.multimode(datos_bimodales)
print(f"Las modas son: {modas}")

Resultado:

Las modas son: [1, 2]

Media geométrica y armónica

El módulo statistics también proporciona otras medias menos comunes pero útiles en ciertos contextos:

La media geométrica es útil para tasas de crecimiento, rendimientos financieros o cualquier conjunto de datos donde la multiplicación es más relevante que la suma:

# Tasas de crecimiento anual (en porcentaje)
tasas_crecimiento = [1.05, 1.08, 1.03, 1.07]  # 5%, 8%, 3%, 7%

# Calculando la media geométrica
media_geometrica = statistics.geometric_mean(tasas_crecimiento)
print(f"La media geométrica es: {media_geometrica}")

Resultado:

La media geométrica es: 1.0573620375713457

Esto indica un crecimiento promedio del 5.74% anual.

La media armónica es útil para promediar tasas, velocidades o cualquier medida donde se necesite mantener la relación inversa:

# Velocidades en diferentes tramos (km/h)
velocidades = [40, 60, 50, 45]

# Calculando la media armónica
media_armonica = statistics.harmonic_mean(velocidades)
print(f"La media armónica es: {media_armonica}")

Resultado:

La media armónica es: 47.61904761904762

Comparación de medidas de tendencia central

Cada medida de tendencia central tiene sus propias características y casos de uso. Veamos un ejemplo comparativo:

import statistics
import matplotlib.pyplot as plt

# Datos de ingresos mensuales (en miles)
ingresos = [2.8, 3.2, 2.9, 3.0, 2.7, 2.5, 15.0]  # 15 es un valor atípico

# Calculando diferentes medidas
media = statistics.mean(ingresos)
mediana = statistics.median(ingresos)
moda = statistics.mode(ingresos)

print(f"Media: {media}")
print(f"Mediana: {mediana}")
print(f"Moda: {moda}")

# Visualización simple
plt.figure(figsize=(10, 6))
plt.scatter(range(len(ingresos)), ingresos, color='blue', label='Datos')
plt.axhline(y=media, color='r', linestyle='-', label=f'Media: {media:.2f}')
plt.axhline(y=mediana, color='g', linestyle='--', label=f'Mediana: {mediana:.2f}')
plt.axhline(y=moda, color='purple', linestyle=':', label=f'Moda: {moda:.2f}')
plt.legend()
plt.title('Comparación de medidas de tendencia central')
plt.ylabel('Ingresos (miles)')
plt.tight_layout()
plt.show()

Este código generaría una visualización que muestra cómo la media se ve más afectada por el valor atípico (15.0) que la mediana o la moda.

Elección de la medida adecuada

La elección de la medida de tendencia central más apropiada depende del tipo de datos y del contexto:

• Media: Ideal para datos continuos con distribución simétrica sin valores atípicos significativos.
• Mediana: Preferible cuando hay valores extremos o la distribución está sesgada.
• Moda: Útil para datos categóricos o cuando queremos conocer el valor más común.

# Ejemplo de datos sesgados: precios de viviendas (en miles)
precios = [150, 165, 180, 190, 210, 250, 300, 450, 800]

# Calculando medidas
media = statistics.mean(precios)
mediana = statistics.median(precios)

print(f"Media de precios: {media}")
print(f"Mediana de precios: {mediana}")

Resultado:

Media de precios: 299.44444444444446
Mediana de precios: 210

En este caso, la mediana (210) probablemente representa mejor el "precio típico" que la media (299.44), ya que esta última se ve inflada por los valores más altos.

Aplicación práctica

Veamos un ejemplo práctico de cómo utilizar estas medidas para analizar datos reales:

import statistics

# Tiempos de respuesta de un servidor web (en milisegundos)
tiempos_respuesta = [45, 42, 38, 40, 43, 120, 41, 39, 44]

# Análisis estadístico básico
media = statistics.mean(tiempos_respuesta)
mediana = statistics.median(tiempos_respuesta)
desviacion = statistics.stdev(tiempos_respuesta)

print(f"Tiempo medio de respuesta: {media:.2f} ms")
print(f"Tiempo mediano de respuesta: {mediana:.2f} ms")
print(f"Desviación estándar: {desviacion:.2f} ms")

# Identificando posibles problemas
if media > 1.5 * mediana:
    print("Advertencia: La media es significativamente mayor que la mediana.")
    print("Esto sugiere valores atípicos que podrían indicar problemas de rendimiento.")

Este análisis nos permitiría identificar rápidamente si hay problemas de rendimiento en el servidor, utilizando la diferencia entre la media y la mediana como indicador de valores atípicos.

Medidas de dispersión

Las medidas de dispersión nos permiten entender cómo se distribuyen los datos alrededor de los valores centrales. Mientras que las medidas de tendencia central nos dan un punto de referencia, las medidas de dispersión nos indican qué tan esparcidos o concentrados están los valores en nuestro conjunto de datos.

El módulo statistics de Python proporciona varias funciones para calcular estas medidas de dispersión, permitiéndonos cuantificar la variabilidad de nuestros datos sin necesidad de bibliotecas externas.

Rango

El rango es la medida de dispersión más simple y representa la diferencia entre el valor máximo y mínimo de un conjunto de datos. Aunque no está implementado directamente en el módulo statistics, podemos calcularlo fácilmente:

import statistics

# Datos de temperatura diaria (°C)
temperaturas = [22, 24, 19, 21, 25, 23, 20]

# Calculando el rango
rango = max(temperaturas) - min(temperaturas)
print(f"El rango de temperaturas es: {rango}°C")

Resultado:

El rango de temperaturas es: 6°C

El rango nos da una idea rápida de la amplitud de nuestros datos, pero no nos dice nada sobre cómo se distribuyen los valores entre los extremos.

Varianza

La varianza mide la dispersión promedio de los valores con respecto a la media. Es el promedio de los cuadrados de las diferencias entre cada valor y la media. Un valor alto de varianza indica que los datos están muy dispersos.

Para calcular la varianza de una muestra, utilizamos la función variance():

# Pesos de paquetes en una línea de producción (kg)
pesos = [10.2, 10.4, 9.8, 10.0, 10.5, 9.9, 10.3]

# Calculando la varianza
varianza = statistics.variance(pesos)
print(f"La varianza de los pesos es: {varianza:.4f} kg²")

Resultado:

La varianza de los pesos es: 0.0624 kg²

El módulo statistics ofrece dos funciones para calcular la varianza:

• variance(): Calcula la varianza muestral (dividiendo por n-1)
• pvariance(): Calcula la varianza poblacional (dividiendo por n)

# Comparando varianza muestral y poblacional
var_muestral = statistics.variance(pesos)
var_poblacional = statistics.pvariance(pesos)

print(f"Varianza muestral: {var_muestral:.4f}")
print(f"Varianza poblacional: {var_poblacional:.4f}")

Resultado:

Varianza muestral: 0.0624
Varianza poblacional: 0.0535

La diferencia está en el denominador: la varianza muestral usa n-1 (corrección de Bessel) mientras que la poblacional usa n. Cuando trabajamos con una muestra de una población mayor, la varianza muestral proporciona un estimador insesgado de la varianza poblacional.

Desviación estándar

La desviación estándar es simplemente la raíz cuadrada de la varianza. Tiene la ventaja de estar expresada en las mismas unidades que los datos originales, lo que facilita su interpretación.

# Tiempos de entrega de pedidos (minutos)
tiempos_entrega = [25, 28, 30, 22, 27, 26, 31, 29]

# Calculando la desviación estándar
desviacion = statistics.stdev(tiempos_entrega)
print(f"La desviación estándar es: {desviacion:.2f} minutos")

Resultado:

La desviación estándar es: 2.95 minutos

Al igual que con la varianza, el módulo statistics proporciona dos funciones:

• stdev(): Desviación estándar muestral
• pstdev(): Desviación estándar poblacional

# Comparando ambas desviaciones
desv_muestral = statistics.stdev(tiempos_entrega)
desv_poblacional = statistics.pstdev(tiempos_entrega)

print(f"Desviación estándar muestral: {desv_muestral:.2f}")
print(f"Desviación estándar poblacional: {desv_poblacional:.2f}")

Resultado:

Desviación estándar muestral: 2.95
Desviación estándar poblacional: 2.77

Desviación absoluta media

La desviación absoluta media (MAD, por sus siglas en inglés) es el promedio de las diferencias absolutas entre cada valor y la media. Es menos sensible a valores extremos que la desviación estándar.

# Errores de predicción en un modelo (unidades)
errores = [2.5, -1.8, 3.2, -2.1, 1.5, -0.9, 15.0]  # 15.0 es un valor atípico

# Calculando la desviación absoluta media manualmente
media = statistics.mean(errores)
mad = sum(abs(x - media) for x in errores) / len(errores)
print(f"La desviación absoluta media es: {mad:.2f}")

Resultado:

La desviación absoluta media es: 4.29

A partir de Python 3.8, el módulo statistics incluye la función mean_absolute_deviation() que calcula esta medida directamente:

# Usando la función incorporada (Python 3.8+)
mad = statistics.mean_absolute_deviation(errores)
print(f"MAD (función incorporada): {mad:.2f}")

Rango intercuartílico (IQR)

El rango intercuartílico es la diferencia entre el tercer cuartil (Q3) y el primer cuartil (Q1). Representa el rango del 50% central de los datos y es muy útil para identificar valores atípicos.

Para calcular el IQR, podemos usar la función quantiles() introducida en Python 3.8:

# Datos de consumo eléctrico diario (kWh)
consumo = [8.2, 7.8, 9.1, 7.5, 8.0, 8.4, 15.2, 7.9, 8.3]

# Calculando cuartiles
cuartiles = statistics.quantiles(consumo, n=4)  # Divide en 4 partes (cuartiles)
q1, q2, q3 = cuartiles  # q2 es la mediana

# Calculando el rango intercuartílico
iqr = q3 - q1
print(f"Primer cuartil (Q1): {q1:.2f}")
print(f"Mediana (Q2): {q2:.2f}")
print(f"Tercer cuartil (Q3): {q3:.2f}")
print(f"Rango intercuartílico (IQR): {iqr:.2f}")

Resultado:

Primer cuartil (Q1): 7.85
Mediana (Q2): 8.20
Tercer cuartil (Q3): 8.75
Rango intercuartílico (IQR): 0.90

El IQR es especialmente útil para detectar valores atípicos. Una regla común es considerar como atípicos los valores que están a más de 1.5 × IQR por debajo de Q1 o por encima de Q3:

# Identificando valores atípicos
limite_inferior = q1 - 1.5 * iqr
limite_superior = q3 + 1.5 * iqr

print(f"Límite inferior para valores atípicos: {limite_inferior:.2f}")
print(f"Límite superior para valores atípicos: {limite_superior:.2f}")

# Encontrando valores atípicos
atipicos = [x for x in consumo if x < limite_inferior or x > limite_superior]
print(f"Valores atípicos: {atipicos}")

Resultado:

Límite inferior para valores atípicos: 6.50
Límite superior para valores atípicos: 10.10
Valores atípicos: [15.2]

Coeficiente de variación

El coeficiente de variación (CV) es una medida de dispersión relativa que expresa la desviación estándar como porcentaje de la media. Es útil para comparar la variabilidad entre conjuntos de datos con diferentes unidades o escalas.

# Rendimiento de dos cultivos diferentes (kg/hectárea)
cultivo_a = [520, 490, 550, 570, 530]
cultivo_b = [2100, 2300, 1950, 2250, 2000]

# Función para calcular el coeficiente de variación
def coef_variacion(datos):
    return (statistics.stdev(datos) / statistics.mean(datos)) * 100

cv_a = coef_variacion(cultivo_a)
cv_b = coef_variacion(cultivo_b)

print(f"Media del cultivo A: {statistics.mean(cultivo_a):.2f} kg/ha")
print(f"Media del cultivo B: {statistics.mean(cultivo_b):.2f} kg/ha")
print(f"CV del cultivo A: {cv_a:.2f}%")
print(f"CV del cultivo B: {cv_b:.2f}%")

Resultado:

Media del cultivo A: 532.00 kg/ha
Media del cultivo B: 2120.00 kg/ha
CV del cultivo A: 5.67%
CV del cultivo B: 6.49%

Aunque el cultivo B tiene una desviación estándar mucho mayor en términos absolutos, el coeficiente de variación nos muestra que, en términos relativos, ambos cultivos tienen una variabilidad similar.

Interpretación y visualización

Para entender mejor las medidas de dispersión, es útil visualizarlas junto con los datos:

import statistics
import matplotlib.pyplot as plt
import numpy as np

# Datos de altura de plantas (cm)
alturas = [65, 70, 62, 68, 73, 67, 71, 64, 69, 66]

# Calculando estadísticas
media = statistics.mean(alturas)
desviacion = statistics.stdev(alturas)

# Creando visualización
plt.figure(figsize=(10, 6))

# Histograma
plt.hist(alturas, bins=5, alpha=0.7, color='skyblue', edgecolor='black')

# Línea vertical para la media
plt.axvline(x=media, color='red', linestyle='-', linewidth=2, label=f'Media: {media:.1f}')

# Líneas verticales para media ± desviación estándar
plt.axvline(x=media-desviacion, color='green', linestyle='--', linewidth=1.5, 
            label=f'Media ± Desv. Est.: {media:.1f} ± {desviacion:.1f}')
plt.axvline(x=media+desviacion, color='green', linestyle='--', linewidth=1.5)

plt.title('Distribución de alturas de plantas')
plt.xlabel('Altura (cm)')
plt.ylabel('Frecuencia')
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Esta visualización nos mostraría cómo se distribuyen los datos alrededor de la media y qué proporción de ellos cae dentro de una desviación estándar.

Aplicaciones prácticas

Las medidas de dispersión tienen numerosas aplicaciones prácticas:

• Control de calidad: Monitorear la variabilidad en procesos de producción.

# Diámetros de piezas manufacturadas (mm)
diametros = [10.02, 10.05, 9.98, 10.01, 10.03, 9.99, 10.04, 10.00]

# Análisis de control de calidad
media = statistics.mean(diametros)
desviacion = statistics.stdev(diametros)
cv = (desviacion / media) * 100

print(f"Diámetro medio: {media:.2f} mm")
print(f"Desviación estándar: {desviacion:.4f} mm")
print(f"Coeficiente de variación: {cv:.2f}%")

# Verificando si el proceso está bajo control
if cv < 0.5:
    print("El proceso está bajo control (CV < 0.5%)")
else:
    print("El proceso muestra variabilidad excesiva (CV ≥ 0.5%)")

• Análisis de riesgo financiero: Evaluar la volatilidad de inversiones.

# Rendimientos mensuales de dos inversiones (%)
inversion_a = [1.2, -0.5, 0.8, 1.5, -0.3, 0.9]
inversion_b = [2.5, -2.1, 3.0, -1.8, 2.2, -1.5]

# Comparando riesgo (volatilidad)
riesgo_a = statistics.stdev(inversion_a)
riesgo_b = statistics.stdev(inversion_b)

print(f"Rendimiento medio A: {statistics.mean(inversion_a):.2f}%")
print(f"Rendimiento medio B: {statistics.mean(inversion_b):.2f}%")
print(f"Riesgo (desv. est.) A: {riesgo_a:.2f}%")
print(f"Riesgo (desv. est.) B: {riesgo_b:.2f}%")

• Evaluación educativa: Analizar la distribución de calificaciones.

# Calificaciones de dos grupos de estudiantes
grupo_a = [75, 82, 78, 80, 85, 79, 83, 77]
grupo_b = [65, 95, 72, 88, 60, 92, 70, 85]

# Comparando homogeneidad
desv_a = statistics.stdev(grupo_a)
desv_b = statistics.stdev(grupo_b)

print(f"Calificación media grupo A: {statistics.mean(grupo_a):.1f}")
print(f"Calificación media grupo B: {statistics.mean(grupo_b):.1f}")
print(f"Desviación estándar grupo A: {desv_a:.1f}")
print(f"Desviación estándar grupo B: {desv_b:.1f}")
print(f"El grupo {'A' if desv_a < desv_b else 'B'} tiene calificaciones más homogéneas.")

Elección de la medida adecuada

La elección de la medida de dispersión más apropiada depende del contexto y del tipo de datos:

• Desviación estándar: Ideal para datos con distribución aproximadamente normal y cuando necesitamos un análisis estadístico riguroso.
• Rango intercuartílico: Preferible cuando hay valores atípicos o la distribución está sesgada.
• Coeficiente de variación: Útil para comparar la dispersión relativa entre conjuntos de datos con diferentes unidades o escalas.

# Ejemplo de elección de medida según el tipo de datos
datos_normales = [105, 108, 103, 106, 107, 104, 109]
datos_sesgados = [10, 12, 11, 13, 9, 14, 50]  # 50 es un valor atípico

# Para datos normales, la desviación estándar es adecuada
print("Datos normales:")
print(f"Media: {statistics.mean(datos_normales):.2f}")
print(f"Desviación estándar: {statistics.stdev(datos_normales):.2f}")

# Para datos sesgados, el IQR es más robusto
print("\nDatos sesgados:")
cuartiles = statistics.quantiles(datos_sesgados, n=4)
iqr = cuartiles[2] - cuartiles[0]
print(f"Mediana: {statistics.median(datos_sesgados):.2f}")
print(f"IQR: {iqr:.2f}")

Correlación básica

La correlación es una medida estadística que nos permite cuantificar la relación entre dos variables numéricas. Entender si dos conjuntos de datos están relacionados y cómo lo están es fundamental en análisis de datos, investigación científica y toma de decisiones basadas en evidencia.

El módulo statistics de Python incluye funciones para calcular la correlación de manera sencilla, sin necesidad de recurrir a bibliotecas externas como NumPy o Pandas.

Coeficiente de correlación de Pearson

El coeficiente de correlación de Pearson (r) es la medida más común para evaluar la relación lineal entre dos variables. Este valor oscila entre -1 y 1:

• r = 1: Correlación positiva perfecta (cuando una variable aumenta, la otra aumenta proporcionalmente)
• r = -1: Correlación negativa perfecta (cuando una variable aumenta, la otra disminuye proporcionalmente)
• r = 0: No existe correlación lineal

Para calcular este coeficiente, utilizamos la función correlation() del módulo statistics:

import statistics

# Datos de altura (cm) y peso (kg) de un grupo de personas
alturas = [165, 170, 160, 180, 175, 155, 172, 168]
pesos = [68, 72, 65, 80, 76, 60, 74, 70]

# Calculando la correlación
correlacion = statistics.correlation(alturas, pesos)
print(f"Coeficiente de correlación: {correlacion:.4f}")

Resultado:

Coeficiente de correlación: 0.9944

Este valor cercano a 1 indica una correlación positiva muy fuerte entre altura y peso, lo que significa que generalmente las personas más altas tienden a pesar más.

Interpretación del coeficiente de correlación

La interpretación del coeficiente de correlación depende del contexto, pero generalmente se pueden seguir estas pautas:

• 0.00 - 0.19: Correlación muy débil
• 0.20 - 0.39: Correlación débil
• 0.40 - 0.59: Correlación moderada
• 0.60 - 0.79: Correlación fuerte
• 0.80 - 1.00: Correlación muy fuerte

Los mismos rangos aplican para valores negativos, indicando relaciones inversas.

# Función para interpretar el coeficiente de correlación
def interpretar_correlacion(r):
    r_abs = abs(r)
    if r_abs < 0.20:
        fuerza = "muy débil"
    elif r_abs < 0.40:
        fuerza = "débil"
    elif r_abs < 0.60:
        fuerza = "moderada"
    elif r_abs < 0.80:
        fuerza = "fuerte"
    else:
        fuerza = "muy fuerte"
    
    direccion = "positiva" if r > 0 else "negativa"
    
    return f"Correlación {fuerza} {direccion}"

# Ejemplos de interpretación
ejemplos = [0.15, -0.35, 0.55, -0.75, 0.95]
for r in ejemplos:
    print(f"r = {r:.2f}: {interpretar_correlacion(r)}")

Resultado:

r = 0.15: Correlación muy débil positiva
r = -0.35: Correlación débil negativa
r = 0.55: Correlación moderada positiva
r = -0.75: Correlación fuerte negativa
r = 0.95: Correlación muy fuerte positiva

Visualización de la correlación

Aunque el módulo statistics no proporciona herramientas de visualización, podemos combinar nuestros cálculos con matplotlib para entender mejor la correlación:

import matplotlib.pyplot as plt

# Datos de horas de estudio y calificaciones
horas_estudio = [1, 2, 3, 4, 5, 6, 7, 8]
calificaciones = [65, 70, 75, 80, 85, 85, 90, 95]

# Calculando la correlación
r = statistics.correlation(horas_estudio, calificaciones)

# Creando la visualización
plt.figure(figsize=(8, 6))
plt.scatter(horas_estudio, calificaciones, color='blue', alpha=0.7)
plt.title(f'Relación entre horas de estudio y calificaciones\nCorrelación: {r:.2f}')
plt.xlabel('Horas de estudio')
plt.ylabel('Calificación')
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Esta visualización mostraría un diagrama de dispersión con los puntos distribuidos en una tendencia ascendente, reflejando la correlación positiva entre horas de estudio y calificaciones.

Correlación vs. causalidad

Es crucial entender que correlación no implica causalidad. Dos variables pueden estar correlacionadas sin que una cause a la otra:

# Ejemplo: Consumo de helado y ahogamientos
# (Ambos aumentan en verano debido a la temperatura)
consumo_helado = [10, 15, 25, 30, 35, 40, 35, 25, 15, 10, 8, 7]  # kg/mes
ahogamientos = [5, 6, 10, 15, 20, 25, 22, 18, 12, 8, 6, 5]  # casos/mes

correlacion = statistics.correlation(consumo_helado, ahogamientos)
print(f"Correlación entre consumo de helado y ahogamientos: {correlacion:.4f}")
print("Nota: Esta correlación no indica que comer helado cause ahogamientos.")
print("Ambas variables están influenciadas por un tercer factor: la temperatura estacional.")

Resultado:

Correlación entre consumo de helado y ahogamientos: 0.9896
Nota: Esta correlación no indica que comer helado cause ahogamientos.
Ambas variables están influenciadas por un tercer factor: la temperatura estacional.

Correlación con datos faltantes

En situaciones reales, es común encontrar datos incompletos. La función correlation() de statistics maneja automáticamente los pares de datos donde uno o ambos valores son None:

# Datos con valores faltantes
x = [10, 15, None, 25, 30, 35, None]
y = [20, 25, 30, None, 40, 45, 50]

# Calculando correlación (solo usa pares completos)
correlacion = statistics.correlation(x, y)
print(f"Correlación con datos faltantes: {correlacion:.4f}")

La función utilizará solo los pares donde ambos valores están presentes, ignorando los pares incompletos.

Correlación de Spearman (correlación de rangos)

El coeficiente de correlación de Pearson asume una relación lineal entre variables. Cuando la relación es monótona pero no necesariamente lineal, o cuando trabajamos con datos ordinales, la correlación de Spearman es más apropiada.

Aunque el módulo statistics no incluye directamente esta función, podemos implementarla usando las funciones existentes:

def correlacion_spearman(x, y):
    """Calcula el coeficiente de correlación de Spearman entre dos variables."""
    # Filtrar pares completos
    pares = [(a, b) for a, b in zip(x, y) if a is not None and b is not None]
    if not pares:
        return None
    
    x_filtrado, y_filtrado = zip(*pares)
    
    # Convertir valores a rangos
    def rangos(datos):
        orden = sorted(range(len(datos)), key=lambda i: datos[i])
        rangos = [0] * len(datos)
        for i, pos in enumerate(orden):
            rangos[pos] = i + 1
        return rangos
    
    rangos_x = rangos(x_filtrado)
    rangos_y = rangos(y_filtrado)
    
    # Calcular correlación de Pearson entre los rangos
    return statistics.correlation(rangos_x, rangos_y)

# Ejemplo: Relación entre experiencia y salario
experiencia = [1, 3, 5, 7, 10, 15, 20]
salario = [3000, 3200, 3500, 4000, 5000, 5500, 6000]

# Calculando ambas correlaciones
pearson = statistics.correlation(experiencia, salario)
spearman = correlacion_spearman(experiencia, salario)

print(f"Correlación de Pearson: {pearson:.4f}")
print(f"Correlación de Spearman: {spearman:.4f}")

Aplicaciones prácticas

La correlación tiene numerosas aplicaciones en diversos campos:

• Finanzas: Analizar la relación entre diferentes activos para diversificación de carteras.

# Rendimientos mensuales de dos acciones (%)
accion_a = [1.2, -0.5, 0.8, 1.5, -0.3, 0.9, -0.2, 1.1]
accion_b = [-0.8, 0.6, -0.5, -1.2, 0.4, -0.7, 0.3, -0.9]

correlacion = statistics.correlation(accion_a, accion_b)
print(f"Correlación entre acciones: {correlacion:.4f}")

if correlacion < -0.5:
    print("Las acciones tienen correlación negativa fuerte.")
    print("Podrían ser buenas candidatas para diversificación de cartera.")

• Meteorología: Estudiar la relación entre variables climáticas.

# Temperatura (°C) y humedad relativa (%)
temperatura = [20, 22, 25, 28, 30, 32, 35, 33, 31, 29]
humedad = [85, 80, 75, 65, 60, 55, 45, 50, 55, 60]

correlacion = statistics.correlation(temperatura, humedad)
print(f"Correlación temperatura-humedad: {correlacion:.4f}")
print(f"Esto indica una relación {interpretar_correlacion(correlacion).split()[1]} inversa.")

• Salud: Investigar relaciones entre factores de riesgo y enfermedades.

# Consumo diario de azúcar (g) y nivel de glucosa en sangre (mg/dL)
azucar = [25, 40, 60, 35, 50, 75, 30, 45, 65, 55]
glucosa = [90, 95, 110, 92, 100, 120, 91, 98, 115, 105]

correlacion = statistics.correlation(azucar, glucosa)
print(f"Correlación azúcar-glucosa: {correlacion:.4f}")

Matriz de correlación simple

Para analizar las relaciones entre múltiples variables, podemos crear una matriz de correlación básica:

def matriz_correlacion(variables, nombres=None):
    """Crea una matriz de correlación para múltiples variables."""
    n = len(variables)
    if nombres is None:
        nombres = [f"Var{i+1}" for i in range(n)]
    
    # Imprimir encabezado
    header = "          " + "".join(f"{nombre:<10}" for nombre in nombres)
    print(header)
    print("-" * len(header))
    
    # Calcular y mostrar correlaciones
    for i, var1 in enumerate(variables):
        fila = f"{nombres[i]:<10}"
        for j, var2 in enumerate(variables):
            if i == j:
                fila += f"1.0000    "
            else:
                corr = statistics.correlation(var1, var2)
                fila += f"{corr:.4f}    "
        print(fila)

# Ejemplo con datos de estudiantes
calificaciones_mate = [85, 90, 75, 80, 95, 70, 85, 80]
calificaciones_ciencia = [90, 85, 80, 75, 90, 75, 80, 85]
horas_estudio = [8, 7, 5, 6, 9, 4, 7, 6]
horas_sueno = [7, 6, 8, 7, 6, 9, 7, 8]

variables = [calificaciones_mate, calificaciones_ciencia, horas_estudio, horas_sueno]
nombres = ["Matemát.", "Ciencias", "Estudio", "Sueño"]

matriz_correlacion(variables, nombres)

Esta función generaría una tabla que muestra las correlaciones entre todas las variables, permitiéndonos identificar rápidamente las relaciones más fuertes.

Consideraciones importantes

Al trabajar con correlaciones, debemos tener en cuenta varias consideraciones:

• Tamaño de la muestra: Las correlaciones basadas en muestras pequeñas pueden ser poco confiables.

# Comparando correlaciones con diferentes tamaños de muestra
muestra_pequena_x = [1, 2, 3, 4, 5]
muestra_pequena_y = [2, 3, 5, 6, 8]

muestra_grande_x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
muestra_grande_y = [2, 3, 5, 6, 8, 9, 10, 12, 13, 15, 16, 18, 19, 21, 22]

corr_pequena = statistics.correlation(muestra_pequena_x, muestra_pequena_y)
corr_grande = statistics.correlation(muestra_grande_x, muestra_grande_y)

print(f"Correlación (muestra pequeña, n=5): {corr_pequena:.4f}")
print(f"Correlación (muestra grande, n=15): {corr_grande:.4f}")

• Valores atípicos: Los outliers pueden distorsionar significativamente el coeficiente de correlación de Pearson.

# Efecto de valores atípicos en la correlación
x_normal = [1, 2, 3, 4, 5, 6, 7, 8, 9]
y_normal = [2, 3, 5, 4, 6, 7, 8, 9, 10]

# Añadiendo un valor atípico
x_con_atipico = x_normal + [100]
y_con_atipico = y_normal + [20]

corr_normal = statistics.correlation(x_normal, y_normal)
corr_atipico = statistics.correlation(x_con_atipico, y_con_atipico)

print(f"Correlación sin valor atípico: {corr_normal:.4f}")
print(f"Correlación con valor atípico: {corr_atipico:.4f}")

• Relaciones no lineales: El coeficiente de Pearson solo detecta relaciones lineales.

import math

# Relación cuadrática (no lineal)
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
y = [x_val**2 for x_val in x]  # y = x²

# La correlación de Pearson no captura bien esta relación
pearson = statistics.correlation(x, y)
print(f"Correlación de Pearson para relación cuadrática: {pearson:.4f}")
print("Aunque la relación es perfecta (y = x²), el coeficiente no es 1 porque la relación no es lineal.")

La correlación es una herramienta poderosa pero debe usarse con conocimiento de sus limitaciones y siempre en conjunto con análisis visuales y contextual de los datos.

Funciones estadísticas comunes

El módulo statistics de Python ofrece un conjunto de funciones adicionales que complementan las medidas de tendencia central y dispersión que ya hemos visto. Estas funciones nos permiten realizar análisis estadísticos más completos sin necesidad de recurrir a bibliotecas externas como NumPy o pandas.

Funciones para datos agrupados

Cuando trabajamos con conjuntos de datos grandes, a menudo los organizamos en grupos o categorías. El módulo statistics proporciona funciones específicas para estos casos.

La función fmean() calcula la media aritmética de manera más eficiente que mean() para datos de punto flotante:

import statistics

# Mediciones de temperatura con muchos decimales
temperaturas = [22.45, 23.78, 21.99, 22.56, 23.01, 22.87, 23.15]

# Usando fmean para mayor precisión y rendimiento
media_flotante = statistics.fmean(temperaturas)
print(f"Media (fmean): {media_flotante:.4f}°C")

Para datos con pesos o frecuencias diferentes, podemos usar weighted_mean():

# Calificaciones y sus pesos (importancia)
calificaciones = [85, 90, 78, 92, 88]
pesos = [0.15, 0.30, 0.10, 0.25, 0.20]  # Suman 1.0

# Calculando la media ponderada
media_ponderada = statistics.weighted_mean(calificaciones, pesos)
print(f"Media ponderada: {media_ponderada:.2f}")

Funciones para distribuciones

El módulo statistics también incluye funciones para analizar la forma de las distribuciones de datos.

La asimetría (skewness) mide qué tan simétrica es una distribución:

# Datos con diferentes tipos de asimetría
datos_simetricos = [1, 2, 3, 4, 5, 6, 7, 8, 9]
datos_asim_positiva = [1, 2, 2, 3, 3, 3, 4, 5, 10]
datos_asim_negativa = [1, 6, 7, 8, 8, 8, 9, 9, 9]

# Calculando la asimetría
asimetria1 = statistics.skewness(datos_simetricos)
asimetria2 = statistics.skewness(datos_asim_positiva)
asimetria3 = statistics.skewness(datos_asim_negativa)

print(f"Asimetría (datos simétricos): {asimetria1:.4f}")
print(f"Asimetría (asimetría positiva): {asimetria2:.4f}")
print(f"Asimetría (asimetría negativa): {asimetria3:.4f}")

Un valor cercano a 0 indica una distribución simétrica, mientras que valores positivos indican una cola más larga hacia la derecha y valores negativos una cola más larga hacia la izquierda.

La curtosis mide qué tan "puntiaguda" es una distribución en comparación con una distribución normal:

# Calculando la curtosis
curtosis = statistics.kurtosis(datos_simetricos)
print(f"Curtosis: {curtosis:.4f}")

Un valor positivo indica una distribución más puntiaguda que la normal (leptocúrtica), mientras que un valor negativo indica una distribución más plana (platicúrtica).

Percentiles y cuantiles

Los percentiles dividen un conjunto de datos en 100 partes iguales, mientras que los cuantiles lo dividen en un número específico de partes.

# Datos de tiempo de respuesta de un servidor (ms)
tiempos = [45, 42, 50, 38, 40, 43, 41, 39, 44, 55, 60, 48]

# Calculando percentiles específicos
p25 = statistics.quantiles(tiempos, n=4)[0]  # Primer cuartil (25%)
p50 = statistics.median(tiempos)             # Mediana (50%)
p75 = statistics.quantiles(tiempos, n=4)[2]  # Tercer cuartil (75%)
p90 = statistics.quantiles(tiempos, n=10)[8] # Percentil 90

print(f"Percentil 25: {p25} ms")
print(f"Percentil 50 (mediana): {p50} ms")
print(f"Percentil 75: {p75} ms")
print(f"Percentil 90: {p90} ms")

La función quantiles() nos permite dividir los datos en n partes iguales. Por ejemplo, con n=4 obtenemos los cuartiles, con n=10 los deciles, y con n=100 los percentiles.

Normalización de datos

La normalización es el proceso de transformar los datos para que tengan propiedades específicas, como una media de 0 y una desviación estándar de 1 (puntuación Z).

# Función para calcular puntuaciones Z
def puntuacion_z(datos):
    media = statistics.mean(datos)
    desv = statistics.stdev(datos)
    return [(x - media) / desv for x in datos]

# Datos de altura (cm)
alturas = [165, 170, 160, 180, 175, 155, 172, 168]

# Normalizando los datos
alturas_z = puntuacion_z(alturas)

print("Alturas originales (cm):", alturas)
print("Alturas normalizadas (puntuación Z):", [round(z, 2) for z in alturas_z])

# Verificando que la media es aproximadamente 0 y la desviación estándar es 1
print(f"Media de puntuaciones Z: {statistics.mean(alturas_z):.4f}")
print(f"Desviación estándar de puntuaciones Z: {statistics.stdev(alturas_z):.4f}")

Las puntuaciones Z nos permiten comparar valores de diferentes distribuciones o escalas, ya que indican cuántas desviaciones estándar está un valor por encima o por debajo de la media.

Funciones para muestras aleatorias

El módulo random de Python se puede combinar con statistics para generar muestras aleatorias y realizar análisis estadísticos:

import random

# Generando una muestra aleatoria
poblacion = list(range(1, 101))  # Números del 1 al 100
muestra = random.sample(poblacion, 10)  # Muestra de 10 elementos

# Análisis estadístico de la muestra
print(f"Muestra: {muestra}")
print(f"Media: {statistics.mean(muestra):.2f}")
print(f"Mediana: {statistics.median(muestra)}")
print(f"Desviación estándar: {statistics.stdev(muestra):.2f}")

Intervalos de confianza

Los intervalos de confianza nos permiten estimar un rango donde es probable que se encuentre el verdadero valor de un parámetro poblacional:

import math

def intervalo_confianza_media(datos, nivel_confianza=0.95):
    """Calcula el intervalo de confianza para la media."""
    n = len(datos)
    media = statistics.mean(datos)
    desv = statistics.stdev(datos)
    
    # Valor crítico para el nivel de confianza (aproximación normal)
    # Para 95% de confianza, z = 1.96
    if nivel_confianza == 0.95:
        z = 1.96
    elif nivel_confianza == 0.99:
        z = 2.576
    else:
        z = 1.645  # Para 90% de confianza
    
    error = z * (desv / math.sqrt(n))
    
    return (media - error, media + error)

# Datos de presión arterial sistólica (mmHg)
presiones = [120, 125, 118, 132, 127, 122, 129, 124, 130, 126]

# Calculando intervalo de confianza al 95%
ic_95 = intervalo_confianza_media(presiones)
print(f"Media: {statistics.mean(presiones):.2f} mmHg")
print(f"Intervalo de confianza (95%): ({ic_95[0]:.2f}, {ic_95[1]:.2f}) mmHg")

Este código calcula un intervalo de confianza del 95% para la media de presión arterial, lo que significa que hay un 95% de probabilidad de que la verdadera media poblacional se encuentre dentro de ese rango.

Pruebas de normalidad

Aunque el módulo statistics no incluye pruebas de normalidad directamente, podemos implementar una aproximación simple basada en la asimetría y curtosis:

def es_aproximadamente_normal(datos, umbral=0.5):
    """Verifica si los datos siguen aproximadamente una distribución normal."""
    asimetria = abs(statistics.skewness(datos))
    curtosis = abs(statistics.kurtosis(datos))
    
    return asimetria < umbral and curtosis < umbral

# Generando datos normales
datos_normales = [random.gauss(100, 15) for _ in range(100)]

# Generando datos no normales (distribución exponencial)
datos_exponenciales = [random.expovariate(0.1) for _ in range(100)]

print(f"Datos normales son aproximadamente normales: {es_aproximadamente_normal(datos_normales)}")
print(f"Datos exponenciales son aproximadamente normales: {es_aproximadamente_normal(datos_exponenciales)}")

Análisis de valores atípicos

Podemos usar las funciones del módulo statistics para identificar valores atípicos en nuestros datos:

def detectar_valores_atipicos(datos, factor=1.5):
    """Detecta valores atípicos usando el método del rango intercuartílico."""
    cuartiles = statistics.quantiles(datos, n=4)
    q1, q3 = cuartiles[0], cuartiles[2]
    iqr = q3 - q1
    
    limite_inferior = q1 - factor * iqr
    limite_superior = q3 + factor * iqr
    
    atipicos = [x for x in datos if x < limite_inferior or x > limite_superior]
    return atipicos, (limite_inferior, limite_superior)

# Datos de ventas diarias ($)
ventas = [120, 135, 110, 140, 125, 115, 130, 350, 145, 128]

# Detectando valores atípicos
atipicos, limites = detectar_valores_atipicos(ventas)
print(f"Límites para valores atípicos: ({limites[0]:.2f}, {limites[1]:.2f})")
print(f"Valores atípicos detectados: {atipicos}")

Estadísticas robustas

Las estadísticas robustas son menos sensibles a valores extremos y distribuciones no normales:

def media_recortada(datos, proporcion=0.1):
    """Calcula la media recortada, eliminando los extremos."""
    n = len(datos)
    k = int(n * proporcion)
    datos_ordenados = sorted(datos)
    return statistics.mean(datos_ordenados[k:n-k])

# Datos con valores extremos
datos = [25, 28, 30, 32, 33, 35, 36, 80]

# Comparando diferentes estadísticas
print(f"Media: {statistics.mean(datos):.2f}")
print(f"Mediana: {statistics.median(datos):.2f}")
print(f"Media recortada (10%): {media_recortada(datos):.2f}")

La media recortada elimina un porcentaje de los valores más altos y más bajos antes de calcular la media, lo que la hace más robusta frente a valores atípicos.

Aplicación práctica: análisis de rendimiento

Veamos cómo aplicar varias de estas funciones en un escenario real de análisis de rendimiento:

import statistics
import random

# Simulando tiempos de carga de una página web (ms)
tiempos_carga = [random.normalvariate(300, 50) for _ in range(100)]
tiempos_carga.extend([random.normalvariate(600, 30) for _ in range(5)])  # Algunos valores atípicos

# Análisis estadístico completo
def analisis_rendimiento(datos):
    # Estadísticas básicas
    media = statistics.mean(datos)
    mediana = statistics.median(datos)
    desviacion = statistics.stdev(datos)
    
    # Percentiles
    p90 = statistics.quantiles(datos, n=10)[8]
    p95 = statistics.quantiles(datos, n=20)[18]
    p99 = statistics.quantiles(datos, n=100)[98]
    
    # Valores atípicos
    atipicos, _ = detectar_valores_atipicos(datos)
    
    # Media sin valores atípicos
    datos_filtrados = [x for x in datos if x not in atipicos]
    media_filtrada = statistics.mean(datos_filtrados) if datos_filtrados else media
    
    return {
        "media": media,
        "mediana": mediana,
        "desviacion": desviacion,
        "p90": p90,
        "p95": p95,
        "p99": p99,
        "atipicos": len(atipicos),
        "media_sin_atipicos": media_filtrada
    }

# Ejecutando el análisis
resultados = analisis_rendimiento(tiempos_carga)

# Mostrando resultados
print("Análisis de tiempos de carga:")
print(f"Media: {resultados['media']:.2f} ms")
print(f"Mediana: {resultados['mediana']:.2f} ms")
print(f"Desviación estándar: {resultados['desviacion']:.2f} ms")
print(f"Percentil 90: {resultados['p90']:.2f} ms")
print(f"Percentil 95: {resultados['p95']:.2f} ms")
print(f"Percentil 99: {resultados['p99']:.2f} ms")
print(f"Valores atípicos detectados: {resultados['atipicos']}")
print(f"Media sin valores atípicos: {resultados['media_sin_atipicos']:.2f} ms")

Este análisis nos proporciona una visión completa del rendimiento de carga de la página, identificando no solo los valores promedio sino también los percentiles altos (importantes para entender la experiencia de los usuarios) y el impacto de los valores atípicos.

Combinación con otras bibliotecas

Aunque el módulo statistics es suficiente para análisis básicos, se puede combinar fácilmente con otras bibliotecas para análisis más avanzados:

import statistics
import matplotlib.pyplot as plt

# Datos de ejemplo
datos = [random.normalvariate(100, 15) for _ in range(1000)]

# Análisis con statistics
media = statistics.mean(datos)
mediana = statistics.median(datos)
desviacion = statistics.stdev(datos)

# Visualización con matplotlib
plt.figure(figsize=(10, 6))
plt.hist(datos, bins=30, alpha=0.7, color='skyblue', edgecolor='black')
plt.axvline(media, color='red', linestyle='-', linewidth=2, label=f'Media: {media:.2f}')
plt.axvline(mediana, color='green', linestyle='--', linewidth=2, label=f'Mediana: {mediana:.2f}')

# Añadiendo líneas para media ± desviación estándar
plt.axvline(media - desviacion, color='orange', linestyle=':', linewidth=1.5, 
            label=f'Media ± Desv. Est.: {desviacion:.2f}')
plt.axvline(media + desviacion, color='orange', linestyle=':', linewidth=1.5)

plt.title('Distribución de datos con estadísticas')
plt.xlabel('Valor')
plt.ylabel('Frecuencia')
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Este código combina el análisis estadístico del módulo statistics con la visualización de matplotlib para crear un histograma informativo que muestra la distribución de los datos junto con las principales estadísticas.

El módulo statistics de Python proporciona un conjunto completo de herramientas para análisis estadísticos básicos, permitiéndonos realizar cálculos precisos y significativos sin depender de bibliotecas externas más complejas. Estas funciones son especialmente útiles para análisis rápidos, prototipos o cuando queremos mantener nuestras dependencias al mínimo.