Todos los datasets están empaquetados dentro de statslibx.datasets. Se cargan automáticamente sin necesidad de rutas locales.
El clásico dataset de Fisher. Medidas de sépalos y pétalos de 3 especies de iris (setosa, versicolor, virginica). Ideal para análisis descriptivo y clasificación.
load_iris()Medidas de pingüinos Palmer de 3 especies (Adelie, Chinstrap, Gentoo). Alternativa moderna al iris con datos reales de campo y valores nulos.
load_penguins()Pasajeros del Titanic con variable de supervivencia. Ideal para Chi-cuadrado, análisis categórico, regresión logística y exploración de datos faltantes.
load_dataset("titanic.csv")Información de las empresas del índice S&P 500: sector, capitalización de mercado, ingresos y más. Ideal para análisis financiero y agrupamiento.
load_dataset("sp500_companies.csv")Datos de completitud de cursos en línea. Útil para análisis de comportamiento educativo, tasas de abandono y estudios de retención.
load_dataset("course_completion.csv")Inversiones en Nigeria y Ghana entre 1980 y 2023. Datos financieros reales en formato Excel. Perfecto para series temporales y análisis económico.
load_dataset("Cocoa...xlsx")Carga el dataset Iris directamente. Con return_X_y retorna arrays numpy (X, y) listos para machine learning, donde el primer elemento de la tupla es la lista de columnas predictoras y el segundo la columna objetivo.
| Parámetro | Tipo | Default | Descripción |
|---|---|---|---|
| backend | str | 'pandas' | Backend de DataFrame. Actualmente solo 'pandas' soportado. |
| return_X_y | Tuple | None | None | Si se especifica, retorna (X, y) como arrays numpy. Formato: ([col1, col2, ...], 'col_target') |
from statslibx.datasets import load_iris
# Como DataFrame
df = load_iris()
print(df.shape) # (150, 5)
print(df.columns.tolist())
# ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']
# Como arrays numpy (X, y) para ML
X, y = load_iris(
return_X_y=(
['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
'species'
)
)
print(X.shape) # (150, 4)
print(y.shape) # (150,)
print(y[:5]) # ['setosa' 'setosa' 'setosa' ...]Carga el dataset Palmer Penguins. Este dataset contiene valores nulos en algunas columnas, lo que lo hace ideal para practicar preprocesamiento antes del análisis.
from statslibx.datasets import load_penguins
df = load_penguins()
print(df.head())
print(df.dtypes)
# Con return_X_y
X, y = load_penguins(
return_X_y=(
['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm'],
'species'
)
)Función genérica para cargar cualquier dataset por nombre. Primero busca en el paquete interno statslibx.datasets; si no lo encuentra, intenta cargarlo como ruta local. Soporta múltiples formatos de archivo detectados automáticamente por extensión.
| Parámetro | Tipo | Default | Descripción |
|---|---|---|---|
| name | str | — | Nombre del dataset interno (ej: "iris.csv") o ruta local completa. |
| backend | str | 'pandas' | Backend de procesamiento. Solo 'pandas' disponible actualmente. |
| return_X_y | Tuple | None | None | Si se especifica, retorna (X, y). Formato: ([col1, col2], 'target') |
| sep | str | ',' | Separador de columnas para archivos CSV. Ej: ';' para CSV europeo. |
Formatos soportados:
| Extensión | Formato | Función interna |
|---|---|---|
| .csv | CSV con separador configurable | pd.read_csv() |
| .parquet | Formato columnar Apache Parquet | pd.read_parquet() |
| .xlsx / .xls | Libro de Excel | pd.read_excel() |
| .json | JSON plano compatible con pandas | pd.read_json() |
from statslibx.datasets import load_dataset
# Datasets internos del paquete
df_titanic = load_dataset("titanic.csv")
df_penguins = load_dataset("penguins.csv")
df_sp500 = load_dataset("sp500_companies.csv")
df_cocoa = load_dataset("Cocoa_Bubbles_Investment_Nigeria_Ghana_1980_2023.xlsx")
# Archivo local externo (CSV con separador punto y coma)
df_local = load_dataset("mis_datos/ventas_2024.csv", sep=";")
# Retornar (X, y) como arrays numpy
X, y = load_dataset(
"titanic.csv",
return_X_y=(['pclass', 'age', 'fare'], 'survived')
)
print(X.shape) # (891, 3)
print(y.shape) # (891,)load_dataset() intenta cargarlo como ruta del sistema de archivos local. Si tampoco existe localmente, lanza FileNotFoundError con mensaje descriptivo.
Genera un DataFrame sintético con la cantidad de filas y esquema de columnas especificado. Cada columna se define con una distribución estadística y tipo de datos. El resultado es reproducible con seed. Si save=True y se provee filename, guarda el resultado como CSV; de lo contrario guarda como dataset.csv.
| Parámetro | Tipo | Default | Descripción |
|---|---|---|---|
| n_rows | int | — | Número de filas a generar (requerido). |
| schema | dict | — | Diccionario donde cada clave es un nombre de columna y el valor es su configuración de distribución (requerido). |
| seed | int | None | None | Semilla de aleatoriedad. Si es None usa 42 por defecto. Debe ser entero. |
| save | bool | False | Si True, guarda el DataFrame como CSV en disco. |
| filename | str | None | None | Nombre del archivo sin extensión. Si save=True y filename=None, guarda como dataset.csv. |
from statslibx.datasets import generate_dataset
schema = {
'edad': {'dist': 'normal', 'mean': 35, 'std': 10, 'type': 'int'},
'salario': {'dist': 'lognormal', 'mean': 10.5, 'std': 0.5, 'type': 'float', 'round': 2},
'experiencia': {'dist': 'exponential', 'scale': 5, 'type': 'float', 'round': 1},
}
df = generate_dataset(n_rows=200, schema=schema, seed=42)
print(df.head())
print(df.describe())Cada columna del schema es un diccionario con las siguientes claves:
| Clave | Tipo | Requerido | Descripción |
|---|---|---|---|
| dist | str | Sí | Distribución estadística. Ver tabla de distribuciones abajo. |
| type | str | No | 'int' o 'float'. Default: 'float'. Para 'categorical' no aplica. |
| round | int | No | Decimales de redondeo. Default: 2 (o 0 si type='int'). |
| choices | list | Condicional | Requerido solo para dist='categorical'. Lista de valores posibles. |
Cada distribución tiene sus propios parámetros de configuración. Los valores entre paréntesis son los defaults.
'normal'
mean: Media μ (def: 0)
std: Desviación estándar σ (def: 1)
type: 'float' | 'int'
'uniform'
low: Límite inferior (def: 0)
high: Límite superior (def: 1)
type: 'float' | 'int'
'exponential'
scale: Parámetro β = 1/λ (def: 1)
type: 'float' | 'int'
'lognormal'
mean: Media del logaritmo μ (def: 0)
std: Desv. estándar log σ (def: 1)
Ideal para salarios y precios.
'poisson'
lam: Lambda λ — tasa esperada de eventos (def: 1)
Siempre genera enteros.
'binomial'
n: Número de ensayos (def: 1)
p: Probabilidad de éxito (def: 0.5)
Con n=1 genera 0s y 1s.
'categorical'
choices: Lista de categorías (requerido)
Selección uniforme aleatoria.
No usa type ni round.
Ejemplo que usa las 7 distribuciones disponibles para generar un dataset realista de recursos humanos.
from statslibx.datasets import generate_dataset
from statslibx import DescriptiveStats, Preprocessing
schema = {
# Distribución normal → edad de empleados
'edad': {
'dist': 'normal',
'mean': 35, 'std': 10,
'type': 'int', 'round': 0
},
# Distribución log-normal → salarios (siempre positivos, sesgo derecho)
'salario': {
'dist': 'lognormal',
'mean': 10.5, 'std': 0.5,
'type': 'float', 'round': 2
},
# Distribución exponencial → años de experiencia
'experiencia_anos': {
'dist': 'exponential',
'scale': 6,
'type': 'float', 'round': 1
},
# Distribución uniforme → calificación de desempeño (1.0 a 5.0)
'calificacion': {
'dist': 'uniform',
'low': 1.0, 'high': 5.0,
'type': 'float', 'round': 1
},
# Distribución Poisson → número de proyectos completados
'proyectos_completados': {
'dist': 'poisson',
'lam': 8,
'type': 'int'
},
# Distribución binomial (n=1) → variable binaria activo/inactivo
'activo': {
'dist': 'binomial',
'n': 1, 'p': 0.88,
'type': 'int'
},
# Distribución categórica → departamento
'departamento': {
'dist': 'categorical',
'choices': ['Marketing', 'Ventas', 'IT', 'RRHH', 'Finanzas', 'Operaciones']
},
# Distribución categórica → nivel de educación
'educacion': {
'dist': 'categorical',
'choices': ['Bachiller', 'Tecnico', 'Universitario', 'Magister', 'Doctorado']
}
}
# Generar dataset reproducible de 1000 empleados
df = generate_dataset(
n_rows=1000,
schema=schema,
seed=42,
save=True,
filename="empleados_rrhh"
)
print(f"Shape: {df.shape}")
print(df.dtypes)
print(df.head())
# Análisis inmediato con DescriptiveStats
ds = DescriptiveStats(df)
print(ds.summary())
# Revisar calidad con Preprocessing
pp = Preprocessing(df)
print(pp.data_quality())from statslibx.datasets import generate_dataset, load_dataset
# 1. Generar y guardar
schema_ml = {
'feature_1': {'dist': 'normal', 'mean': 0, 'std': 1, 'type': 'float', 'round': 4},
'feature_2': {'dist': 'uniform', 'low': -2, 'high': 2, 'type': 'float', 'round': 4},
'feature_3': {'dist': 'exponential', 'scale': 1, 'type': 'float', 'round': 4},
'target': {'dist': 'binomial', 'n': 1, 'p': 0.5, 'type': 'int'},
}
generate_dataset(n_rows=500, schema=schema_ml, seed=7, save=True, filename="ml_dataset")
# 2. Recargar como (X, y)
X, y = load_dataset(
"ml_dataset.csv",
return_X_y=(['feature_1', 'feature_2', 'feature_3'], 'target')
)
print(f"X shape: {X.shape}") # (500, 3)
print(f"y shape: {y.shape}") # (500,)generate_dataset() con Preprocessing para practicar pipelines completos de limpieza, o con DescriptiveStats e InferentialStats para exploración estadística controlada con datos reproducibles.