Módulo statistics - parte 2

Correlación básica

flowchart TD
    STATS["statistics avanzado"] --> CORR["correlation: coeficiente Pearson r"]
    CORR --> RANGE["Rango: -1 (negativa) a +1 (positiva)"]
    STATS --> QUANT["quantiles: percentiles, P25/P75"]
    STATS --> Z["Normalización: puntuación Z = (x - mean) / stdev"]
    STATS --> CI["Intervalos de confianza (aprox. normal)"]
    QUANT --> IQR["IQR = Q3 - Q1"]
    IQR --> OUTLIERS["Detección de atípicos: 1.5*IQR"]
    STATS --> SHAPE["skewness, kurtosis: forma distribución"]

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 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 útil 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.

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.

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.