Pandas & NumPy Academy · Lektion

Vänster- och högerjoin

Gör vänster- och högerjoin för att bevara alla rader från en tabell samtidigt som poster från en annan matchas.

Lektion 3 av 413 steg

Vänster- och högerjoin är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Asymmetriska joins

Inner- och outer-joins behandlar båda DataFrames symmetriskt. Ofta vill du dock bevara alla poster från en tabell och berika dem med data från en annan. Det är här left joins och right joins kommer in. Dessa asymmetriska joins är mycket vanliga inom analys: behåll alla transaktioner och lägg till produktnamn där de finns; behåll alla användare och lägg till datumet för deras senaste köp om de har gjort något köp.

Left join: bevara alla vänstra rader

En left join (how='left') behåller varje rad från den vänstra DataFrame:n. För rader som hittar en matchande nyckel i den högra DataFrame:n fylls de högra kolumnerna med de matchande värdena. För rader utan matchning fylls de högra kolumnerna med NaN. Resultatets radantal är alltid samma som radantalet i den vänstra DataFrame:n (förutsatt att det inte finns några dubbletta nycklar).

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

Strukturen hos resultatet av en left join

Efter en left join innehåller rader från den vänstra DataFrame:n som inte hittade någon matchning i den högra NaN i varje kolumn som kommer från den högra tabellen. Du kan använda detta för att identifiera omatchade rader med ett booleskt filter på en kolumn från den högra tabellen och räkna hur många vänstra rader som saknade matchning — en användbar kontroll av datakvaliteten.

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')

När ska du använda en left join?

Left-joins passar när din vänstra DataFrame är huvudtabellen och den högra tabellen innehåller kompletterande data. Vanliga scenarier är att berika en faktatabell med en dimensionstabell (orders + produktnamn), lägga till valfria metadata (användare + profildata) eller beräkna mått för alla poster även när en uppslagning misslyckas. I de flesta analysprogram är left-joins betydligt vanligare än right-joins.

# 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

Right join: bevara alla högra rader

En right join (how='right') är spegelbilden av en left join: den behåller varje rad från den högra DataFrame:n och fyller kolumner från den vänstra tabellen med NaN där det saknas en matchning. En right join är mindre vanlig eftersom du alltid kan uppnå samma resultat genom att byta plats på DataFrame-argumenten och använda en left join i stället, vilket är tydligare för läsaren.

# 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

Jämför alla fyra join-typer

De fyra join-typerna skiljer sig endast åt genom vilka rader från den omatchade sidan som bevaras. inner: endast matchande rader. outer: alla rader från båda sidor. left: alla vänstra rader. right: alla högra rader. För omatchade poster fylls kolumner från den sida som saknas med NaN. Det är avgörande att välja rätt typ för att undvika att poster tyst tas bort eller dupliceras.

# 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')

Fyll NaN i resultat från left-joins

Efter en left join innehåller omatchade rader NaN i kolumnerna från den högra tabellen. Ofta vill du ersätta dessa med rimliga standardvärden — till exempel 'Unknown' för en saknad kategori eller 0 för ett saknat antal. Använd fillna() på resultatet eller skicka med fill_value i de aritmetiska operationer som följer efter joinen.

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

Left anti-join: rader utan matchning

Ett användbart mönster som inte stöds direkt av how är en anti-join: behåll endast vänstra rader som INTE har någon matchning i den högra tabellen. Implementera detta med en left join och indicator=True, och filtrera sedan på _merge == 'left_only'. Detta passar perfekt för att hitta övergivna poster, nya objekt som inte finns i en referenslista eller transaktioner som saknas i en redovisning.

# 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

Bevara radantalet med en left join

När den högra DataFrame:n har unika nycklar är det garanterat att en left join bevarar exakt samma radantal som den vänstra tabellen. Om den högra tabellen däremot har dubbletta nyckelvärden multiplicerar left joinen rader på samma sätt som en inner join. Kontrollera alltid att resultatets radantal överensstämmer med den vänstra tabellens när du förväntar dig en en-till-många-relation.

# 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)

Ett praktiskt mönster för left join

Här är ett komplett praktiskt arbetsflöde: börja med en transaktionslogg, gör en left join med en produktkatalog för att hämta namn och gör sedan en left join med en kundtabell för att hämta namn. Ersätt saknade uppslagningar med standardvärden. Kedjan av left-joins säkerställer att varje transaktionsrad bevaras även om produkt- eller kundposten saknas i referenstabellerna.

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)

Välj mellan left join och inner join

Valet mellan left och inner join är ett beslut om verksamhetslogik: ska du behålla poster som saknar en uppslagsmatchning eller ta bort dem utan meddelande? Använd left join när saknade uppslagningar är acceptabla och du vill behålla alla primära poster. Använd inner join när en saknad uppslagning innebär att posten är ogiltig och ska uteslutas från analysen. Dokumentera alltid vad du valde och varför.

# 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

Snabb kontroll

Testa dina kunskaper om left- och right-joins från den här lektionen.

Repetition av lektionen

I den här lektionen lärde du dig att left join bevarar alla rader från den vänstra DataFrame:n och fyller de högra kolumnerna med NaN för rader utan matchning; right join är spegelbilden; anti-join-mönstret med indicator=True hittar vänstra rader utan matchning i högerledet; och valet mellan left och inner join är ett beslut om verksamhetslogik. Härnäst utforskar vi hur du sammanfogar DataFrames på deras index i stället för på en kolumn.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Vänster- och högerjoin” gratis?

Ja – hela texten till ”Vänster- och högerjoin” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Vänster- och högerjoin”?

Gör vänster- och högerjoin för att bevara alla rader från en tabell samtidigt som poster från en annan matchas. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Vänster- och högerjoin”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. pd.concat för att stapla DataFrames
  2. pd.merge: inre och yttre join
  3. Vänster- och högerjoin
  4. Joina på index
← Tillbaka till Pandas & NumPy Academy