Manual de ChartPython

2 + 2

precio = 3450
cantidad = 2

precio * cantidad

subtotal = precio * cantidad
print("Subtotal:", subtotal)
print("Con IVA:", subtotal * 1.21)
subtotal > 5000

display(precio, cantidad)
precio * cantidad;

import os

os.getcwd()

with open("notas.txt", "w", encoding="utf-8") as archivo:
    archivo.write("Primera prueba con ChartPython\n")

sorted(os.listdir())

# No lo ejecutes: este bucle no termina nunca y hay que interrumpirlo
while True:
    pass

import sys
import numpy as np
import pandas as pd
import scipy
import statsmodels

print("Python", sys.version.split()[0])
print("pandas", pd.__version__)
print("NumPy", np.__version__)
print("SciPy", scipy.__version__)
print("statsmodels", statsmodels.__version__)

import matplotlib.pyplot as plt

import time

inicio = time.perf_counter()
suma = sum(range(1_000_000))
print(f"Tardó {time.perf_counter() - inicio:.3f} segundos")

from IPython.display import display

nombre = input("¿Cómo te llamás? ")

import numpy as np

np.array([2_000_000_000, 2_000_000_000]).sum()

np.array([2_000_000_000, 2_000_000_000], dtype="int64").sum()

edad = 34            # entero (int)
altura = 1.72        # decimal (float): siempre con punto, nunca con coma
nombre = "Lucía"     # texto (str), entre comillas simples o dobles
socio = True         # verdadero o falso (bool)
sin_dato = None      # "no hay valor"
type(altura)

print(7 + 2, 7 - 2, 7 * 2)
print(7 / 2)     # división
print(7 // 2)    # división entera
print(7 % 2)     # resto
print(7 ** 2)    # potencia
print(round(3.14159, 2), abs(-5), max(3, 8, 1), min(3, 8, 1))

cliente = "  ana PÉREZ  "
print(cliente.strip())                 # sin espacios en los bordes
print(cliente.strip().title())         # Mayúscula Inicial
print(cliente.strip().upper())         # TODO EN MAYÚSCULAS
print("yerba;café;azúcar".split(";"))  # cortar en una lista
print("$ 3.450".replace("$", "").strip())
print(len("Córdoba"), "Cór" in "Córdoba")

total = 1234567.891
descuento = 0.15
print(f"Total: {total:,.2f}")
print(f"Descuento: {descuento:.0%}")
# Con punto de miles y coma decimal, como se escribe en Argentina:
print(f"{total:,.2f}".replace(",", "X").replace(".", ",").replace("X", "."))

print(int("42") + 1, float("3.5") * 2, str(10) + " unidades")
print(float("3,5".replace(",", ".")))

float("3,5")

precios = [3450, 5200.5, 1100, 2890]
print(precios[0])      # el primero
print(precios[-1])     # el último
print(precios[1:3])    # posiciones 1 y 2: el 3 no entra
precios.append(990)    # agregar al final
print(len(precios), sum(precios), max(precios))
print(sorted(precios))

producto = {"nombre": "Yerba 1kg", "precio": 3450, "stock": 12}
print(producto["precio"])
print(producto.get("marca", "sin marca"))   # valor por defecto si la clave no está
producto["stock"] = 10                       # cambiar o agregar un valor
for clave, valor in producto.items():
    print(clave, "→", valor)

minimo, maximo = min(precios), max(precios)
print(minimo, maximo)

provincias = ["CABA", "Córdoba", "CABA", "Mendoza"]
sorted(set(provincias))

stock = 3
if stock == 0:
    print("Sin stock")
elif stock < 5:
    print("Quedan pocas unidades")
else:
    print("Hay stock")

for provincia in ["CABA", "Córdoba", "Mendoza"]:
    print(provincia.upper())

for numero, precio in enumerate([3450, 1100], start=1):
    print(numero, precio)

for producto, precio in zip(["Yerba", "Azúcar"], [3450, 1100]):
    print(f"{producto}: $ {precio}")

for mes in range(1, 4):   # 1, 2 y 3: el 4 no entra
    print("Mes", mes)

precios = [3450, 5200.5, 1100, 2890]
con_iva = [round(p * 1.21, 2) for p in precios]
caros = [p for p in precios if p > 3000]
print(con_iva)
print(caros)

def precio_final(precio, descuento=0.0, iva=0.21):
    """Aplica el descuento y después el IVA."""
    con_descuento = precio * (1 - descuento)
    return round(con_descuento * (1 + iva), 2)

print(precio_final(1000))
print(precio_final(1000, descuento=0.1))

def a_numero(texto):
    try:
        return float(texto.replace(".", "").replace(",", "."))
    except ValueError:
        return None

print(a_numero("3.450,50"), a_numero("s/d"))

import math
from statistics import mean, median
import numpy as np
import pandas as pd

print(math.sqrt(16), math.log(100, 10))
print(mean([3, 5, 10]), median([3, 5, 10]))

help(round)

texto = """Sucursal;Fecha;Cliente ;Provincia;Producto;Cantidad;Precio Unitario;Descuento;Pagado
001;03/01/2026; Ana Pérez ;Buenos Aires;Yerba 1kg;2;$ 3.450,00;10%;Sí
001;03/01/2026;JUAN GÓMEZ;bs. as.;Café 500g;1;$ 5.200,50;0%;si
002;04/01/2026;María López;Córdoba;Yerba 1kg;;$ 3.450,00;5%;No
002;04/01/2026;María López;Córdoba;Yerba 1kg;;$ 3.450,00;5%;No
001;05/01/2026;Pedro Ruiz;CABA;Azúcar 1kg;3;$ 1.100,00;;SI
;;;;;;;;
002;06/01/2026;lucía  fernández;cordoba;Aceite 900ml;s/d;$ 2.890,00;0%;no
003;07/01/2026;Ana Pérez;Santa Fe ;Café 500g;250;$ 5.200,50;15%;Sí
001;31/02/2026;Juan Gómez;Capital Federal;Yerba 1kg;4;$ 3.450,00;0%;Sí
003;08/01/2026;Sofía Díaz;Mendoza;Aceite 900ml;1;$ 2.890,00;0%;No
001;09/01/2026;Pedro Ruiz;caba;Azúcar 1kg;6;$ 1.100,00;5%;Sí
002;10/01/2026;Lucía Fernández;Córdoba;Café 500g;2;$ 5.200,50;0%;No
"""

with open("ventas.csv", "w", encoding="utf-8") as archivo:
    archivo.write(texto)

print("Listo: ventas.csv quedó en /mnt/data")

import pandas as pd

ventas = pd.read_csv("ventas.csv")
ventas.shape

ventas = pd.read_csv("ventas.csv", sep=";")
ventas.shape

ventas["Sucursal"].head(3)

ventas = pd.read_csv("ventas.csv", sep=";", dtype={"Sucursal": str})
ventas["Sucursal"].head(3)

pd.read_csv("ventas.csv", sep=";", usecols=["Fecha", "Producto", "Cantidad"], nrows=3)

pd.read_csv("ventas.csv", sep=";", na_values=["s/d"])["Cantidad"].tolist()

import io

texto = "producto;precio\nYerba;3.450,50\nCafé;5.200,00\n"
pd.read_csv(io.StringIO(texto), sep=";", decimal=",", thousands=".")

with open("clientes_windows.csv", "w", encoding="latin-1") as archivo:
    archivo.write("nombre;ciudad\nJosé;Córdoba\n")

pd.read_csv("clientes_windows.csv", sep=";")

pd.read_csv("clientes_windows.csv", sep=";", encoding="latin-1")

display(ventas.head(3), ventas.tail(2))

ventas.columns.tolist()

ventas.info()

ventas["Provincia"].value_counts(dropna=False)

print(ventas["Pagado"].unique())
print("Filas repetidas:", ventas.duplicated().sum())

pd.set_option("display.max_columns", 50)   # columnas antes de cortar
pd.set_option("display.max_rows", 100)     # filas antes de mostrar sólo el principio y el final

df.columns = (
    df.columns.str.strip()                     # espacios en los bordes
    .str.lower()                               # minúsculas
    .str.normalize("NFKD")                     # separa cada letra de su acento...
    .str.encode("ascii", "ignore")             # ...descarta los acentos...
    .str.decode("ascii")                       # ...y vuelve a texto
    .str.replace(r"\W+", "_", regex=True)      # espacios y símbolos → _
)
df.columns.tolist()

df = df.dropna(how="all")   # borra las filas que están completamente vacías
df[df.duplicated(keep=False)][["fecha", "cliente", "producto"]]

df = df.drop_duplicates()
df = df.reset_index(drop=True)   # vuelve a numerar las filas 0, 1, 2…
len(df)

df["cliente"] = (
    df["cliente"].str.strip()                   # espacios en los bordes
    .str.replace(r"\s+", " ", regex=True)       # espacios repetidos en el medio
    .str.title()                                # Mayúscula Inicial
)
df["cliente"].unique().tolist()

df["producto"].str.extract(r"(\d+)\s*(kg|g|ml)").drop_duplicates()

clave = (
    df["provincia"].str.strip().str.lower()
    .str.normalize("NFKD").str.encode("ascii", "ignore").str.decode("ascii")
    .str.replace(".", "", regex=False)
)
clave.unique().tolist()

equivalencias = {
    "buenos aires": "Buenos Aires",
    "bs as": "Buenos Aires",
    "caba": "CABA",
    "capital federal": "CABA",
    "cordoba": "Córdoba",
    "santa fe": "Santa Fe",
    "mendoza": "Mendoza",
}
df["provincia"] = clave.map(equivalencias)
df["provincia"].value_counts(dropna=False)

df["precio_unitario"] = pd.to_numeric(
    df["precio_unitario"]
    .str.replace("$", "", regex=False)    # el signo
    .str.replace(".", "", regex=False)    # el punto de miles
    .str.replace(",", ".", regex=False)   # la coma decimal
    .str.strip(),
    errors="coerce",
)
df["precio_unitario"].head(3)

df["descuento"] = pd.to_numeric(df["descuento"].str.replace("%", "", regex=False).str.strip(), errors="coerce") / 100
df["descuento"].tolist()

convertida = pd.to_numeric(df["cantidad"], errors="coerce")
df.loc[convertida.isna() & df["cantidad"].notna(), ["cliente", "cantidad"]]

df["cantidad"] = convertida
df["cantidad"].tolist()

df["pagado"] = df["pagado"].str.strip().str.lower().map({"sí": True, "si": True, "no": False})
df["pagado"].value_counts(dropna=False)

df["fecha"] = pd.to_datetime(df["fecha"], format="%d/%m/%Y", errors="coerce")
df.loc[df["fecha"].isna(), ["cliente", "fecha"]]

dias = ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"]
pd.DataFrame({
    "fecha": df["fecha"],
    "mes": df["fecha"].dt.to_period("M"),
    "dia": df["fecha"].dt.dayofweek.map(dict(enumerate(dias))),
    "hace_dias": (pd.Timestamp("2026-01-31") - df["fecha"]).dt.days,
}).head(4)

q1 = df["cantidad"].quantile(0.25)
q3 = df["cantidad"].quantile(0.75)
iqr = q3 - q1
fuera = (df["cantidad"] < q1 - 1.5 * iqr) | (df["cantidad"] > q3 + 1.5 * iqr)
df.loc[fuera, ["fecha", "cliente", "producto", "cantidad"]]

import numpy as np

df.loc[fuera, "cantidad"] = np.nan

df.isna().sum()

df["descuento"] = df["descuento"].fillna(0)
df["cantidad"] = df["cantidad"].fillna(df["cantidad"].median())
df["cantidad"].tolist()

df["cantidad"] = df["cantidad"].astype("int64")
df["pagado"] = df["pagado"].astype(bool)
df.dtypes

montos = pd.Series([3_000_000_000.0, 150_000.0])
print(montos.astype(int).tolist())
print(montos.astype("int64").tolist())

pd.Series(["10", "20", "30"]).sum()

assert df["precio_unitario"].notna().all(), "Hay precios que no se pudieron leer"
assert df["cantidad"].between(1, 100).all(), "Hay cantidades fuera de rango"
assert df["provincia"].notna().all(), "Hay provincias sin equivalencia"
assert not df.duplicated().any(), "Quedaron filas repetidas"
print("Validación OK:", len(df), "filas")

assert df["fecha"].notna().all(), "Hay fechas vacías o imposibles"

pd.DataFrame({
    "tipo": df.dtypes.astype(str),
    "faltantes": df.isna().sum(),
    "distintos": df.nunique(),
})

df["total"] = (df["cantidad"] * df["precio_unitario"] * (1 - df["descuento"])).round(2)
df.to_csv("ventas_limpio.csv", index=False)

df.to_csv(
    "ventas_para_excel.csv",
    index=False,
    sep=";",
    decimal=",",
    encoding="utf-8-sig",
    date_format="%d/%m/%Y",
)
with open("ventas_para_excel.csv", encoding="utf-8-sig") as archivo:
    print("".join(archivo.readlines()[:3]))

import numpy as np
import pandas as pd

EQUIVALENCIAS = {
    "buenos aires": "Buenos Aires", "bs as": "Buenos Aires",
    "caba": "CABA", "capital federal": "CABA",
    "cordoba": "Córdoba", "santa fe": "Santa Fe", "mendoza": "Mendoza",
}


def sin_acentos(textos):
    """Sirve para una columna (Series) o para los nombres de columnas."""
    return textos.str.normalize("NFKD").str.encode("ascii", "ignore").str.decode("ascii")


def a_numero(textos):
    """'$ 3.450,50' → 3450.5. Lo que no se puede leer queda NaN."""
    limpio = (
        textos.str.replace("$", "", regex=False)
        .str.replace("%", "", regex=False)
        .str.replace(".", "", regex=False)
        .str.replace(",", ".", regex=False)
        .str.strip()
    )
    return pd.to_numeric(limpio, errors="coerce")


def limpiar_ventas(ruta):
    df = pd.read_csv(ruta, sep=";", dtype={"Sucursal": str})

    # Nombres de columnas y filas vacías o repetidas
    df.columns = sin_acentos(df.columns.str.strip().str.lower()).str.replace(r"\W+", "_", regex=True)
    df = df.dropna(how="all").drop_duplicates().reset_index(drop=True)

    # Texto y categorías
    df["cliente"] = df["cliente"].str.strip().str.replace(r"\s+", " ", regex=True).str.title()
    clave = sin_acentos(df["provincia"].str.strip().str.lower()).str.replace(".", "", regex=False)
    df["provincia"] = clave.map(EQUIVALENCIAS)
    df["pagado"] = df["pagado"].str.strip().str.lower().map({"sí": True, "si": True, "no": False})

    # Números y fechas
    df["precio_unitario"] = a_numero(df["precio_unitario"])
    df["descuento"] = a_numero(df["descuento"]).fillna(0) / 100
    df["cantidad"] = pd.to_numeric(df["cantidad"], errors="coerce")
    df["fecha"] = pd.to_datetime(df["fecha"], format="%d/%m/%Y", errors="coerce")

    # Atípicos: fuera de 1,5 IQR se toman como error de carga
    q1, q3 = df["cantidad"].quantile([0.25, 0.75])
    fuera = (df["cantidad"] < q1 - 1.5 * (q3 - q1)) | (df["cantidad"] > q3 + 1.5 * (q3 - q1))
    df.loc[fuera, "cantidad"] = np.nan

    # Faltantes, tipos y columnas calculadas
    df["cantidad"] = df["cantidad"].fillna(df["cantidad"].median()).astype("int64")
    df["pagado"] = df["pagado"].astype(bool)
    df["total"] = (df["cantidad"] * df["precio_unitario"] * (1 - df["descuento"])).round(2)

    # Validaciones
    assert df["precio_unitario"].notna().all(), "Hay precios que no se pudieron leer"
    assert df["provincia"].notna().all(), "Hay provincias sin equivalencia"
    return df


limpio = limpiar_ventas("ventas.csv")
limpio.to_csv("ventas_limpio.csv", index=False)
limpio[["fecha", "cliente", "provincia", "producto", "cantidad", "total"]]

limpio.equals(df)

ventas["cliente"].head(3)

ventas[["cliente", "producto", "total"]].head(3)

print(ventas.loc[2, "cliente"])     # fila con índice 2, columna "cliente"
print(ventas.iloc[0, 2])            # primera fila, tercera columna
ventas.loc[0:2, ["cliente", "total"]]

de_caba = ventas["provincia"] == "CABA"
ventas.loc[de_caba, ["cliente", "producto", "total"]]

grandes_de_caba = (ventas["provincia"] == "CABA") & (ventas["total"] > 5000)
ventas.loc[grandes_de_caba, ["cliente", "total"]]

ventas[ventas["provincia"] == "CABA" and ventas["total"] > 5000]

minimo = 5000
ventas.query("provincia in ['CABA', 'Córdoba'] and total > @minimo")[["cliente", "provincia", "total"]]

caba = ventas[ventas["provincia"] == "CABA"]
caba["total_con_iva"] = caba["total"] * 1.21

caba = ventas[ventas["provincia"] == "CABA"].copy()
caba["total_con_iva"] = caba["total"] * 1.21

ventas["region"] = np.where(ventas["provincia"].isin(["CABA", "Buenos Aires"]), "AMBA", "Interior")

condiciones = [ventas["total"] < 4000, ventas["total"] < 8000]
ventas["tamano"] = np.select(condiciones, ["chico", "mediano"], default="grande")

ventas[["provincia", "region", "total", "tamano"]].head(4)

ventas["tramo"] = pd.cut(ventas["total"], bins=[0, 4000, 8000, np.inf], labels=["bajo", "medio", "alto"])
ventas["quintil"] = pd.qcut(ventas["total"], q=5, labels=[1, 2, 3, 4, 5])
ventas[["total", "tramo", "quintil"]].head(4)

def rubro(producto):
    return "Infusiones" if producto.startswith(("Yerba", "Café")) else "Almacén"

ventas["rubro"] = ventas["producto"].apply(rubro)
ventas["envase"] = ventas["producto"].map({
    "Yerba 1kg": "paquete", "Café 500g": "paquete", "Azúcar 1kg": "paquete", "Aceite 900ml": "botella",
})
ventas[["producto", "rubro", "envase"]].drop_duplicates()

ventas = ventas.drop(columns=["tamano", "envase"])
ventas.sort_values(["provincia", "total"], ascending=[True, False])[["provincia", "cliente", "total"]].head(5)

(
    ventas
    .assign(total_miles=lambda d: (d["total"] / 1000).round(1))
    .sort_values("total_miles", ascending=False)
    .head(3)
    [["cliente", "producto", "total_miles"]]
)

rng = np.random.default_rng(2026)
n = 300
encuesta = pd.DataFrame({
    "edad": rng.integers(18, 66, n),
    "sexo": rng.choice(["mujer", "varón"], n),
    "region": rng.choice(["AMBA", "Centro", "Cuyo", "NEA", "NOA", "Patagonia"], n),
    "educacion": rng.integers(7, 19, n),   # años de estudio
})
encuesta["experiencia"] = (encuesta["edad"] - encuesta["educacion"] - 6).clip(lower=0)
encuesta["horas"] = rng.normal(40, 8, n).round().clip(10, 70)
log_salario = (
    13
    + 0.07 * encuesta["educacion"]
    + 0.03 * encuesta["experiencia"]
    - 0.0005 * encuesta["experiencia"] ** 2
    - 0.12 * (encuesta["sexo"] == "mujer")
    + rng.normal(0, 0.35, n)
)
encuesta["salario"] = np.exp(log_salario).round(-3)
encuesta.to_csv("encuesta.csv", index=False)
encuesta.head()

salario = encuesta["salario"]
print("Media:", round(salario.mean()))
print("Mediana:", salario.median())
print("Desvío estándar:", round(salario.std()))
print("Mínimo y máximo:", salario.min(), salario.max())
print("Percentil 90:", salario.quantile(0.9))

encuesta.describe().round(1)

encuesta["region"].value_counts(normalize=True).round(3)

encuesta[["edad", "educacion", "experiencia", "horas", "salario"]].corr().round(2)

pd.set_option("display.float_format", "{:,.2f}".format)
encuesta[["horas", "salario"]].agg(["mean", "median"])

pd.reset_option("display.float_format")   # vuelve al formato normal

ventas.groupby("provincia")["total"].sum()

resumen = ventas.groupby("provincia").agg(
    pedidos=("total", "size"),
    unidades=("cantidad", "sum"),
    facturacion=("total", "sum"),
    ticket_promedio=("total", "mean"),
)
resumen.round(2).sort_values("facturacion", ascending=False)

ventas.groupby(["provincia", "producto"], as_index=False)["cantidad"].sum()

ventas["participacion"] = ventas["total"] / ventas.groupby("provincia")["total"].transform("sum")
ventas[["provincia", "cliente", "total", "participacion"]].round(3).head(4)

pd.pivot_table(
    ventas,
    index="provincia",
    columns="rubro",
    values="total",
    aggfunc="sum",
    fill_value=0,
    margins=True,
    margins_name="Total",
)

pd.crosstab(encuesta["region"], encuesta["sexo"], normalize="index").round(2)

ventas.groupby("tramo", observed=True)["total"].agg(["count", "sum"])

productos = pd.DataFrame({
    "producto": ["Yerba 1kg", "Café 500g", "Azúcar 1kg", "Aceite 900ml"],
    "costo": [2300.0, 3600.0, 700.0, 2100.0],
})
con_costo = ventas.merge(productos, on="producto", how="left", validate="m:1")
con_costo["margen"] = con_costo["total"] - con_costo["cantidad"] * con_costo["costo"]
con_costo.groupby("producto")[["total", "margen"]].sum()

clientes = pd.DataFrame({
    "cliente": ["Ana Pérez", "Juan Gómez", "Marta Ríos"],
    "segmento": ["mayorista", "minorista", "minorista"],
})
ventas[["cliente"]].drop_duplicates().merge(clientes, on="cliente", how="outer", indicator=True)

import glob

ventas.iloc[:5].to_csv("ventas_parte1.csv", index=False)
ventas.iloc[5:].to_csv("ventas_parte2.csv", index=False)

archivos = sorted(glob.glob("ventas_parte*.csv"))
juntas = pd.concat(
    [pd.read_csv(nombre).assign(archivo=nombre) for nombre in archivos],
    ignore_index=True,
)
juntas["archivo"].value_counts()

ipc = pd.DataFrame({
    "region": ["GBA", "Noreste", "Patagonia"],
    "2026-01": [2.1, 2.4, 1.9],
    "2026-02": [2.3, 2.2, 2.0],
    "2026-03": [1.8, 2.0, 2.1],
})
largo = ipc.melt(id_vars="region", var_name="mes", value_name="variacion")
largo.head(4)

largo.pivot(index="mes", columns="region", values="variacion")

meses = pd.date_range("2024-01-01", periods=24, freq="MS")
serie = pd.DataFrame(
    {
        "ventas": np.round(1000 * 1.04 ** np.arange(24) + np.tile([0.0, 40.0, -30.0], 8)),
        "ipc": np.round(100 * 1.03 ** np.arange(24), 1),
    },
    index=meses,
)
serie.head(3)

serie[["ventas"]].assign(
    anterior=serie["ventas"].shift(1),
    variacion=serie["ventas"].pct_change().round(3),
    interanual=serie["ventas"].pct_change(12).round(3),
    media_movil=serie["ventas"].rolling(3).mean().round(1),
    acumulado=serie["ventas"].cumsum(),
).iloc[12:15]

serie["ventas"].resample("QE").sum().head(4)

serie["ventas"].resample("Q").sum().head(1)

ventas.set_index("fecha")["total"].resample("W").sum()

serie["ventas_reales"] = (serie["ventas"] / serie["ipc"] * serie["ipc"].iloc[-1]).round()
serie[["ventas", "ipc", "ventas_reales"]].iloc[[0, 12, 23]]

from statsmodels.tsa.stattools import acf, adfuller

estadistico, p_valor, *_ = adfuller(serie["ventas"])
print(f"ADF = {estadistico:.2f}, p-valor = {p_valor:.3f}")
print("Autocorrelación:", acf(serie["ventas"], nlags=3).round(2))

from statsmodels.tsa.arima.model import ARIMA

ajuste = ARIMA(serie["ventas"], order=(1, 1, 0)).fit()
ajuste.forecast(steps=3).round()

a = np.array([1.5, 2.0, np.nan, 4.0])
print(np.nanmean(a), np.nanmedian(a), np.isnan(a).sum())
print(np.round(np.sqrt(a), 2))
print(np.where(a > 1.8, "alto", "bajo"))   # ojo: NaN > 1.8 es False

print(np.log(100), np.exp(1), np.log10(1000))
print(np.arange(0, 1, 0.25), np.linspace(0, 1, 5))
print(np.percentile([10, 20, 30, 40, 50], 90))

rng = np.random.default_rng(42)
print(rng.normal(loc=0, scale=1, size=3).round(3))
print(rng.integers(1, 7, size=5))          # como tirar un dado: del 1 al 6
print(rng.choice(["AMBA", "Centro", "Cuyo", "NEA", "NOA", "Patagonia"], size=3))
print(rng.permutation(5))                  # los números del 0 al 4, mezclados

salarios = np.array([500_000.0, 800_000.0, 1_200_000.0])
ponderadores = np.array([120, 60, 20])   # cuántas personas representa cada caso
np.average(salarios, weights=ponderadores)

from scipy import stats

mujeres = encuesta.loc[encuesta["sexo"] == "mujer", "salario"]
varones = encuesta.loc[encuesta["sexo"] == "varón", "salario"]
prueba = stats.ttest_ind(mujeres, varones, equal_var=False)   # t de Welch
print(f"t = {prueba.statistic:.2f}, p-valor = {prueba.pvalue:.4f}")

tabla = pd.crosstab(encuesta["region"], encuesta["sexo"])
chi2, p_valor, grados, esperados = stats.chi2_contingency(tabla)
print(f"chi2 = {chi2:.2f}, gl = {grados}, p-valor = {p_valor:.3f}")

r, p_valor = stats.pearsonr(encuesta["educacion"], encuesta["salario"])
print(f"r = {r:.2f}, p-valor = {p_valor:.2g}")

grupos = [grupo["salario"] for _, grupo in encuesta.groupby("region")]
anova = stats.f_oneway(*grupos)
print(f"ANOVA: F = {anova.statistic:.2f}, p-valor = {anova.pvalue:.3f}")

horas = encuesta["horas"]
bajo, alto = stats.t.interval(0.95, df=len(horas) - 1, loc=horas.mean(), scale=stats.sem(horas))
print(f"Horas semanales: {horas.mean():.1f} (IC 95 %: {bajo:.1f} a {alto:.1f})")

import statsmodels.formula.api as smf

modelo = smf.ols("salario ~ educacion + experiencia", data=encuesta).fit()
print(modelo.summary())

pd.DataFrame({
    "coeficiente": modelo.params,
    "error_estandar": modelo.bse,
    "t": modelo.tvalues,
    "p_valor": modelo.pvalues,
}).round(4)

print(f"R² = {modelo.rsquared:.3f}, R² ajustado = {modelo.rsquared_adj:.3f}, n = {int(modelo.nobs)}")
modelo.conf_int(alpha=0.05).round()   # intervalos de confianza del 95 %

mincer = smf.ols(
    "np.log(salario) ~ educacion + experiencia + I(experiencia ** 2) + C(sexo) + C(region)",
    data=encuesta,
).fit(cov_type="HC1")
mincer.params.round(4)

retorno = mincer.params["educacion"] * 100
print(f"Cada año más de educación se asocia con un salario {retorno:.1f} % más alto")

nuevos = pd.DataFrame({"educacion": [12, 17], "experiencia": [10, 10]})
modelo.predict(nuevos).round()

encuesta["salario_alto"] = (encuesta["salario"] > encuesta["salario"].median()).astype("int64")
logit = smf.logit("salario_alto ~ educacion + experiencia + C(sexo)", data=encuesta).fit(disp=0)
np.exp(logit.params).round(3)

import statsmodels.api as sm
from statsmodels.stats.diagnostic import het_breuschpagan
from statsmodels.stats.outliers_influence import variance_inflation_factor

_, p_bp, _, _ = het_breuschpagan(modelo.resid, modelo.model.exog)
print(f"Breusch-Pagan (heterocedasticidad): p-valor = {p_bp:.3f}")

X = sm.add_constant(encuesta[["educacion", "experiencia", "horas"]])
vif = pd.Series([variance_inflation_factor(X.values, i) for i in range(1, X.shape[1])], index=X.columns[1:])
print("VIF (multicolinealidad):", vif.round(2).to_dict())

por_producto = ventas.groupby("producto")["total"].sum().sort_values(ascending=False)
largos = (por_producto / por_producto.max() * 30).round().astype("int64")
for producto, largo in largos.items():
    print(f"{producto:<14}{'█' * largo} {por_producto[producto]:,.0f}")

from html import escape


class SVG:
    """Muestra un dibujo SVG como salida de la celda."""

    def __init__(self, codigo):
        self.codigo = codigo

    def _repr_svg_(self):
        return self.codigo


def grafico_barras(serie, titulo="", ancho=640, color="#1e5fa8"):
    """Barras horizontales: una por cada valor de la serie."""
    serie = serie.dropna()
    fila, arriba, izquierda = 28, 36, 150
    maximo = max(serie.max(), 0) or 1
    partes = [
        '<rect width="100%" height="100%" fill="#fff"/>',
        f'<text x="0" y="20" font-size="15" font-weight="600">{escape(str(titulo))}</text>',
    ]
    for i, (etiqueta, valor) in enumerate(serie.items()):
        y = arriba + i * fila
        largo = max(valor, 0) / maximo * (ancho - izquierda - 90)
        partes.append(
            f'<text x="{izquierda - 8}" y="{y + 16}" font-size="12" text-anchor="end">{escape(str(etiqueta))}</text>'
            f'<rect x="{izquierda}" y="{y + 4}" width="{largo:.1f}" height="{fila - 10}" fill="{color}"/>'
            f'<text x="{izquierda + largo + 6:.1f}" y="{y + 16}" font-size="12">{valor:,.0f}</text>'
        )
    alto = arriba + fila * len(serie) + 8
    return SVG(
        f'<svg xmlns="http://www.w3.org/2000/svg" width="{ancho}" height="{alto}" '
        f'font-family="sans-serif" fill="#101725">{"".join(partes)}</svg>'
    )


def grafico_lineas(serie, titulo="", ancho=640, alto=280, color="#1e5fa8"):
    """Una línea para una serie ordenada, por ejemplo con fechas en el índice."""
    serie = serie.dropna()
    izquierda, derecha, arriba, abajo = 70, 20, 36, 40
    minimo, maximo = serie.min(), serie.max()
    rango = (maximo - minimo) or 1
    paso = (ancho - izquierda - derecha) / max(len(serie) - 1, 1)

    def x(i):
        return izquierda + i * paso

    def y(valor):
        return arriba + (maximo - valor) / rango * (alto - arriba - abajo)

    puntos = " ".join(f"{x(i):.1f},{y(v):.1f}" for i, v in enumerate(serie))
    desde, hasta = (escape(str(v)[:10]) for v in (serie.index[0], serie.index[-1]))
    return SVG(
        f'<svg xmlns="http://www.w3.org/2000/svg" width="{ancho}" height="{alto}" '
        f'font-family="sans-serif" fill="#101725">'
        '<rect width="100%" height="100%" fill="#fff"/>'
        f'<text x="0" y="20" font-size="15" font-weight="600">{escape(str(titulo))}</text>'
        f'<line x1="{izquierda}" y1="{alto - abajo}" x2="{ancho - derecha}" y2="{alto - abajo}" stroke="#c9d0da"/>'
        f'<text x="{izquierda - 8}" y="{y(maximo) + 4:.1f}" font-size="11" text-anchor="end">{maximo:,.0f}</text>'
        f'<text x="{izquierda - 8}" y="{y(minimo) + 4:.1f}" font-size="11" text-anchor="end">{minimo:,.0f}</text>'
        f'<polyline points="{puntos}" fill="none" stroke="{color}" stroke-width="2"/>'
        f'<text x="{izquierda}" y="{alto - 14}" font-size="11">{desde}</text>'
        f'<text x="{ancho - derecha}" y="{alto - 14}" font-size="11" text-anchor="end">{hasta}</text>'
        "</svg>"
    )

grafico_barras(por_producto, "Facturación por producto")

grafico_lineas(serie["ventas_reales"], "Ventas a precios del último mes")

conteo = encuesta["salario"].value_counts(bins=8, sort=False)
conteo.index = [f"{tramo.left / 1e6:.1f} a {tramo.right / 1e6:.1f} M" for tramo in conteo.index]
grafico_barras(conteo, "Personas por tramo de salario")

grafico = grafico_lineas(serie["ventas"], "Ventas mensuales")
with open("ventas_mensuales.svg", "w", encoding="utf-8") as archivo:
    archivo.write(grafico.codigo)

pd.read_csv("Ventas.csv")   # el archivo se llama ventas.csv, en minúscula

crudo = pd.read_csv("ventas.csv", sep=";")
crudo["Cliente"]   # la columna es "Cliente " con un espacio

import io

texto = "producto,precio\nYerba,3450\nCafé,5200,50\n"   # coma decimal en un CSV con comas
pd.read_csv(io.StringIO(texto))