Qué puedes calcular con cada columna

El archivo tiene 3.000 ventas. ¿De cuántos clientes distintos? ¿Y cuántas ventas hace un cliente típico?

print('clientes distintos:', v['cliente_id'].nunique())
print('ventas por cliente: %.2f' % (len(v) / v['cliente_id'].nunique()))
print(v['cliente_id'].value_counts().describe().round(2))

clientes distintos: 617
ventas por cliente: 4.86
count    617.00
mean       4.86
std        2.19
min        1.00
25%        3.00
50%        5.00
75%        6.00
max       14.00
Name: count, dtype: float64

617 clientes y 3.000 ventas: 4,86 ventas por cliente.

Esto cambia cómo hay que leer el archivo entero, y es de las cosas que más se pasan por alto. Las 3.000 filas no son 3.000 clientes independientes: hay uno que aparece 14 veces.

Cuando el mismo cliente sale muchas veces, sus filas se parecen entre ellas más de lo normal, y eso hace que cualquier prueba estadística crea que tiene más información de la que tiene. Es una de las cosas que invalidan análisis y sale en el capítulo 17.

Escribe algo que recorra las columnas numéricas y te avise de cuáles son sospechosas de ser categorías.

for col in v.select_dtypes('number').columns:
    distintos = v[col].nunique()
    aviso = '  <-- categorica disfrazada' if distintos <= 10 else ''
    print('%-24s %5d distintos%s' % (col, distintos, aviso))

id_venta                  3000 distintos
unidades                    30 distintos
monto                     2964 distintos
descuento                  251 distintos
satisfaccion                 5 distintos  <-- categorica disfrazada
compro                       2 distintos  <-- categorica disfrazada
monto_final_facturado     1723 distintos

Caza las dos que buscábamos. Y fíjate que unidades, con 30 valores, se queda fuera: es discreta de verdad, no una categoría.

El umbral de 10 es mío y es discutible, que quede claro. Sirve como primer filtro para mirar, no como sentencia. Lo que este código hace es ahorrarte abrir 14 columnas a mano 🙌

La columna descuento tiene vacíos. Calcula su media, y luego calcúlala tratando los vacíos como cero. ¿Cuál está bien?

print('filas totales:      ', len(v))
print('descuentos con dato:', v['descuento'].count())
print('media ignorando huecos: %.4f' % v['descuento'].mean())
print('media con huecos = 0:   %.4f' % v['descuento'].fillna(0).mean())

filas totales:       3000
descuentos con dato: 2405
media ignorando huecos: 0.1252
media con huecos = 0:   0.1004

12,52% contra 10,04%. Una diferencia de dos puntos y medio, decidida enteramente por lo que supongas de 595 celdas vacías.

¿Cuál está bien? Depende de qué signifique el vacío, y eso no está en los datos. Si el sistema deja el campo en blanco cuando no hubo descuento, el vacío es un cero y la buena es 10,04%. Si el campo se llena siempre y esos 595 se perdieron al migrar, el vacío es un desconocido y la buena es 12,52%.

Lo que no puedes hacer es no decidir. Porque mean() decide por ti: ignora los nulos en silencio y te devuelve 12,52% sin avisarte de que se saltó el 20% de las filas.

Esto se pregunta a quien mantiene el sistema. Es la clase de pregunta que distingue a alguien que analiza datos de alguien que ejecuta celdas 😌

Con fecha y fecha_ultima_compra, calcula cuántos días hacía que ese cliente no compraba. Mira bien el resultado antes de darlo por bueno.

for col in ['fecha', 'fecha_ultima_compra']:
    f = pd.to_datetime(v[col], format='%Y-%m-%d', errors='coerce')
    falta = f.isna() & v[col].notna()
    f[falta] = pd.to_datetime(v.loc[falta, col], format='%d/%m/%Y',
                              errors='coerce')
    v[col] = f

dias = (v['fecha'] - v['fecha_ultima_compra']).dt.days
print(dias.describe().round(2))
print('negativos:', (dias < 0).sum())

count    2456.00
mean       72.82
std       190.33
min      -385.00
25%       -65.00
50%        69.00
75%       213.25
max       522.00
dtype: float64
negativos: 904

Aquí hay que parar 🛑

904 valores negativos. O sea 904 ventas donde la "última compra" del cliente ocurrió después de la venta que estamos mirando.

Eso no es un dato raro, es un dato imposible tal como lo estamos leyendo. La explicación más probable es que la columna no sea "la compra anterior a esta" sino "la última compra registrada del cliente hasta hoy", que es un dato del cliente y no de la venta. Con ese significado los negativos son normales: la venta que miramos es vieja y el cliente volvió después.

La conclusión práctica es dura y es la correcta: esta columna no sirve como recencia y hay que preguntar antes de usarla. Si la metes en un análisis tal cual, la mitad de tus filas dice que el cliente compró hace -65 días.

Lo que hicimos aquí, mirar el describe() de una variable recién creada, es lo que evitó publicarlo. Cuesta diez segundos y salva informes 🙏

Compara la satisfacción entre segmentos con las dos medidas. ¿Cuál cuenta mejor lo que pasa?

print(v.groupby('segmento')['satisfaccion']
      .agg(['mean', 'median', 'count']).round(4))

              mean  median  count
segmento
Bodega      2.9603     3.0    655
Horeca      3.0332     3.0    692
Mayorista   2.9927     3.0    684
Minimarket  3.0474     3.0    738

Las medias van de 2,96 a 3,05. Las medianas son todas 3.

Y las dos están contando lo mismo: aquí no pasa nada. La satisfacción no distingue segmentos.

Fíjate en lo fácil que sería hacer el ridículo con esto. Con las medias en la mano, alguien escribe "Minimarket es nuestro segmento más satisfecho, con 3,05 frente al 2,96 de Bodega". Suena a hallazgo. Son nueve centésimas en una escala de 1 a 5, con setecientas filas por grupo.

La mediana, al ser toda 3, te lo deja más difícil de contar mal. Por eso me gusta para ordinales: no te deja fingir precisión que no tienes 🎯

En el capítulo 14 le ponemos número a esto y sale que la diferencia es minúscula incluso comparada con lo que varía la satisfacción dentro de un mismo segmento.

Saca la media de monto_final_facturado sobre todas las filas y luego solo sobre las que compraron. Explica la diferencia.

print('media sobre las 3000 filas:      %.2f' % v['monto_final_facturado'].mean())
print('media solo sobre los que compraron: %.2f'
      % v.loc[v['compro'] == 1, 'monto_final_facturado'].mean())
print('cuantos ceros:', (v['monto_final_facturado'] == 0).sum())

media sobre las 3000 filas:      481.26
media solo sobre los que compraron: 833.10
cuantos ceros: 1267

481 contra 833. Casi el doble, y las dos son "la media de la misma columna" 🫠

Lo que pasa es que 1.267 filas tienen un cero, y esos ceros no son ventas de cero soles: son ventas que no ocurrieron. La columna solo se llena cuando compro vale 1.

El número que un negocio quiere oír, el ticket promedio, es el de 833,10, y se calcula solo sobre las ventas cerradas. El 481,26 no es el ticket de nada: es una mezcla de tickets y de no-ventas.

Y ojo con esta columna, porque tiene otra trampa peor que la usamos en el libro de machine learning: como solo existe si la venta se cerró, meterla en un modelo que predice si la venta se va a cerrar es hacer trampa. Se llama fuga de información y está contada en el capítulo de fuga del libro de ML.

Junta todo lo del capítulo en algo que puedas pegar al inicio de cualquier cuaderno.

def carga_limpia(url):
    """Lee el archivo y deja cada columna en su tipo."""
    v = pd.read_csv(url).drop_duplicates()

    v['ciudad'] = (v['ciudad'].str.strip().str.lower()
                   .str.normalize('NFKD')
                   .str.encode('ascii', 'ignore').str.decode('utf-8'))

    v['monto'] = pd.to_numeric(v['monto'].str.replace(',', '.'))

    for col in ['fecha', 'fecha_ultima_compra']:
        f = pd.to_datetime(v[col], format='%Y-%m-%d', errors='coerce')
        falta = f.isna() & v[col].notna()
        f[falta] = pd.to_datetime(v.loc[falta, col], format='%d/%m/%Y',
                                  errors='coerce')
        v[col] = f

    return v

limpio = carga_limpia(URL)
print(limpio.shape)
print(limpio['ciudad'].nunique(), 'ciudades |',
      limpio['monto'].dtype, '| fechas:', limpio['fecha'].dtype)

(3000, 14)
6 ciudades | float64 | fechas: datetime64[us]

Esta función es la que abre todos los capítulos que vienen. Cópiala 📌

Fíjate en ese falta = f.isna() & v[col].notna(): solo reintenta las fechas que tenían texto y no se pudieron convertir. Sin la segunda condición intentaría rellenar también los huecos de verdad, y esos tienen que seguir siendo huecos 🕳️

Saca de un tirón el tipo que pandas le puso a cada columna y cuántos valores distintos tiene.

for col in v.columns:
    print('%-22s %-16s %5d distintos' % (col, v[col].dtype, v[col].nunique()))

id_venta               int64             3000 distintos
fecha                  datetime64[us]     537 distintos
cliente_id             str                617 distintos
ciudad                 str                  6 distintos
segmento               str                  4 distintos
canal                  str                  4 distintos
categoria              str                  5 distintos
unidades               int64               30 distintos
monto                  float64           2964 distintos
descuento              float64            251 distintos
fecha_ultima_compra    datetime64[us]     399 distintos
satisfaccion           float64              5 distintos
compro                 int64                2 distintos
monto_final_facturado  float64           1723 distintos

Esta tabla es lo primero que yo miro de un archivo que no conozco, y tarda un segundo 📋

Fíjate en las dos columnas juntas, que es donde está la gracia. satisfaccion es float64 y tiene cinco valores distintos: pandas la guarda como decimal y en realidad es ordinal. Y compro es int64 con dos valores, o sea binaria disfrazada de número.

El tipo que pone pandas dice cómo está guardada. El tipo que importa lo decides tú mirando cuántos valores distintos hay y qué significan 🔍

Dile a pandas que el segmento tiene orden, y comprueba que después se puede comparar.

orden = ['Bodega', 'Minimarket', 'Horeca', 'Mayorista']
v['segmento_orden'] = pd.Categorical(v['segmento'], categories=orden, ordered=True)
print(v.groupby('segmento_orden', observed=True)['monto'].median().round(2).to_string())
print()
print('ahora si se puede preguntar por el orden:')
print((v['segmento_orden'] > 'Minimarket').sum(), 'pedidos son de Horeca o Mayorista')

segmento_orden
Bodega         183.26
Minimarket     413.74
Horeca         743.00
Mayorista     1869.26

ahora si se puede preguntar por el orden:
1492 pedidos son de Horeca o Mayorista

Dos cosas cambian y las dos importan 💜

La primera: la tabla sale en el orden del negocio y no en alfabético. Con eso solo, ya se lee que la mediana sube de 183 a 1.869 según el escalón, que es una historia entera.

La segunda: ahora > 'Minimarket' significa algo. Sobre texto suelto esa comparación te habría dado el orden del diccionario, que aquí no quiere decir nada. Convertir una ordinal en ordinal de verdad es una línea y te ahorra errores todo el resto del análisis 🔑