22. september 2025Norsk

En omfattende guide til sammenslåing av DataFrames i Python Pandas. Dekker indre, ytre, venstre og høyre koblinger med praktiske eksempler for global dataanalyse.

Python Pandas Sammenslåing: Mestring av DataFrame-koblingsstrategier for dataanalyse

Datamanipulering er et avgjørende aspekt ved dataanalyse, og Pandas-biblioteket i Python tilbyr kraftige verktøy for dette formålet. Blant disse verktøyene er sammenslåing og kobling av DataFrames essensielle operasjoner for å kombinere datasett basert på felles kolonner eller indekser. Denne omfattende guiden utforsker ulike DataFrame-koblingsstrategier i Pandas, og utruster deg med kunnskapen til effektivt å kombinere og analysere data fra forskjellige kilder.

Forståelse av DataFrame-sammenslåing og -kobling

Sammenslåing og kobling av DataFrames innebærer å kombinere to eller flere DataFrames til én enkelt DataFrame basert på en felles kolonne eller indeks. Hovedforskjellen mellom `merge` og `join` er at `merge` er en funksjon av Pandas-biblioteket og vanligvis kobler DataFrames på kolonner, mens `join` er en DataFrame-metode som primært kobler DataFrames på indekser, selv om den også kan brukes med kolonner.

Nøkkelkonsepter

DataFrames: To-dimensjonale merkede datastrukturer med kolonner av potensielt forskjellige typer.
Felles Kolonner/Indekser: Kolonner eller indekser som deler samme navn og datatype på tvers av DataFrames, og fungerer som grunnlag for sammenslåing/kobling.
Koblingstyper: Ulike strategier for håndtering av uoverensstemmende rader under sammenslåings-/koblingsprosessen, inkludert indre, ytre, venstre og høyre koblinger.

DataFrame-sammenslåing med `pd.merge()`

Funksjonen `pd.merge()` er det primære verktøyet for å slå sammen DataFrames basert på kolonner. Den tilbyr en fleksibel måte å kombinere data basert på en eller flere felles kolonner.

Syntaks

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

Parametre

left: Den venstre DataFramen som skal slås sammen.
right: Den høyre DataFramen som skal slås sammen.
how: Typen sammenslåing som skal utføres ('inner', 'outer', 'left', 'right'). Standard er 'inner'.
on: Navnet på kolonnen(e) å koble på. Disse må finnes i begge DataFrames.
left_on: Navnet på kolonnen(e) i den venstre DataFramen som skal brukes som koblingsnøkler.
right_on: Navnet på kolonnen(e) i den høyre DataFramen som skal brukes som koblingsnøkler.
left_index: Hvis Sann, bruk indeksen fra den venstre DataFramen som koblingsnøkkel(er).
right_index: Hvis Sann, bruk indeksen fra den høyre DataFramen som koblingsnøkkel(er).
sort: Sorter resultat-DataFramen leksikografisk etter koblingsnøklene. Standard er Usann.
suffixes: En tuppel av streng-suffikser som skal brukes på overlappende kolonnenavn. Standard er ('_x', '_y').
copy: Hvis Usann, unngå å kopiere data til den nye DataFramen der det er mulig. Standard er Sann.
indicator: Hvis Sann, legger til en kolonne kalt '_merge' som indikerer kilden til hver rad.
validate: Sjekker om sammenslåingen er av spesifisert type. "one_to_one", "one_to_many", "many_to_one", "many_to_many".

Koblingstyper forklart

Parameteret `how` i `pd.merge()` bestemmer typen kobling som utføres. De forskjellige koblingstypene håndterer uoverensstemmende rader på forskjellige måter.

Indre Kobling

En indre kobling returnerer kun radene som har samsvarende verdier i begge DataFrames basert på koblingsnøklene. Rader med uoverensstemmende verdier utelukkes fra resultatet.

Eksempel:

Vurder to DataFrames:

            import pandas as pd

# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
 'order_id': [1, 2, 3, 4, 5],
 'customer_id': [101, 102, 103, 104, 105],
 'product_id': [1, 2, 1, 3, 2],
 'quantity': [2, 1, 3, 1, 2]
})

# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
 'customer_id': [101, 102, 103, 106],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
 'country': ['USA', 'Canada', 'UK', 'Australia']
})

# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)

Utdata:

             order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK

I dette eksemplet kombinerer den indre koblingen `df_orders` og `df_customers` DataFrames basert på `customer_id`-kolonnen. Kun kunder som har lagt inn bestillinger er inkludert i resultatet. Kunden 'David' (customer_id 106) er ekskludert fordi han ikke har noen bestillinger.

Ytre Kobling (Full Ytre Kobling)

En ytre kobling returnerer alle rader fra begge DataFrames, inkludert uoverensstemmende rader. Hvis en rad ikke har en match i den andre DataFramen, vil de tilsvarende kolonnene inneholde `NaN` (Not a Number) verdier.

Eksempel:

            # Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)

Utdata:

               order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       4.0          104         3.0       1.0           NaN        NaN
4       5.0          105         2.0       2.0           NaN        NaN
5       NaN          106         NaN       NaN         David   Australia

Den ytre koblingen inkluderer alle kunder og alle bestillinger. Kunder 104 og 105 har bestillinger, men ingen kundeinformasjon, og kunde 106 har kundeinformasjon, men ingen bestillinger. De manglende verdiene er representert som `NaN`.

Venstre Kobling

En venstre kobling returnerer alle rader fra den venstre DataFramen og de samsvarende radene fra den høyre DataFramen. Hvis en rad i den venstre DataFramen ikke har en match i den høyre DataFramen, vil de tilsvarende kolonnene fra den høyre DataFramen inneholde `NaN`-verdier.

Eksempel:

            # Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)

Utdata:

               order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Den venstre koblingen inkluderer alle bestillinger fra `df_orders`. Kunder 104 og 105 har bestillinger, men ingen kundeinformasjon, så kolonnene `customer_name` og `country` er `NaN` for disse bestillingene.

Høyre Kobling

En høyre kobling returnerer alle rader fra den høyre DataFramen og de samsvarende radene fra den venstre DataFramen. Hvis en rad i den høyre DataFramen ikke har en match i den venstre DataFramen, vil de tilsvarende kolonnene fra den venstre DataFramen inneholde `NaN`-verdier.

Eksempel:

            # Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)

Utdata:

               order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       NaN          106         NaN       NaN         David   Australia

Den høyre koblingen inkluderer alle kunder fra `df_customers`. Kunde 106 har kundeinformasjon, men ingen bestillinger, så kolonnene `order_id`, `product_id` og `quantity` er `NaN` for den kunden.

DataFrame-kobling med `df.join()`

Metoden `df.join()` brukes primært til å koble DataFrames basert på deres indekser. Den kan også brukes til å koble på kolonner, men det er vanligvis mer praktisk å bruke `pd.merge()` for kolonnebaserte koblinger.

Syntaks

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

Parametre

other: Den andre DataFramen som skal kobles.
on: Kolonnenavn å koble på. Må sendes inn hvis indeksen ikke brukes som koblingsnøkkel.
how: Hvordan operasjonen av venstre og høyre sett skal håndteres. Standard er 'left'.
lsuffix: Suffiks som skal brukes fra venstre DataFrame for å overstyre overlappende kolonnenavn.
rsuffix: Suffiks som skal brukes fra høyre DataFrame for å overstyre overlappende kolonnenavn.
sort: Sorter resultat-DataFramen leksikografisk etter koblingsnøklene. Standard er Usann.

Kobling på Indeks

Når du kobler på indeksen, brukes ikke `on`-parameteret.

Eksempel:

            # DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')

# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')

# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)

Utdata:

               order_id  product_id  quantity customer_name country
customer_id                                        
101                 1           1         2         Alice     USA
102                 2           2         1           Bob  Canada
103                 3           1         3       Charlie      UK
104                 4           3         1           NaN     NaN
105                 5           2         2           NaN     NaN

I dette eksemplet brukes `join()`-metoden til å utføre en venstre kobling på indeksen (`customer_id`). Resultatet ligner på den venstre koblingen ved bruk av `pd.merge()`, men koblingen er basert på indeksen snarere enn en kolonne.

Kobling på Kolonne

For å koble på en kolonne ved hjelp av `df.join()`, må du spesifisere `on`-parameteret.

Eksempel:

            # Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)

Utdata:

               order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Dette eksemplet demonstrerer kobling av `df_orders` med `df_customers` ved hjelp av `customer_id`-kolonnen. Legg merke til at `customer_id` er satt som indeks i `df_customers` før koblingen utføres.

Håndtering av Overlappende Kolonner

Når du slår sammen eller kobler DataFrames, er det vanlig å støte på overlappende kolonnenavn (kolonner med samme navn i begge DataFrames). Pandas tilbyr `suffixes`-parameteret i `pd.merge()` og `lsuffix`- og `rsuffix`-parametrene i `df.join()` for å håndtere disse situasjonene.

Bruk av `suffixes` i `pd.merge()`

Parameteret `suffixes` lar deg spesifisere suffikser som vil bli lagt til de overlappende kolonnenavnene for å skille dem.

Eksempel:

            # DataFrame 1: Product Information
df_products1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Product A', 'Product B', 'Product C'],
 'price': [10, 20, 15]
})

# DataFrame 2: Product Information (med potensielt oppdaterte priser)
df_products2 = pd.DataFrame({
 'product_id': [1, 2, 4],
 'product_name': ['Product A', 'Product B', 'Product D'],
 'price': [12, 18, 25]
})

# Merge med suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)

Utdata:

               product_id product_name_old  price_old product_name_new  price_new
0           1      Product A         10       Product A         12
1           2      Product B         20       Product B         18

I dette eksemplet er kolonnene `product_name` og `price` til stede i begge DataFrames. `suffixes`-parameteret legger til suffiksene `_old` og `_new` for å skille kolonnene fra henholdsvis venstre og høyre DataFrame.

Bruk av `lsuffix` og `rsuffix` i `df.join()`

`lsuffix`- og `rsuffix`-parametrene tilbyr lignende funksjonalitet for `df.join()`. `lsuffix` legger til venstre DataFrames overlappende kolonner, og `rsuffix` til høyre DataFrames.

Eksempel:

            # Join med lsuffix og rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)

Utdata:

                      product_name_old  price_old product_name_new  price_new
product_id                                                     
1                 Product A       10.0        Product A       12.0
2                 Product B       20.0        Product B       18.0
3                 Product C       15.0            NaN        NaN
4                       NaN        NaN        Product D       25.0

Praktiske Eksempler og Brukstilfeller

Sammenslåing og kobling av DataFrames er mye brukt i ulike dataanalysesenarioer. Her er noen praktiske eksempler:

Kombinere Salgsdata med Produktinformasjon

Et vanlig brukstilfelle er å kombinere salgsdata med produktinformasjon. Anta at du har en DataFrame som inneholder salgstransaksjoner og en annen DataFrame som inneholder produktdetaljer. Du kan slå sammen disse DataFrames for å berike salgsdataene med produktinformasjon.

Eksempel:

            # Sales Transactions Data
df_sales = pd.DataFrame({
 'transaction_id': [1, 2, 3, 4, 5],
 'product_id': [101, 102, 103, 101, 104],
 'quantity': [2, 1, 3, 1, 2],
 'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})

# Product Information Data
df_products = pd.DataFrame({
 'product_id': [101, 102, 103, 104],
 'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
 'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
 'price': [1200, 25, 75, 300]
})

# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)

Utdata:

               transaction_id  product_id  quantity sales_date product_name     category   price
0               1         101         2   2023-01-15       Laptop  Electronics  1200
1               2         102         1   2023-02-20        Mouse  Electronics    25
2               3         103         3   2023-03-10     Keyboard  Electronics    75
3               4         101         1   2023-04-05       Laptop  Electronics  1200
4               5         104         2   2023-05-01      Monitor  Electronics   300

Den resulterende DataFramen `df_sales_enriched` inneholder salgstransaksjonene sammen med tilsvarende produktinformasjon, noe som muliggjør en mer detaljert analyse av salgstrender og produktprestasjoner.

Kombinere Kundedata med Demografisk Informasjon

Et annet vanlig brukstilfelle er å kombinere kundedata med demografisk informasjon. Dette gjør det mulig å analysere kundeatferd basert på demografiske faktorer.

Eksempel:

            # Customer Data
df_customers = pd.DataFrame({
 'customer_id': [1, 2, 3, 4, 5],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})

# Demographic Information Data
df_demographics = pd.DataFrame({
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
 'population': [8419000, 8982000, 13960000, 5312000, 3769000],
 'average_income': [75000, 65000, 85000, 90000, 55000]
})

# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)

Utdata:

               customer_id customer_name      city  population  average_income
0            1         Alice  New York     8419000           75000
1            2           Bob    London     8982000           65000
2            3       Charlie     Tokyo    13960000           85000
3            4         David    Sydney     5312000           90000
4            5           Eve    Berlin     3769000           55000

Den resulterende DataFramen `df_customer_demographics` inneholder kundedata sammen med demografisk informasjon for deres respektive byer, noe som muliggjør analyse av kundeatferd basert på bydemografi.

Analyse av Global Forsyningskjede Data

Pandas-sammenslåing er verdifullt for å analysere globale forsyningskjededata, der informasjon ofte er spredt over flere tabeller. For eksempel kan kobling av leverandørdata, fraktinformasjon og salgstall avsløre flaskehalser og optimalisere logistikken.

Eksempel:

            # Supplier Data
df_suppliers = pd.DataFrame({
 'supplier_id': [1, 2, 3],
 'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
 'location': ['Taiwan', 'Germany', 'China']
})

# Shipping Data
df_shipments = pd.DataFrame({
 'shipment_id': [101, 102, 103, 104],
 'supplier_id': [1, 2, 3, 1],
 'destination': ['USA', 'Canada', 'Australia', 'Japan'],
 'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})


# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')

print(df_supply_chain)

Utdata:

               shipment_id  supplier_id destination shipment_date supplier_name location
0          101            1         USA    2023-01-10     GlobalTech   Taiwan
1          102            2      Canada    2023-02-15      EuroParts  Germany
2          103            3   Australia    2023-03-20     AsiaSource    China
3          104            1       Japan    2023-04-25     GlobalTech   Taiwan

Avanserte Sammenslåingsteknikker

Sammenslåing på Flere Kolonner

Du kan slå sammen DataFrames basert på flere kolonner ved å sende en liste med kolonnenavn til `on`-parameteret.

Eksempel:

            # DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'quantity': [10, 15, 20, 25]
})

# DataFrame 2
df2 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'price': [5, 7, 8, 10]
})

# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)

Utdata:

               product_id color  quantity  price
0           1   red        10      5
1           1  blue        15      7
2           2   red        20      8
3           2  blue        25     10

Sammenslåing med Ulike Kolonnenavn

Hvis koblingskolonnene har forskjellige navn i de to DataFrames, kan du bruke `left_on`- og `right_on`-parametrene for å spesifisere kolonnenavnene som skal brukes for sammenslåing.

Eksempel:

            # DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Product A', 'Product B', 'Product C']
})

# DataFrame 2
df2 = pd.DataFrame({
 'id': [1, 2, 4],
 'price': [10, 20, 25]
})

# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)

Utdata:

               product_id product_name   id   price
0           1    Product A  1.0    10.0
1           2    Product B  2.0    20.0
2           3    Product C  NaN     NaN

Hvis sammenslåingen bryter den spesifiserte valideringen (f.eks. en mange-til-en-relasjon når 'one_to_one' er spesifisert), vil en `MergeError` bli utløst, og varsle deg om potensielle dataintegritetsproblemer.

Bruk av `indicator` for Sammenslåingsanalyse

`indicator`-parameteret i `pd.merge()` legger til en kolonne kalt `_merge` til den resulterende DataFramen, som indikerer kilden til hver rad. Dette er nyttig for å forstå hvilke rader som ble matchet og hvilke som ikke ble det.

Eksempel:

            # Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)

Utdata:

               order_id  customer_id  product_id  quantity customer_name    country      _merge
0       1.0          101         1.0       2.0         Alice        USA        both
1       2.0          102         2.0       1.0           Bob     Canada        both
2       3.0          103         1.0       3.0       Charlie         UK        both
3       4.0          104         3.0       1.0           NaN        NaN   left_only
4       5.0          105         2.0       2.0           NaN        NaN   left_only
5       NaN          106         NaN       NaN         David   Australia  right_only

`_merge`-kolonnen indikerer om raden er fra begge DataFrames (`both`), kun fra venstre DataFrame (`left_only`), eller kun fra høyre DataFrame (`right_only`).

Validere Sammenslåingstyper

`validate`-parameteret sikrer at sammenslåingsoperasjonen stemmer overens med forventede relasjonstyper mellom DataFrames (f.eks. 'one_to_one', 'one_to_many'). Dette bidrar til å forhindre datainkonsekvenser og feil.

Eksempel:

            # Example with one-to-one validation
df_users = pd.DataFrame({
 'user_id': [1, 2, 3],
 'username': ['john_doe', 'jane_smith', 'peter_jones']
})

df_profiles = pd.DataFrame({
 'user_id': [1, 2, 3],
 'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})

# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')

print(merged_df)

Ytelsesbetraktninger

Sammenslåing og kobling av DataFrames kan være beregningsmessig dyrt, spesielt for store datasett. Her er noen tips for å forbedre ytelsen:

Bruk riktig koblingstype: Å velge riktig koblingstype kan ha stor innvirkning på ytelsen. For eksempel, hvis du bare trenger samsvarende rader, bruk en indre kobling.
Indekser koblingskolonnene: Indeksering av koblingskolonnene kan akselerere sammenslåingsprosessen.
Bruk passende datatyper: Sørg for at koblingskolonnene har kompatible datatyper.
Unngå unødvendige kopier: Sett `copy=False` i `pd.merge()` og `df.join()` for å unngå å lage unødvendige kopier av dataene.

Konklusjon

Sammenslåing og kobling av DataFrames er grunnleggende operasjoner innen dataanalyse. Ved å forstå de forskjellige koblingstypene og teknikkene, kan du effektivt kombinere og analysere data fra ulike kilder, låse opp verdifull innsikt og drive informert beslutningstaking. Fra å kombinere salgsdata med produktinformasjon til å analysere globale forsyningskjeder, vil mestring av disse teknikkene gi deg mulighet til å takle komplekse datamanipulasjonsoppgaver med selvtillit. Husk å vurdere ytelsesimplikasjoner når du arbeider med store datasett og dra nytte av avanserte funksjoner som `indicator`- og `validate`-parametrene for en mer robust og innsiktsfull analyse.