merge avanzado

import pandas as pd


def unico(nombre):
    t = pd.read_csv(nombre)
    return (t.sort_values("actualizado", kind="stable")
            .drop_duplicates(subset=["sku"], keep="last"))


a = unico("catalogo_sistema_a.csv")
b = unico("catalogo_sistema_b.csv")

todo = a.merge(b, on="sku", how="outer", suffixes=("_a", "_b"),
               indicator=True)
print("outer:", len(todo), "filas")

print()
print(todo["_merge"].value_counts().to_string())

print()
print("Esa columna es lo que convierte a un outer en un diagnostico:")
print("sin ella, las filas con precio_b vacio pueden ser 'no esta en B'")
print("o 'esta en B pero sin precio', y son cosas muy distintas.")

print()
print(todo.loc[todo["_merge"] != "both",
               ["sku", "precio_a", "precio_b", "_merge"]]
      .head(4).to_string(index=False))

import pandas as pd


def unico(nombre):
    t = pd.read_csv(nombre)
    return (t.sort_values("actualizado", kind="stable")
            .drop_duplicates(subset=["sku"], keep="last"))


a = unico("catalogo_sistema_a.csv")
b = unico("catalogo_sistema_b.csv")

# El anti-join no es un how: es un left (u outer) con indicator, filtrado.
solo_a = (a.merge(b, on="sku", how="left", indicator=True)
          .query('_merge == "left_only"'))
print("productos que estan solo en A:", len(solo_a))
print(solo_a[["sku", "nombre_x", "precio_x"]].head(4).to_string(index=False))

print()
solo_b = (b.merge(a, on="sku", how="left", indicator=True)
          .query('_merge == "left_only"'))
print("productos que estan solo en B:", len(solo_b))

print()
print("Es lo mismo que se podria hacer con conjuntos:")
print("len(set(a.sku) - set(b.sku)) =", len(set(a["sku"]) - set(b["sku"])))
print("pero el merge te devuelve las FILAS enteras, no solo las claves.")

import pandas as pd

a = pd.read_csv("catalogo_sistema_a.csv")
b = pd.read_csv("catalogo_sistema_b.csv")

try:
    a.merge(b, on="sku", how="inner", validate="1:1")
except pd.errors.MergeError as error:
    print("validate='1:1' ->", type(error).__name__)
    print(error)

print()
print("El mensaje dice DONDE esta el problema, que es lo que uno quiere.")


def unico(t):
    return (t.sort_values("actualizado", kind="stable")
            .drop_duplicates(subset=["sku"], keep="last"))


ok = unico(a).merge(unico(b), on="sku", how="inner", validate="1:1",
                    suffixes=("_a", "_b"))
print()
print("deduplicando primero, validate='1:1' pasa:", len(ok), "filas")

print()
# El otro caso frecuente: muchas ventas contra un catalogo.
ventas = pd.read_csv("dw_hecho_ventas.csv")
productos = pd.read_csv("dw_dim_producto.csv")
cruce = ventas.merge(productos, on="producto_id", how="left", validate="m:1")
print("ventas x productos con validate='m:1':", len(cruce), "filas")
print("m:1 afirma que el catalogo tiene una fila por producto.")
print("Si manana alguien duplica un producto, este merge para en vez de")
print("duplicar 500 ventas.")

import pandas as pd


def unico(nombre):
    t = pd.read_csv(nombre)
    return (t.sort_values("actualizado", kind="stable")
            .drop_duplicates(subset=["sku"], keep="last"))


a = unico("catalogo_sistema_a.csv")
b = unico("catalogo_sistema_b.csv")
print("columnas de A:", list(a.columns))
print("columnas de B:", list(b.columns))
print("comparten todo menos la clave, asi que hay 4 choques de nombre.")

sin_sufijos = a.merge(b, on="sku", how="inner")
print()
print("sin declarar sufijos, pandas pone _x y _y:")
print([c for c in sin_sufijos.columns if c.endswith(("_x", "_y"))])

con_sufijos = a.merge(b, on="sku", how="inner", suffixes=("_a", "_b"))
print()
print("declarandolos:")
print([c for c in con_sufijos.columns if c.endswith(("_a", "_b"))])

print()
print("_x y _y no significan nada dentro de seis meses. _a y _b tampoco")
print("mucho, pero al menos se corresponden con los nombres de los archivos.")
print("Lo mejor es que digan de que sistema viene cada dato.")

import pandas as pd


def unico(nombre):
    t = pd.read_csv(nombre)
    return (t.sort_values("actualizado", kind="stable")
            .drop_duplicates(subset=["sku"], keep="last"))


a = unico("catalogo_sistema_a.csv")
b = unico("catalogo_sistema_b.csv")

todo = a.merge(b, on="sku", how="outer", suffixes=("_a", "_b"),
               indicator=True)
print("unificado:", len(todo), "filas")

comunes = todo[todo["_merge"] == "both"]

# La guarda de notna importa: NaN != valor da True, y un dato que falta en una
# fuente NO es una contradiccion entre las dos.
def difieren(columna):
    a_col, b_col = comunes[f"{columna}_a"], comunes[f"{columna}_b"]
    return a_col.ne(b_col) & a_col.notna() & b_col.notna()


def falta_en_una(columna):
    return comunes[f"{columna}_a"].isna() ^ comunes[f"{columna}_b"].isna()


print()
print("de los", len(comunes), "productos que estan en las dos fuentes:")
print("  se contradicen en el precio :", int(difieren("precio").sum()))
print("  se contradicen en el nombre :", int(difieren("nombre").sum()))
print("  a una le falta el nombre    :", int(falta_en_una("nombre").sum()))
print("  alguna de las tres cosas    :",
      int((difieren("precio") | difieren("nombre")
           | falta_en_una("nombre")).sum()))

print()
print("Sin la guarda de notna, 'nombre distinto' daria",
      int(comunes["nombre_a"].ne(comunes["nombre_b"]).sum()),
      "en vez de", int(difieren("nombre").sum()) )
print("porque cuenta como contradiccion la fila donde B no tiene nombre.")

print()
print(comunes.loc[difieren("precio"), ["sku", "precio_a", "precio_b"]]
      .head(4).to_string(index=False))

print()
# combine_first llena los huecos de la primera con la segunda. Es la forma
# corta de decir "gana A, y si A no tiene, uso B".
precio = todo["precio_a"].combine_first(todo["precio_b"])
print("precio unificado con 'gana A':", int(precio.notna().sum()),
      "de", len(todo), "con valor")

print()
print("Cual gana NO lo deciden los datos. Aca elegimos A por escrito;")
print("elegir B, o el mas reciente, o promediarlos, son politicas distintas")
print("y todas producen un archivo distinto.")