Data Science II-E: Estadística descriptiva unidimensional. La curva normal

media_nota = df["nota"].mean()
var_nota = df["nota"].var()

print('nota media =',round(media_nota, 2))
print('varianza notas =',round(var_nota, 2))

import seaborn as sns
import matplotlib.pyplot as plt

# Graficar la densidad de las notas usando Seaborn (población=
plt.figure(figsize=(10, 6))
sns.kdeplot(data=df['nota'], fill=True, color='blue')
plt.title('Distribución de Notas de la Población')
plt.xlabel('Nota')
plt.ylabel('Densidad')
plt.show()

# Graficar el histograma con 11 contenedores sin forzar bordes específicos
plt.figure(figsize=(10, 6))
sns.histplot(data=df['nota'], bins=11, kde=True, color='blue')
plt.title('Distribución de Notas de la Población')
plt.xlabel('Nota')
plt.ylabel('Frecuencia')
plt.show()

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import statistics

# Establecer semillas para la reproducibilidad
np.random.seed(42)
random.seed(42)

# Función para calcular la moda usando pandas
def calcular_moda_pandas(df):
    return df['nota'].mode()[0]

# Función para calcular el rango medio
def calcular_rango_medio(df):
    minimo = df['nota'].min()
    maximo = df['nota'].max()
    return (minimo + maximo) / 2

# Crear la gráfica de densidad de las notas y marcar media, mediana, moda y rango medio
def graficar_densidad(df):
    # Calcular estadísticas
    media = df['nota'].mean()
    mediana = df['nota'].median()
    moda = calcular_moda_pandas(df)
    rango_medio = calcular_rango_medio(df)

    # Crear la gráfica de densidad
    plt.figure(figsize=(10, 6))
    sns.kdeplot(df['nota'], fill=True, color='blue', label='Densidad')

    # Marcar la media
    plt.axvline(media, color='red', linestyle='-', label=f'Media: {media:.2f}')

    # Marcar la mediana
    plt.axvline(mediana, color='green', linestyle='--', label=f'Mediana: {mediana:.2f}')

    # Marcar la moda
    plt.axvline(moda, color='purple', linestyle='--', label=f'Moda: {moda:.2f}')

    # Marcar el rango medio
    plt.axvline(rango_medio, color='orange', linestyle='--', label=f'Rango medio: {rango_medio:.2f}')

    # Etiquetas y título
    plt.title('Densidad de Notas con Media, Mediana, Moda y Rango Medio')
    plt.xlabel('Notas')
    plt.ylabel('Densidad')
    plt.legend()

    # Personalizar los ticks del eje x para mostrar solo los valores 2 a 9
    plt.xticks([2, 3, 4, 5, 6, 7, 8, 9])

    # Mostrar la gráfica
    plt.show()

# Llamada a la función
graficar_densidad(df)

import matplotlib.pyplot as plt
import numpy as np
import statsmodels.api as sm

# Calcular la media y la desviación estándar de la variable "nota"
media_nota = df["nota"].mean()
std_nota = df["nota"].std()

# Calcular los porcentajes reales de datos dentro de 1, 2 y 3
# desviaciones estándar
z1 = ((df["nota"] >= media_nota - std_nota) &
 (df["nota"] <= media_nota + std_nota)).mean() * 100
z2 = ((df["nota"] >= media_nota - 2 * std_nota) &
 (df["nota"] <= media_nota + 2 * std_nota)).mean() * 100
z3 = ((df["nota"] >= media_nota - 3 * std_nota) &
 (df["nota"] <= media_nota + 3 * std_nota)).mean() * 100

# Crear los datos de la densidad
kde = sm.nonparametric.KDEUnivariate(df["nota"])
kde.fit()
x_kde = kde.support
y_kde = kde.density

# Crear el gráfico de densidad
plt.figure(figsize=(10, 5))
plt.fill_between(x_kde, y_kde, color="blue", alpha=0.3)

def shade_region(start, end, color):
    mask = (x_kde >= start) & (x_kde <= end)
    plt.fill_between(x_kde[mask], y_kde[mask], color=color, alpha=0.5)

# Sombrear las áreas correspondientes
shade_region(media_nota - std_nota, media_nota + std_nota, "blue")  # 1σ
shade_region(media_nota - 2 * std_nota, media_nota - std_nota, "red")
shade_region(media_nota + std_nota, media_nota + 2 * std_nota, "red")  # 2σ
shade_region(media_nota - 3 * std_nota, media_nota - 2 * std_nota, "skyblue")
shade_region(media_nota + 2 * std_nota, media_nota + 3 * std_nota, "skyblue")  # 3σ

# Marcar la media y las desviaciones estándar
for i in range(-3, 4):
    valor = media_nota + i * std_nota
    etiqueta = "$\\mu$" if i == 0 else f"$\\mu {'+' if i > 0 else '-'} {abs(i)}\\sigma$"
    plt.axvline(valor, color="black", linestyle="--", alpha=0.7)
    plt.text(valor, plt.ylim()[1] * 0.05,
             etiqueta,
             horizontalalignment='center',
             color="black")

# Agregar los valores de calificación z debajo del eje x
ticks_x = [media_nota + i * std_nota for i in range(-3, 4)]
labels_x = [f"{tick:.2f}\n(z={i})" for i, tick in zip(range(-3, 4), ticks_x)]
plt.xticks(ticks_x, labels_x)

# Agregar porcentajes reales en la parte superior
plt.text(media_nota, plt.ylim()[1] * 0.5, f"{z1:.2f}%",
         horizontalalignment='center', fontsize=12, color="blue")
plt.text(media_nota, plt.ylim()[1] * 0.6, f"{z2:.2f}%",
         horizontalalignment='center', fontsize=12, color="red")
plt.text(media_nota, plt.ylim()[1] * 0.7, f"{z3:.2f}%",
         horizontalalignment='center', fontsize=12, color="skyblue")

# Etiquetas y título
plt.xlabel("Nota")
plt.ylabel("Densidad")
plt.title("Distribución de Notas con Calificación Z")
plt.show()

import pandas as pd
import numpy as np

# Calcular media y desviación estándar de las notas
media_nota = df["nota"].mean()
std_nota = df["nota"].std()

# Contar valores dentro de 1, 2 y 3 desviaciones estándar
dentro_1std = ((df["nota"] >= media_nota - std_nota) & (df["nota"] <= media_nota + std_nota)).mean() * 100
dentro_2std = ((df["nota"] >= media_nota - 2 * std_nota) & (df["nota"] <= media_nota + 2 * std_nota)).mean() * 100
dentro_3std = ((df["nota"] >= media_nota - 3 * std_nota) & (df["nota"] <= media_nota + 3 * std_nota)).mean() * 100

# Valores teóricos en distribución normal
teorico_1std = 68.27
teorico_2std = 95.45
teorico_3std = 99.73

# Crear DataFrame de comparación
comparacion_df = pd.DataFrame({
    "Rango": ["Media ± 1σ", "Media ± 2σ", "Media ± 3σ"],
    "Real (%)": [dentro_1std, dentro_2std, dentro_3std],
    "Teórico (%)": [teorico_1std, teorico_2std, teorico_3std]
})

# Mostrar la tabla
print(comparacion_df)

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# --- 1. Definir los parámetros ---
# Media de la distribución
mu = 6.48
# Varianza de la distribución
variance = 1.03
# La desviación estándar es la raíz cuadrada de la varianza
sigma = np.sqrt(variance)

# --- 2. Preparar los datos para el gráfico ---
# Creamos un rango de valores para el eje X.
# Usamos de -4 a +4 desviaciones estándar alrededor de la media para cubrir la mayor parte de la curva.
x = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000)

# Calculamos los valores del eje Y usando la función de densidad de probabilidad (PDF) de SciPy.
y = norm.pdf(x, mu, sigma)

# --- 3. Crear el gráfico ---
# Configuramos el tamaño de la figura para que se vea bien
plt.figure(figsize=(10, 6))

# Dibujamos la curva
plt.plot(x, y, color='#007acc', linewidth=2, label=f'σ² = {variance:.2f}')

# Añadimos una línea vertical para marcar la media (μ)
plt.axvline(mu, color='red', linestyle='--', linewidth=1.5, label=f'Media (μ) = {mu}')

# --- 4. Añadir títulos y etiquetas ---
plt.title(f'Distribución Normal (μ = {mu}, σ² = {variance})', fontsize=16)
plt.xlabel('Valor', fontsize=12)
plt.ylabel('Densidad de Probabilidad', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()

# --- 5. Mostrar el gráfico ---
plt.show()

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from scipy.stats import norm

def graficar_densidad_comparativa(df, mu_teorica, varianza_teorica):
    """
    Grafica la densidad de los datos reales de la columna 'nota' y la compara
    con una distribución normal teórica.

    Args:
        df (pd.DataFrame): DataFrame con la columna 'nota'.
        mu_teorica (float): Media para la curva normal teórica.
        varianza_teorica (float): Varianza para la curva normal teórica.
    """
    # --- 1. Calcular estadísticas de los datos REALES ---
    notas_reales = df['nota']
    media_real = notas_reales.mean()
    mediana_real = notas_reales.median()

    # --- 2. Preparar la gráfica ---
    plt.figure(figsize=(12, 7))

    # Dibuja la curva de densidad de los datos REALES
    sns.kdeplot(notas_reales, fill=True, color='#2b7bba', label='Densidad de Datos Reales')

    # Añade líneas para la media y mediana REALES
    plt.axvline(media_real, color='#e63946', linestyle='-', linewidth=2, label=f'Media Real: {media_real:.2f}')
    plt.axvline(mediana_real, color='#52b788', linestyle='--', linewidth=2, label=f'Mediana Real: {mediana_real:.2f}')

    # --- 3. Superponer la curva de la distribución normal TEÓRICA ---
    # Calcula la desviación estándar teórica
    sigma_teorica = np.sqrt(varianza_teorica)

    # Crea un rango de valores X que cubra la gráfica
    xmin, xmax = plt.xlim()
    x_teorico = np.linspace(xmin, xmax, 1000)

    # Calcula los valores Y para la curva teórica
    y_teorico = norm.pdf(x_teorico, mu_teorica, sigma_teorica)

    # Dibuja la curva teórica
    plt.plot(x_teorico, y_teorico, color='black', linestyle='-.', linewidth=2.5, label='Normal Teórica (μ=6.48, σ²=1.03)')

    # --- 4. Personalizar y mostrar el gráfico ---
    plt.title('Comparativa: Densidad Real vs. Distribución Normal Teórica', fontsize=16)
    plt.xlabel('Notas', fontsize=12)
    plt.ylabel('Densidad', fontsize=12)
    plt.legend()
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    plt.show()


# 2. Llama a la función con tu df y los parámetros teóricos
graficar_densidad_comparativa(df, mu_teorica=6.48, varianza_teorica=1.03)

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd

# 1. Definición de los bordes de los contenedores
# np.arange(12) crea un array [0, 1, 2, ..., 11] para 11 contenedores
bin_edges = np.arange(12)

# 2. Creación del gráfico
plt.figure(figsize=(10, 6))

# Se asigna el gráfico a la variable 'ax' para poder manipular sus elementos
# NOTA: Asegúrate de que tu DataFrame se llame 'df' y tenga la columna 'nota'
ax = sns.histplot(data=df['nota'], bins=bin_edges, kde=False, color='blue')

# 3. Configuración de títulos y ejes
plt.title('Distribución de Notas de la Población')
plt.xlabel('Nota')
plt.ylabel('Frecuencia')
plt.xticks(bin_edges) # Asegura que los ticks del eje X coincidan con los bordes

# 4. Bucle para añadir las etiquetas de frecuencia sobre cada barra
for p in ax.patches:
    height = p.get_height()
    if height > 0:
        ax.text(
            x=p.get_x() + p.get_width() / 2.,  # Posición X (centro de la barra)
            y=height + 2,                     # Posición Y (un poco encima de la barra)
            s=f'{int(height)}',               # Texto a mostrar (frecuencia)
            ha='center'                       # Alineación horizontal
        )

# 5. Mostrar el gráfico final
plt.show()

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd
from matplotlib.ticker import PercentFormatter

# (Asegúrate de que tu DataFrame 'df' ya esté cargado aquí)

# 1. Definición de los bordes de los contenedores
bin_edges = np.arange(12)

# 2. Creación del gráfico
plt.figure(figsize=(10, 6))

# Se añade stat='percent' para que el eje Y muestre porcentajes
ax = sns.histplot(data=df['nota'], bins=bin_edges, stat='percent', kde=False, color='blue')

# 3. Configuración de títulos y ejes
plt.title('Distribución de Notas de la Población (%)')
plt.xlabel('Nota')
plt.ylabel('Porcentaje (%)') # Etiqueta del eje Y actualizada
plt.xticks(bin_edges)

# 4. Bucle para añadir las etiquetas de porcentaje sobre cada barra
for p in ax.patches:
    height = p.get_height() # La altura ahora es un porcentaje
    if height > 0:
        ax.text(
            x=p.get_x() + p.get_width() / 2.,
            y=height + 0.2, # Se ajusta el offset para la nueva escala
            s=f'{height:.2f}%', # Se formatea como texto de porcentaje con 1 decimal
            ha='center'
        )

# 5. Mostrar el gráfico final
plt.show()

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd

# 1. Calcular la media y la desviación estándar
media = df['nota'].mean()
desviacion_estandar = df['nota'].std()

# 2. Definir los bordes de los contenedores
bin_edges = [
    media - 3 * desviacion_estandar,
    media - 2 * desviacion_estandar,
    media - 1 * desviacion_estandar,
    media,
    media + 1 * desviacion_estandar,
    media + 2 * desviacion_estandar,
    media + 3 * desviacion_estandar
]

# 3. Crear las etiquetas personalizadas para el eje X
#    Se usa \n para crear un salto de línea entre la etiqueta sigma y el valor
tick_labels = [
    f'μ-3σ\n({bin_edges[0]:.2f})',
    f'μ-2σ\n({bin_edges[1]:.2f})',
    f'μ-1σ\n({bin_edges[2]:.2f})',
    f'μ\n({bin_edges[3]:.2f})',
    f'μ+1σ\n({bin_edges[4]:.2f})',
    f'μ+2σ\n({bin_edges[5]:.2f})',
    f'μ+3σ\n({bin_edges[6]:.2f})'
]

# 4. Creación del gráfico
plt.figure(figsize=(12, 7))
ax = sns.histplot(data=df['nota'], bins=bin_edges, stat='percent', kde=False, color='blue')

# 5. Configuración de títulos y ejes
plt.title('Distribución de Notas por Desviación Estándar (%)')
plt.xlabel('Nota (Agrupada por Desviación Estándar)')
plt.ylabel('Porcentaje (%)')

# Se usan las nuevas etiquetas personalizadas en el eje X
plt.xticks(ticks=bin_edges, labels=tick_labels)

# 6. Bucle para añadir las etiquetas de porcentaje sobre cada barra
for p in ax.patches:
    height = p.get_height()
    if height > 0:
        ax.text(
            x=p.get_x() + p.get_width() / 2.,
            y=height + 0.2,
            s=f'{height:.2f}%',
            ha='center'
        )

# 7. Asegurar que todo el gráfico sea visible
plt.tight_layout()

# 8. Mostrar el gráfico final
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# --- 1. Definir los parámetros ---
# Media de la distribución
mu = 6.48
# Varianza de la distribución
variance = 1.03
# La desviación estándar es la raíz cuadrada de la varianza
sigma = np.sqrt(variance)

# --- 2. Preparar los datos para el gráfico ---
# Creamos un rango de valores para el eje X.
# Usamos de -4 a +4 desviaciones estándar alrededor de la media para cubrir la mayor parte de la curva.
x = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000)

# Calculamos los valores del eje Y usando la función de densidad de probabilidad (PDF) de SciPy.
y = norm.pdf(x, mu, sigma)

# --- 3. Crear el gráfico ---
# Configuramos el tamaño de la figura para que se vea bien
plt.figure(figsize=(10, 6))

# Dibujamos la curva
plt.plot(x, y, color='#007acc', linewidth=2, label=f'σ² = {variance:.2f}')

# Añadimos una línea vertical para marcar la media (μ)
plt.axvline(mu, color='red', linestyle='--', linewidth=1.5, label=f'Media (μ) = {mu}')

# --- 4. Añadir títulos y etiquetas ---
plt.title(f'Distribución Normal (μ = {mu}, σ² = {variance})', fontsize=16)
plt.xlabel('Valor', fontsize=12)
plt.ylabel('Densidad de Probabilidad', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()

# --- 5. Mostrar el gráfico ---
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# --- 1. Definir los parámetros ---
# Media de la distribución
mu = 6.48
# Varianza de la distribución
variance = 1.03
# La desviación estándar es la raíz cuadrada de la varianza
sigma = np.sqrt(variance)
x_limite = 7 # El valor de X hasta donde se sombreará el área

# --- 2. Generar datos para la curva ---
# Crear un rango de valores de X para graficar la curva completa
x = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000)
# Calcular los valores de Y (densidad de probabilidad) para cada X
y = norm.pdf(x, mu, sigma)

# --- 3. Crear la gráfica ---
fig, ax = plt.subplots(figsize=(10, 6))

# Dibujar la curva de distribución normal
ax.plot(x, y, 'b-', linewidth=2, label='Curva Normal')

# --- 4. Sombrear el área bajo la curva ---
# Definir el rango de X para el área sombreada (desde el inicio hasta x_limite)
x_fill = np.linspace(mu - 4*sigma, x_limite, 1000)
# Calcular los valores de Y correspondientes
y_fill = norm.pdf(x_fill, mu, sigma)

# Rellenar el área
ax.fill_between(x_fill, y_fill, color='skyblue', alpha=0.6, label=f'Área para X ≤ {x_limite}')

# --- 5. Añadir detalles y personalizar la gráfica ---
# Calcular la probabilidad (área sombreada)
probabilidad = norm.cdf(x_limite, mu, sigma)

# Añadir título y etiquetas
ax.set_title(f'Distribución Normal (μ={mu}, σ² = {variance})', fontsize=16)
ax.set_xlabel('Valores de X', fontsize=12)
ax.set_ylabel('Densidad de Probabilidad', fontsize=12)

# Añadir una línea vertical en X = 7
ax.axvline(x=x_limite, color='red', linestyle='--', label=f'X = {x_limite}')

# Añadir texto con el valor de la probabilidad
ax.text(mu - 3.5*sigma, max(y)*0.6, f'P(X ≤ {x_limite}) = {probabilidad:.4f}',
         fontsize=14, bbox=dict(facecolor='white', alpha=0.8))

# Añadir una leyenda y una cuadrícula
ax.legend()
ax.grid(True, linestyle='--', alpha=0.6)

# Mostrar la gráfica
plt.show()

import matplotlib.pyplot as plt
import numpy as np
import statsmodels.api as sm

# Calcular la media y la desviación estándar de la variable "nota"
media_nota = df["nota"].mean()
std_nota = df["nota"].std()

# Calcular los porcentajes reales de datos dentro de 1, 2 y 3
# desviaciones estándar
z1 = ((df["nota"] >= media_nota - std_nota) &
 (df["nota"] <= media_nota + std_nota)).mean() * 100
z2 = ((df["nota"] >= media_nota - 2 * std_nota) &
 (df["nota"] <= media_nota + 2 * std_nota)).mean() * 100
z3 = ((df["nota"] >= media_nota - 3 * std_nota) &
 (df["nota"] <= media_nota + 3 * std_nota)).mean() * 100

# Crear los datos de la densidad
kde = sm.nonparametric.KDEUnivariate(df["nota"])
kde.fit()
x_kde = kde.support
y_kde = kde.density

# Crear el gráfico de densidad
plt.figure(figsize=(10, 5))
plt.fill_between(x_kde, y_kde, color="blue", alpha=0.3)

def shade_region(start, end, color):
    mask = (x_kde >= start) & (x_kde <= end)
    plt.fill_between(x_kde[mask], y_kde[mask], color=color, alpha=0.5)

# Sombrear las áreas correspondientes
shade_region(media_nota - std_nota, media_nota + std_nota, "blue")  # 1σ
shade_region(media_nota - 2 * std_nota, media_nota - std_nota, "red")
shade_region(media_nota + std_nota, media_nota + 2 * std_nota, "red")  # 2σ
shade_region(media_nota - 3 * std_nota, media_nota - 2 * std_nota, "skyblue")
shade_region(media_nota + 2 * std_nota, media_nota + 3 * std_nota, "skyblue")  # 3σ

# Marcar la media y las desviaciones estándar
for i in range(-3, 4):
    valor = media_nota + i * std_nota
    etiqueta = "$\\mu$" if i == 0 else f"$\\mu {'+' if i > 0 else '-'} {abs(i)}\\sigma$"
    plt.axvline(valor, color="black", linestyle="--", alpha=0.7)
    plt.text(valor, plt.ylim()[1] * 0.05,
             etiqueta,
             horizontalalignment='center',
             color="black")

# Agregar los valores de calificación z debajo del eje x
ticks_x = [media_nota + i * std_nota for i in range(-3, 4)]
labels_x = [f"{tick:.2f}\n(z={i})" for i, tick in zip(range(-3, 4), ticks_x)]
plt.xticks(ticks_x, labels_x)

# Agregar porcentajes reales en la parte superior
plt.text(media_nota, plt.ylim()[1] * 0.5, f"{z1:.2f}%",
         horizontalalignment='center', fontsize=12, color="blue")
plt.text(media_nota, plt.ylim()[1] * 0.6, f"{z2:.2f}%",
         horizontalalignment='center', fontsize=12, color="red")
plt.text(media_nota, plt.ylim()[1] * 0.7, f"{z3:.2f}%",
         horizontalalignment='center', fontsize=12, color="skyblue")

# Etiquetas y título
plt.xlabel("Nota")
plt.ylabel("Densidad")
plt.title("Distribución de Notas con Calificación Z")
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# --- 1. Definir los parámetros ---
# Media de la distribución
mu = 6.48
# Varianza de la distribución
variance = 1.03
# La desviación estándar es la raíz cuadrada de la varianza
sigma = np.sqrt(variance)

# Límites para la integración y el sombreado
x1 = 5.46
x2 = 7.49

# --- 2. Calcular la probabilidad (Integral) ---
# La probabilidad P(x1 < X < x2) es la diferencia de las funciones de distribución acumulada (CDF)
probabilidad = norm.cdf(x2, mu, sigma) - norm.cdf(x1, mu, sigma)
print(f"El valor de la integral entre {x1} y {x2} es: {probabilidad:.4f}")


# --- 3. Generar datos para la curva ---
# Crear un rango de valores de X para graficar la curva completa
x_curve = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000)
# Calcular los valores de Y (densidad de probabilidad) para cada X
y_curve = norm.pdf(x_curve, mu, sigma)


# --- 4. Crear la gráfica ---
fig, ax = plt.subplots(figsize=(12, 7))

# Dibujar la curva de distribución normal
ax.plot(x_curve, y_curve, 'b-', linewidth=2, label='Curva Normal')

# --- 5. Sombrear el área bajo la curva entre x1 y x2 ---
# Definir el rango de X para el área sombreada
x_fill = np.linspace(x1, x2, 1000)
# Calcular los valores de Y correspondientes
y_fill = norm.pdf(x_fill, mu, sigma)

# Rellenar el área
ax.fill_between(x_fill, y_fill, color='skyblue', alpha=0.7, label=f'Área entre {x1} y {x2}')

# --- 6. Añadir detalles y personalizar la gráfica ---
# Añadir título y etiquetas
ax.set_title(f'Distribución Normal (μ={mu}, σ²={variance})', fontsize=16)
ax.set_xlabel('Valores de X', fontsize=12)
ax.set_ylabel('Densidad de Probabilidad', fontsize=12)

# Añadir líneas verticales en los límites de la integral
ax.axvline(x=x1, color='red', linestyle='--', label=f'Límite inferior: {x1}')
ax.axvline(x=x2, color='green', linestyle='--', label=f'Límite superior: {x2}')

# Añadir texto con el valor de la probabilidad
ax.text(x_curve.min(), max(y_curve)*0.7, f'P({x1} ≤ X ≤ {x2}) = {probabilidad:.4f}',
         fontsize=14, bbox=dict(facecolor='white', alpha=0.9))

# Añadir una leyenda y una cuadrícula
ax.legend()
ax.grid(True, linestyle='--', alpha=0.6)

# Guardar y mostrar la gráfica
plt.savefig("distribucion_normal_area.png")
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Generar datos con distribución exponencial y luego invertirlos para sesgo a la izquierda
data_sesgada_izquierda = -np.random.exponential(scale=1, size=1000)

# Calcular la media (eje de simetría)
media = np.mean(data_sesgada_izquierda)

# Crear el histograma con Seaborn
plt.figure(figsize=(10, 6))
sns.histplot(data_sesgada_izquierda, bins=30, kde=True, color='blue', edgecolor='black')

# Añadir el eje de simetría
plt.axvline(media, color='red', linestyle='--', linewidth=2, label=f'Eje de Simetría (Media): {media:.2f}')

plt.title('Histograma de Datos Sesgados a la Izquierda (Asimetría Negativa)')
plt.xlabel('Valor')
plt.ylabel('Frecuencia')
plt.legend()
plt.grid(True)
plt.savefig('histograma_con_simetria.png')

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Generar datos con distribución exponencial (sesgada a la derecha)
data_sesgada = np.random.exponential(scale=1, size=1000)

# Calcular la media (eje de simetría)
media = np.mean(data_sesgada)

# Crear el histograma con Seaborn
plt.figure(figsize=(10, 6))
sns.histplot(data_sesgada, bins=30, kde=True, color='green', edgecolor='black')

# Añadir el eje de simetría
plt.axvline(media, color='red', linestyle='--', linewidth=2, label=f'Eje de Simetría (Media): {media:.2f}')

plt.title('Histograma de Datos Sesgados a la Derecha (Asimetría Positiva)')
plt.xlabel('Valor')
plt.ylabel('Frecuencia')
plt.legend()
plt.grid(True)
plt.savefig('histograma_derecha_con_simetria.png')

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import kurtosis, norm

# Set a seed for reproducibility
np.random.seed(123)

# --- Creación de una distribución Platicúrtica desde Normales ---
# 1. Generamos la primera mitad de los datos de una normal centrada a la izquierda.
#    Usamos una desviación estándar más pequeña para tener colas más delgadas.
data_left = np.random.normal(loc=-1, scale=0.7, size=5000)

# 2. Generamos la segunda mitad de los datos de una normal centrada a la derecha.
data_right = np.random.normal(loc=1, scale=0.7, size=5000)

# 3. Combinamos ambos conjuntos de datos. La superposición creará una cima plana.
platykurtic_data = np.concatenate([data_left, data_right])

# Calculate the excess kurtosis (Fisher's definition, where normal = 0)
# El resultado debería ser < 0
calculated_kurtosis = kurtosis(platykurtic_data, fisher=True)

# --- Visualization ---
plt.figure(figsize=(12, 7))

# Create the plot using seaborn
sns.histplot(platykurtic_data, kde=True, bins=50, color='royalblue', stat='density', label='Distribución Empírica (Mezcla)')

# For comparison, overlay the PDF of a standard normal distribution
# Ajustamos la media y desviación de la normal de comparación a nuestros datos
# para una comparación más justa.
mean_data = np.mean(platykurtic_data)
std_data = np.std(platykurtic_data)
x_norm = np.linspace(np.min(platykurtic_data), np.max(platykurtic_data), 200)
plt.plot(x_norm, norm.pdf(x_norm, mean_data, std_data), 'r--', lw=2, alpha=0.8, label='PDF Teórica Normal (Mesocúrtica)')


# Add titles and labels
plt.title(f'Distribución Platicúrtica (Mezcla de Normales)\nCurtosis Calculada: {calculated_kurtosis:.2f}', fontsize=16)
plt.xlabel('Valor', fontsize=12)
plt.ylabel('Densidad', fontsize=12)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)
plt.xlim(np.min(platykurtic_data), np.max(platykurtic_data)) # Adjust x-axis to fit all data

# Show the plot
plt.show()

# Print the calculated kurtosis to the console
print(f"La curtosis calculada de los datos es: {calculated_kurtosis}")

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import kurtosis, norm

# Set a seed for reproducibility
np.random.seed(202)

# Generate data from a Normal distribution (loc=mean, scale=std_dev)
# The normal distribution is the baseline for kurtosis, so it's mesokurtic.
mesokurtic_data = np.random.normal(loc=0, scale=1, size=10000)

# Calculate the excess kurtosis (Fisher's definition, where normal = 0)
# For a perfect normal distribution, this value is 0.
calculated_kurtosis = kurtosis(mesokurtic_data, fisher=True)

# --- Visualization ---
plt.figure(figsize=(12, 7))

# Create the plot using seaborn
sns.histplot(mesokurtic_data, kde=True, bins=30, color='teal', stat='density', label='Distribución Empírica')

# Overlay the theoretical probability density function (PDF) of a standard normal distribution
x = np.linspace(norm.ppf(0.001), norm.ppf(0.999), 100)
plt.plot(x, norm.pdf(x, 0, 1), 'r-', lw=2, alpha=0.8, label='PDF Teórica Normal(0,1)')

# Add titles and labels
plt.title(f'Distribución Mesocúrtica (Normal)\nCurtosis Calculada: {calculated_kurtosis:.2f}', fontsize=16)
plt.xlabel('Valor', fontsize=12)
plt.ylabel('Densidad', fontsize=12)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)

# Show the plot
plt.show()

# Print the calculated kurtosis to the console
print(f"La curtosis calculada de los datos es: {calculated_kurtosis}")

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import kurtosis, norm

# Set a seed for reproducibility
np.random.seed(42)

# --- Creación de una distribución Leptocúrtica desde Normales ---
# 1. Generamos la mayoría de los datos (90%) de una distribución normal estándar.
data_normal_base = np.random.normal(loc=0, scale=1, size=9000)

# 2. Generamos una minoría de datos (10%) de una normal con mucha más dispersión (colas pesadas).
data_outliers = np.random.normal(loc=0, scale=5, size=1000)

# 3. Combinamos ambos conjuntos de datos.
leptokurtic_data = np.concatenate([data_normal_base, data_outliers])

# Calculate the excess kurtosis (Fisher's definition, where normal = 0)
# El resultado debería ser > 0
calculated_kurtosis = kurtosis(leptokurtic_data, fisher=True)

# --- Visualization ---
plt.figure(figsize=(12, 7))

# Create the plot using seaborn
sns.histplot(leptokurtic_data, kde=True, bins=50, color='darkred', stat='density', label='Distribución Empírica (Mezcla)')

# For comparison, overlay the PDF of a standard normal distribution
x_norm = np.linspace(norm.ppf(0.001), norm.ppf(0.999), 100)
plt.plot(x_norm, norm.pdf(x_norm, 0, 1), 'b--', lw=2, alpha=0.8, label='PDF Teórica Normal (Mesocúrtica)')


# Add titles and labels
plt.title(f'Distribución Leptocúrtica (Mezcla de Normales)\nCurtosis Calculada: {calculated_kurtosis:.2f}', fontsize=16)
plt.xlabel('Valor', fontsize=12)
plt.ylabel('Densidad', fontsize=12)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)
plt.xlim(np.min(leptokurtic_data), np.max(leptokurtic_data)) # Adjust x-axis to fit all data

# Show the plot
plt.show()

# Print the calculated kurtosis to the console
print(f"La curtosis calculada de los datos es: {calculated_kurtosis}")