0Pricing
Pandas & NumPy Academy · Lección

Joins izquierdo y derecho

Realice joins izquierdos y derechos para conservar todas las filas de una tabla y hacer coincidir los registros de otra.

Joins izquierdo y derecho es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

Combinaciones asimétricas

Las combinaciones internas y externas tratan ambos DataFrames de forma simétrica. Sin embargo, a menudo querrá conservar todos los registros de una tabla y enriquecerlos con datos de otra. Para eso existen las combinaciones izquierdas y las combinaciones derechas. Estas combinaciones asimétricas son muy habituales en análisis de datos: conservar todas las transacciones y añadir los nombres de producto cuando estén disponibles; conservar todos los usuarios y añadir la fecha de su última compra si tienen alguna.

Combinación izquierda: conservar todas las filas izquierdas

Una combinación izquierda (how='left') conserva todas las filas del DataFrame izquierdo. En las filas que encuentran una clave coincidente en el DataFrame derecho, las columnas derechas se rellenan con los valores correspondientes. En las filas sin coincidencia, las columnas derechas se rellenan con NaN. El número de filas del resultado siempre es igual al del DataFrame izquierdo (siempre que no haya claves duplicadas).

import pandas as pd

orders = pd.DataFrame({
    'order_id': [1, 2, 3, 4],
    'customer_id': [101, 102, 101, 999],
    'amount': [250, 80, 320, 150]
})
customers = pd.DataFrame({
    'customer_id': [101, 102, 103],
    'name': ['Alice', 'Bob', 'Carol']
})

result = pd.merge(orders, customers, on='customer_id', how='left')
print(result)
# All 4 orders kept; order with customer_id=999 gets NaN for name

Estructura del resultado de una combinación izquierda

Después de una combinación izquierda, las filas del DataFrame izquierdo que no encontraron una correspondencia en el derecho tendrán NaN en todas las columnas procedentes de la tabla derecha. Puede utilizar esto para identificar las filas no coincidentes mediante un filtro booleano sobre una columna de la tabla derecha y para contar cuántas filas izquierdas no tuvieron correspondencia, lo que constituye una comprobación útil de la calidad de los datos.

result = pd.merge(orders, customers, on='customer_id', how='left')
print(result)
#    order_id  customer_id  amount   name
# 0         1          101     250  Alice
# 1         2          102      80    Bob
# 2         3          101     320  Alice
# 3         4          999     150    NaN  <- no matching customer

# Count unmatched
unmatched = result['name'].isna().sum()
print(f'{unmatched} orders have no customer record')

Cuándo usar una combinación izquierda

Las combinaciones izquierdas son apropiadas cuando su DataFrame izquierdo es la tabla principal y la tabla derecha es complementaria. Algunos casos habituales son enriquecer una tabla de hechos con una tabla de dimensiones (pedidos + nombres de productos), añadir metadatos opcionales (usuarios + datos de perfil) o calcular métricas para todos los registros aunque falle una búsqueda. En la mayoría del código de análisis, las combinaciones izquierdas son mucho más habituales que las derechas.

# Realistic pattern: enrich all products with optional category data
products = pd.DataFrame({'sku': ['A1', 'B2', 'C3'], 'price': [10, 20, 15]})
categories = pd.DataFrame({'sku': ['A1', 'C3'], 'category': ['Tools', 'Home']})

# Keep all products; add category where available
enriched = pd.merge(products, categories, on='sku', how='left')
print(enriched)
#    sku  price category
# 0   A1     10    Tools
# 1   B2     20      NaN
# 2   C3     15     Home

Combinación derecha: conservar todas las filas derechas

Una combinación derecha (how='right') es el reflejo de una combinación izquierda: conserva todas las filas del DataFrame derecho y rellena con NaN las columnas de la tabla izquierda cuando no existe una correspondencia. Las combinaciones derechas son menos habituales porque siempre puede obtener el mismo resultado intercambiando los argumentos de los DataFrames y usando una combinación izquierda, que resulta más clara para quienes leen el código.

# Right join: keep all customers, attach orders where they exist
result = pd.merge(orders, customers, on='customer_id', how='right')
print(result)
# All 3 customers appear; Carol (103) has NaN for order_id and amount

# Equivalent left join (swap arguments):
result2 = pd.merge(customers, orders, on='customer_id', how='left')
# Same data, just column order differs

Comparar los cuatro tipos de combinación

Los cuatro tipos de combinación solo se diferencian en las filas del lado no coincidente que conservan. inner: solo filas coincidentes. outer: todas las filas de ambos lados. left: todas las filas izquierdas. right: todas las filas derechas. En las entradas sin coincidencia, las columnas del lado ausente se rellenan con NaN. Elegir correctamente es fundamental para evitar descartar o duplicar registros silenciosamente.

# Summary table
# how='inner'  : rows in BOTH tables
# how='left'   : ALL left rows  + matched right
# how='right'  : matched left   + ALL right rows
# how='outer'  : ALL left rows  + ALL right rows

# Test each
for how in ['inner', 'left', 'right', 'outer']:
    r = pd.merge(orders, customers, on='customer_id', how=how)
    print(f'{how}: {len(r)} rows')

Rellenar NaN en los resultados de combinaciones izquierdas

Después de una combinación izquierda, las filas no coincidentes tienen NaN en las columnas de la tabla derecha. A menudo querrá rellenar estos valores con valores predeterminados adecuados, como 'Unknown' para una categoría ausente o 0 para un recuento ausente. Use fillna() en el resultado o pase fill_value en las operaciones aritméticas posteriores a la combinación.

result = pd.merge(products, categories, on='sku', how='left')
result['category'] = result['category'].fillna('Uncategorised')
print(result)
#    sku  price       category
# 0   A1     10          Tools
# 1   B2     20  Uncategorised
# 2   C3     15           Home

Anti-combinación izquierda: filas sin coincidencia

Un patrón útil que no admite directamente how es la anti-combinación: conservar únicamente las filas izquierdas que NO tienen correspondencia en la tabla derecha. Impleméntelo con una combinación izquierda usando indicator=True y, después, filtre por _merge == 'left_only'. Es perfecto para encontrar registros huérfanos, elementos nuevos que no aparecen en una lista de referencia o transacciones ausentes en un libro mayor.

# Anti-join: orders with no matching customer record
result = pd.merge(orders, customers, on='customer_id',
                  how='left', indicator=True)
unmatched_orders = result[result['_merge'] == 'left_only'].drop(columns='_merge')
print(unmatched_orders)
#    order_id  customer_id  amount  name
# 3         4          999     150   NaN

Conservar el número de filas con una combinación izquierda

Cuando el DataFrame derecho tiene claves únicas, una combinación izquierda garantiza conservar exactamente el número de filas de la tabla izquierda. Sin embargo, si la tabla derecha tiene valores de clave duplicados, la combinación izquierda multiplica las filas igual que una combinación interna. Compruebe siempre que el número de filas de salida coincide con el de la tabla izquierda cuando espere una relación de uno a varios.

# Right table has duplicate keys -> row multiplication
orders_small = pd.DataFrame({'id': [1, 2], 'amount': [100, 200]})
multi_customer = pd.DataFrame({
    'id': [1, 1],  # duplicate!
    'contact': ['Alice', 'Alice2']
})

result = pd.merge(orders_small, multi_customer, on='id', how='left')
print(len(result))  # 3 rows! order 1 appears twice
print(result)

Patrón de combinación izquierda en un caso real

Este es un flujo de trabajo completo de un caso real: comience con un registro de transacciones, haga una combinación izquierda con un catálogo de productos para obtener los nombres y, después, otra combinación izquierda con una tabla de clientes para obtener sus nombres. Rellene las búsquedas sin coincidencia con valores predeterminados. La cadena de combinaciones izquierdas garantiza que se conserve cada fila de transacción aunque falte el registro del producto o del cliente en las tablas de referencia.

transactions = pd.DataFrame({
    'txn_id': [1, 2, 3],
    'cust_id': [10, 11, 99],
    'prod_id': [20, 21, 20],
    'total': [50, 30, 70]
})

custs = pd.DataFrame({'cust_id': [10, 11], 'cust_name': ['Alice', 'Bob']})
prods = pd.DataFrame({'prod_id': [20, 21], 'prod_name': ['Widget', 'Gadget']})

result = (
    transactions
    .merge(custs, on='cust_id', how='left')
    .merge(prods, on='prod_id', how='left')
)
print(result)

Decidir entre una combinación izquierda y una interna

La elección entre una combinación izquierda y una interna es una decisión de lógica de negocio: ¿debe conservar los registros que no tienen una correspondencia en la búsqueda o descartarlos silenciosamente? Use una combinación izquierda cuando las búsquedas sin coincidencia sean aceptables y quiera conservar todos los registros principales. Use una combinación interna cuando una búsqueda sin coincidencia indique que el registro no es válido y deba excluirse del análisis. Documente siempre cuál eligió y por qué.

# Left join: keep all transactions (some may have no product name)
result_left = pd.merge(transactions, prods, on='prod_id', how='left')
print('Left join rows:', len(result_left))   # same as transactions

# Inner join: only transactions with known product
result_inner = pd.merge(transactions, prods, on='prod_id', how='inner')
print('Inner join rows:', len(result_inner))  # may be fewer

Comprobación rápida

Compruebe lo que ha aprendido sobre las combinaciones izquierdas y derechas en esta lección.

Resumen de la lección

En esta lección ha aprendido que la combinación izquierda conserva todas las filas del DataFrame izquierdo y rellena con NaN las columnas derechas cuando no hay coincidencia; la combinación derecha es su reflejo; el patrón de anti-combinación con indicator=True encuentra las filas izquierdas sin correspondencia derecha; y la elección entre una combinación izquierda y una interna es una decisión de lógica de negocio. A continuación, exploraremos cómo combinar DataFrames mediante su índice en lugar de una columna.

Preguntas frecuentes

¿La lección «Joins izquierdo y derecho» es gratis?

Sí — el texto completo de «Joins izquierdo y derecho» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Joins izquierdo y derecho»?

Realice joins izquierdos y derechos para conservar todas las filas de una tabla y hacer coincidir los registros de otra. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Joins izquierdo y derecho»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. pd.concat para apilar DataFrames
  2. pd.merge: joins internos y externos
  3. Joins izquierdo y derecho
  4. Unir por el índice
← Volver a Pandas & NumPy Academy