statslibx 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

{statslib → statslibx}/utils.py

@@ -823,67 +823,366 @@ class UtilsStats:
 
     def help(self):
         """
-        Muestra ayuda completa de la clase UtilsStats
+        Muestra ayuda completa de la clase DescriptiveStats
         """
         help_text = """
-            📊 CLASE UtilsStats - AYUDA COMPLETA
+╔════════════════════════════════════════════════════════════════════════════╗
+║                    📊 CLASE UtilsStats - AYUDA COMPLETA                    ║
+╚════════════════════════════════════════════════════════════════════════════╝
 
-            Clase utilitaria para análisis estadísticos y visualización de datos.
+📝 DESCRIPCIÓN:
+   Clase para análisis estadístico descriptivo univariado y multivariado.
+   Proporciona herramientas para análisis exploratorio de datos, medidas de
+   tendencia central, dispersión, forma de distribución y regresión lineal.
 
-            🔧 MÉTODOS PRINCIPALES:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-            1. 📈 ANÁLISIS ESTADÍSTICO:
-            • check_normality()           # Test de normalidad
-            • calculate_confidence_intervals()  # Intervalos de confianza
-            • detect_outliers()           # Detección de outliers
-            • calculate_effect_size()     # Tamaño del efecto
-            • get_descriptive_stats()     # Estadísticas descriptivas
+📋 MÉTODOS PRINCIPALES:
 
-            2. 🎨 VISUALIZACIÓN:
-            • plot_distribution()         # Gráficos de distribución
-            • plot_distribution_with_ci() # Distribución con IC
-            • plot_multiple_distributions_with_ci() # Múltiples distribuciones
-            • plot_correlation_matrix()   # Matriz de correlación
-            • plot_scatter_matrix()       # Matriz de dispersión
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 1. 📊 ANÁLISIS ESTADÍSTICO                                                 │
+└────────────────────────────────────────────────────────────────────────────┘
 
-            3. ⚙️ CONFIGURACIÓN:
-            • set_plot_backend()          # Backend de visualización
-            • set_default_figsize()       # Tamaño de figura
-            • set_save_fig_options()      # Opciones para guardar
+  • .check_normality(data, alpha=0.05)
+    Verifica normalidad usando test Shapiro-Wilk
+    Retorna: dict con estadístico, p-value e interpretación
 
-            4. 🛠️ UTILIDADES:
-            • validate_dataframe()        # Validación de datos
-            • format_number()             # Formateo de números
+  • .calculate_confidence_intervals(data, confidence_level=0.95, 
+                                   method='parametric')
+    Calcula intervalos de confianza para la media
+    Métodos: 'parametric' o 'bootstrap'
 
-            💡 EJEMPLOS DE USO:
+  • .detect_outliers(data, method='iqr', **kwargs)
+    Detecta valores atípicos
+    Métodos: 'iqr', 'zscore', 'isolation_forest'
 
-            # Inicializar
-            utils = UtilsStats()
+  • .calculate_effect_size(group1, group2, method='cohen')
+    Calcula tamaño del efecto entre grupos
+    Métodos: 'cohen' (Cohen's d) o 'hedges' (Hedges' g)
 
-            # Análisis de normalidad
-            normalidad = utils.check_normality(mis_datos)
+  • .get_descriptive_stats(data, column=None)
+    Estadísticas descriptivas completas en un dict
 
-            # Gráfico con intervalos de confianza
-            fig = utils.plot_distribution_with_ci(
-                data=mis_datos,
-                confidence_level=0.95,
-                bins=20
-            )
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 2. 🎨 VISUALIZACIÓN DE DISTRIBUCIONES                                      │
+└────────────────────────────────────────────────────────────────────────────┘
 
-            # Matriz de correlación
-            fig_corr = utils.plot_correlation_matrix(
-                data=mi_dataframe,
-                method='pearson'
-            )
+  • .plot_distribution(data, column=None, plot_type='hist', 
+                      backend='seaborn', bins=30, figsize=None, 
+                      save_fig=None, filename=None)
+    
+    Grafica distribución de una variable
+    
+    plot_type: 'hist', 'kde', 'box', 'violin', 'all'
+    backend: 'matplotlib', 'seaborn', 'plotly'
+
+  • .plot_distribution_with_ci(data, column=None, confidence_level=0.95,
+                               ci_method='parametric', bins=30)
+    
+    Distribución con intervalos de confianza visualizados
+
+  • .plot_multiple_distributions_with_ci(data_dict, confidence_level=0.95)
+    
+    Compara múltiples distribuciones con sus IC
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 3. 🎨 VISUALIZACIÓN MULTIVARIADA                                           │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .plot_correlation_matrix(data, method='pearson', backend='seaborn',
+                            figsize=None, save_fig=None)
+    
+    Matriz de correlación con heatmap
+    Métodos: 'pearson', 'spearman', 'kendall'
+
+  • .plot_scatter_matrix(data, columns=None, backend='seaborn',
+                        figsize=None, save_fig=None)
+    
+    Matriz de gráficos de dispersión (pairplot)
+    Backends: 'seaborn', 'plotly', 'pandas'
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 4. ⚙️  CONFIGURACIÓN                                                       │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .set_plot_backend(backend)
+    Establece backend por defecto: 'matplotlib', 'seaborn', 'plotly'
+
+  • .set_default_figsize(figsize)
+    Establece tamaño de figura por defecto: (ancho, alto)
+
+  • .set_save_fig_options(save_fig=False, fig_format='png', 
+                         fig_dpi=300, figures_dir='figures')
+    
+    Configura guardado automático de figuras
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 5. 🛠️  UTILIDADES                                                          │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .validate_dataframe(data)
+    Valida y convierte datos a DataFrame
+
+  • .format_number(num, decimals=6, scientific=False)
+    Formatea números con precisión específica
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 EJEMPLOS DE USO:
 
-            # Estadísticas descriptivas
-            stats = utils.get_descriptive_stats(mis_datos)
+  ┌─ Ejemplo 1: Configuración Inicial ──────────────────────────────────────┐
+  │ from utils import UtilsStats                                            │
+  │ import pandas as pd                                                      │
+  │ import numpy as np                                                       │
+  │                                                                          │
+  │ # Inicializar                                                            │
+  │ utils = UtilsStats()                                                    │
+  │                                                                          │
+  │ # Configurar visualización                                               │
+  │ utils.set_plot_backend('seaborn')                                       │
+  │ utils.set_default_figsize((12, 6))                                      │
+  │                                                                          │
+  │ # Configurar guardado automático                                         │
+  │ utils.set_save_fig_options(                                             │
+  │     save_fig=True,                                                      │
+  │     fig_format='png',                                                   │
+  │     fig_dpi=300,                                                        │
+  │     figures_dir='mis_graficos'                                          │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
 
-            🎯 CARACTERÍSTICAS:
-            • Múltiples backends: matplotlib, seaborn, plotly
-            • Guardado automático de figuras
-            • Manejo robusto de datos faltantes
-            • Visualizaciones profesionales listas para publicación
-            • Integración perfecta con Jupyter notebooks
-            """
+  ┌─ Ejemplo 2: Análisis de Normalidad ─────────────────────────────────────┐
+  │ # Generar datos                                                          │
+  │ datos_normales = np.random.normal(0, 1, 1000)                           │
+  │ datos_no_normales = np.random.exponential(2, 1000)                      │
+  │                                                                          │
+  │ # Test de normalidad                                                     │
+  │ resultado1 = utils.check_normality(datos_normales)                      │
+  │ print(f"Normales: {resultado1['interpretation']}")                      │
+  │ print(f"p-value: {resultado1['shapiro_pvalue']:.4f}")                   │
+  │                                                                          │
+  │ resultado2 = utils.check_normality(datos_no_normales)                   │
+  │ print(f"No normales: {resultado2['interpretation']}")                   │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 3: Intervalos de Confianza ────────────────────────────────────┐
+  │ # Método paramétrico                                                     │
+  │ ci_param = utils.calculate_confidence_intervals(                        │
+  │     datos_normales,                                                     │
+  │     confidence_level=0.95,                                              │
+  │     method='parametric'                                                 │
+  │ )                                                                        │
+  │                                                                          │
+  │ print(f"Media: {ci_param['mean']:.3f}")                                 │
+  │ print(f"IC 95%: [{ci_param['ci_lower']:.3f}, "                          │
+  │       f"{ci_param['ci_upper']:.3f}]")                                   │
+  │                                                                          │
+  │ # Método bootstrap (para datos no normales)                              │
+  │ ci_boot = utils.calculate_confidence_intervals(                         │
+  │     datos_no_normales,                                                  │
+  │     confidence_level=0.95,                                              │
+  │     method='bootstrap'                                                  │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 4: Detección de Outliers ──────────────────────────────────────┐
+  │ # Método IQR (rango intercuartílico)                                     │
+  │ datos = np.random.normal(100, 15, 1000)                                 │
+  │ datos = np.append(datos, [200, 210, -50])  # Agregar outliers           │
+  │                                                                          │
+  │ outliers_iqr = utils.detect_outliers(datos, method='iqr')               │
+  │ print(f"Outliers IQR: {outliers_iqr.sum()}")                            │
+  │                                                                          │
+  │ # Método Z-score                                                         │
+  │ outliers_z = utils.detect_outliers(                                     │
+  │     datos,                                                              │
+  │     method='zscore',                                                    │
+  │     threshold=3                                                         │
+  │ )                                                                        │
+  │ print(f"Outliers Z-score: {outliers_z.sum()}")                          │
+  │                                                                          │
+  │ # Isolation Forest (machine learning)                                    │
+  │ outliers_if = utils.detect_outliers(                                    │
+  │     datos,                                                              │
+  │     method='isolation_forest',                                          │
+  │     contamination=0.05                                                  │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 5: Tamaño del Efecto ──────────────────────────────────────────┐
+  │ # Comparar dos grupos                                                    │
+  │ grupo_control = np.random.normal(100, 15, 100)                          │
+  │ grupo_tratamiento = np.random.normal(110, 15, 100)                      │
+  │                                                                          │
+  │ efecto = utils.calculate_effect_size(                                   │
+  │     grupo_control,                                                      │
+  │     grupo_tratamiento,                                                  │
+  │     method='cohen'                                                      │
+  │ )                                                                        │
+  │                                                                          │
+  │ print(f"Cohen's d: {efecto['effect_size']:.3f}")                        │
+  │ print(f"Interpretación: {efecto['interpretation']}")                    │
+  │ print(f"Diferencia de medias: {efecto['mean_diff']:.2f}")               │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 6: Gráficos de Distribución ───────────────────────────────────┐
+  │ df = pd.DataFrame({                                                      │
+  │     'edad': np.random.normal(35, 10, 500),                              │
+  │     'salario': np.random.lognormal(10.5, 0.5, 500)                      │
+  │ })                                                                       │
+  │                                                                          │
+  │ # Histograma simple                                                      │
+  │ fig1 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     plot_type='hist',                                                   │
+  │     bins=30                                                             │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Panel completo (histograma, box, violin, Q-Q)                          │
+  │ fig2 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='salario',                                                   │
+  │     plot_type='all',                                                    │
+  │     backend='seaborn'                                                   │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly (interactivo)                                               │
+  │ fig3 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     plot_type='violin',                                                 │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 7: Distribución con Intervalos de Confianza ───────────────────┐
+  │ # Visualizar distribución con IC                                         │
+  │ fig = utils.plot_distribution_with_ci(                                  │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     confidence_level=0.95,                                              │
+  │     ci_method='parametric',                                             │
+  │     bins=30,                                                            │
+  │     save_fig=True,                                                      │
+  │     filename='edad_con_ic'                                              │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Comparar múltiples distribuciones                                      │
+  │ data_dict = {                                                            │
+  │     'Grupo A': df['edad'][:200],                                        │
+  │     'Grupo B': df['edad'][200:400],                                     │
+  │     'Grupo C': df['edad'][400:]                                         │
+  │ }                                                                        │
+  │                                                                          │
+  │ fig = utils.plot_multiple_distributions_with_ci(                        │
+  │     data_dict,                                                          │
+  │     confidence_level=0.95                                               │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 8: Matriz de Correlación ──────────────────────────────────────┐
+  │ # Crear datos correlacionados                                            │
+  │ df = pd.DataFrame({                                                      │
+  │     'A': np.random.normal(0, 1, 100),                                   │
+  │     'B': np.random.normal(0, 1, 100),                                   │
+  │     'C': np.random.normal(0, 1, 100)                                    │
+  │ })                                                                       │
+  │ df['D'] = df['A'] * 0.8 + np.random.normal(0, 0.2, 100)                │
+  │                                                                          │
+  │ # Matriz de correlación con seaborn                                      │
+  │ fig = utils.plot_correlation_matrix(                                    │
+  │     df,                                                                 │
+  │     method='pearson',                                                   │
+  │     backend='seaborn',                                                  │
+  │     figsize=(10, 8)                                                     │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly (interactiva)                                               │
+  │ fig = utils.plot_correlation_matrix(                                    │
+  │     df,                                                                 │
+  │     method='spearman',                                                  │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 9: Matriz de Dispersión ───────────────────────────────────────┐
+  │ # Pairplot completo                                                      │
+  │ fig = utils.plot_scatter_matrix(                                        │
+  │     df,                                                                 │
+  │     columns=['A', 'B', 'C', 'D'],                                       │
+  │     backend='seaborn'                                                   │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly                                                             │
+  │ fig = utils.plot_scatter_matrix(                                        │
+  │     df,                                                                 │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 10: Estadísticas Descriptivas Completas ───────────────────────┐
+  │ # Obtener todas las estadísticas                                         │
+  │ stats = utils.get_descriptive_stats(df, column='edad')                  │
+  │                                                                          │
+  │ print(f"Media: {stats['mean']:.2f}")                                    │
+  │ print(f"Mediana: {stats['median']:.2f}")                                │
+  │ print(f"Desv. Est.: {stats['std']:.2f}")                                │
+  │ print(f"IQR: {stats['iqr']:.2f}")                                       │
+  │ print(f"Asimetría: {stats['skewness']:.3f}")                            │
+  │ print(f"Curtosis: {stats['kurtosis']:.3f}")                             │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 CARACTERÍSTICAS CLAVE:
+
+  ✓ Múltiples backends de visualización (matplotlib, seaborn, plotly)
+  ✓ Guardado automático de figuras en alta resolución
+  ✓ Análisis estadísticos robustos
+  ✓ Detección de outliers con 3 métodos
+  ✓ Intervalos de confianza paramétricos y bootstrap
+  ✓ Visualizaciones profesionales listas para publicación
+  ✓ Manejo automático de valores faltantes
+  ✓ Integración perfecta con pandas y numpy
+  ✓ Gráficos interactivos con Plotly
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 BACKENDS DE VISUALIZACIÓN:
+
+  🔹 Matplotlib:
+     • Rápido y ligero
+     • Ideal para gráficos simples
+     • Mejor para exportar a archivos
+
+  🔹 Seaborn:
+     • Gráficos estadísticos elegantes
+     • Temas predefinidos atractivos
+     • Mejor para análisis exploratorio
+
+  🔹 Plotly:
+     • Gráficos interactivos
+     • Zoom, pan, hover tooltips
+     • Ideal para presentaciones y dashboards
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 CONSEJOS Y MEJORES PRÁCTICAS:
+
+  1. Siempre verificar normalidad antes de usar métodos paramétricos
+  2. Usar bootstrap para IC cuando los datos no son normales
+  3. Detectar outliers antes de calcular estadísticas
+  4. Guardar figuras en alta resolución (300 DPI) para publicaciones
+  5. Usar Plotly para presentaciones interactivas
+  6. Usar seaborn para análisis exploratorio rápido
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 DOCUMENTACIÓN ADICIONAL:
+   Para más información sobre métodos específicos, use:
+   help(UtilsStats.nombre_metodo)
+
+╚════════════════════════════════════════════════════════════════════════════╝
+    """
         print(help_text)

{statslibx-0.1.0.dist-info → statslibx-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statslibx
-Version: 0.1.0
+Version: 0.1.1
 Summary: Librería de estadística descriptiva e inferencial para Python
 Home-page: https://github.com/Immanuel3008/StatsLibrary
 Author: Emmanuel Ascendra Perez

statslibx-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+statslibx/__init__.py,sha256=p1AydN8u_zWgm1rJBJb8TVQkRUzQMA3iNDwfFZn8k00,1117
+statslibx/descriptive.py,sha256=Hu7VuOGXs6oOq-zxQNiBKg7UtkNdNQ1Qy3PP-wEO5_k,36971
+statslibx/inferential.py,sha256=slLh32Ny4doLA0EA8pYRUGQSuMI8oBUCMBu-CTX-7FY,41732
+statslibx/utils.py,sha256=vnfs5LmWEKsB9p8Fs2Di3btReepkB1RYAwQfT-eZs6c,61856
+statslibx-0.1.1.dist-info/METADATA,sha256=ujX3UiJWx5ibgNv7OaJevK5YYeIaxudPkKzlFWBChO0,1737
+statslibx-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+statslibx-0.1.1.dist-info/top_level.txt,sha256=eeYZXyFm0hIjuI0ba3wF6XW938Mv9tv7Nk9qgjYfCtU,10
+statslibx-0.1.1.dist-info/RECORD,,

statslibx-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+statslibx