# Hvordan slå sammen DataFrames med pandas merge() Med pandas-funksjonen `DataFrame.merge()` kan du kombinere DataFrames ved hjelp av nøkler. Dette gjør det mulig å kombinere data fra ulike kilder på en effektiv måte, slik at du kan utføre mer omfattende analyser. ## Hva er syntaksen for pandas `merge()`? Python pandas DataFrame `merge()` metoden kan akseptere en rekke forskjellige parametere, slik at utviklere kan spesifisere hvordan DataFrames skal kombineres. Den generelle syntaksen til `merge()` er som følger: ```python DataFrame.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) ``` Note Funksjonen pandas `merge()` ligner JOIN-operasjonen i SQL. Erfaring med relasjonsdatabaser som [SQL](https://www.ionos.com/nb-no/digitalguide/server/kunnskap/hva-er-sql/) kan gjøre det lettere å forstå hvordan metoden pandas DataFrame `merge()` fungerer. Husk imidlertid at det er noen forskjeller. I pandas vil verdiene også slås sammen hvis begge nøkkelkolonnene har verdier som evalueres til *null*. ### Hvilke parametere kan brukes med pandas `merge`? De ulike parametrene som aksepteres av `merge()` lar deg ikke bare spesifisere hvilke [pandas DataFrames](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-dataframe/) som skal kombineres, men også hvilken type sammenføyning som skal brukes, samt andre detaljer.
Parameter Beskrivelse Standardverdi
venstre Den første DataFrame som skal slås sammen
høyre Den andre DataFrame som skal slås sammen
hvordan Hvilken type sammenføyningsoperasjon som skal utføres (`inner`, `outer`, `left`, `right`) `inner`
på Kolonnen(e) eller indeksnivået(ene) som skal brukes som nøkler; må være til stede i begge DataFrames
left\_on Kolonnen(e) eller indeksnivået(ene) i den venstre DataFrame som skal brukes som nøkkel(er)
right\_on Kolonnen(e) eller indeksnivået(ene) i den høyre DataFrame som skal brukes som nøkkel(er)
left\_index Hvis `True`, brukes indeksen til venstre DataFrame som nøkkel `False`
right\_index Hvis `True`, brukes indeksen til høyre DataFrame som nøkkel. `False`
sort Hvis `True`, sorteres nøklene i den resulterende DataFrame leksikografisk. `False`
suffikser Suffikser som brukes til å skille mellom kolonner med samme navn. `("_x", "_y")`
kopi Hvis `False`, unngås kopiering `True`
## Hvordan bruke pandas `merge()` Nedenfor er noen eksempler som illustrerer hvordan du kan bruke pandas `merge()` effektivt. ### `INNER JOIN` En INNER JOIN kombinerer to pandas DataFrames og **returnerer bare radene der nøklene samsvarer i begge DataFrames**. For å få en bedre forståelse av hvordan dette fungerer, kan vi opprette to DataFrames: ```python import pandas as pd # Sample DataFrames df1 = pd.DataFrame({ 'Key': ['A', 'B', 'C'], 'Value1': [1, 2, 3] }) df2 = pd.DataFrame({ 'Key': ['B', 'C', 'D'], 'Value2': [4, 5, 6] }) print(df1) print(df2) ``` De to resulterende DataFrames ser slik ut: ```none Key Value1 0 A 1 1 B 2 2 C 3 Key Value2 0 B 4 1 C 5 2 D 6 ``` Nå kan vi utføre en `INNER JOIN` ved hjelp av funksjonen `merge()`: ```python # INNER JOIN result = pd.merge(df1, df2, how='inner', on='Key') print(result) ``` Utdataene viser at bare radene som har nøklene B og C er inkludert i DataFrame. Dette skyldes at disse to nøklene finnes i **begge de opprinnelige DataFrames**. ```none Key Value1 Value2 0 B 2 4 1 C 3 5 ``` ### `OUTER JOIN` An `OUTER JOIN` slår også sammen to DataFrames, men i motsetning til `INNER JOIN` returnerer den **alle radene** og fyller ut **manglende verdier med `NaN`**. ```python # OUTER JOIN result = pd.merge(df1, df2, how='outer', on='Key') print(result) ``` DataFrame nedenfor inneholder **alle radene fra begge DataFrames**. `NaN` brukes for manglende verdier i nøkkel A, som bare finnes i `df1`, og nøkkel D, som bare finnes i `df2`. ```none Key Value1 Value2 0 A 1.0 NaN 1 B 2.0 4.0 2 C 3.0 5.0 3 D NaN 6.0 ``` Note De andre standardvariantene av `JOIN` fungerer på lignende måte. ### Bruke `left_on` og `right_on` Noen ganger har to DataFrames forskjellige kolonnenavn for nøklene sine. I dette tilfellet kan du bruke parameterne `left_on` og `right_on` til å spesifisere hvilke kolonner som skal brukes. Først skal vi opprette to nye DataFrames: ```python df3 = pd.DataFrame({ 'Key': ['A', 'B', 'C'], 'Value1': [1, 2, 3] }) df4 = pd.DataFrame({ 'Key2': ['B', 'C', 'D'], 'Value2': [4, 5, 6] }) print(df3) print(df4) ``` De to DataFrames ser slik ut: ```none Key Value1 0 A 1 1 B 2 2 C 3 Key2 Value2 0 B 4 1 C 5 2 D 6 ``` Vi kan bruke parameterne `left_on` og `right_on` til å utføre operasjonen `JOIN` ved hjelp av forskjellige nøkler: ```python # Join with different key column names result = pd.merge(df3, df4, how='inner', left_on='Key', right_on='Key2') print(result) ``` Ved å eksplisitt bruke `left_on='Key'` og `right_on='Key2'`, blir de tilsvarende nøkkelkolonnene brukt til sammenslåingen. ```none Key Value1 Key2 Value2 0 B 2 B 4 1 C 3 C 5 ``` ### Bruk av indekser som nøkler Du kan også bruke **indeksene til DataFrames som nøkler** ved å sette parameterne `left_index` og `right_index` til `True`. Først skal vi opprette to nye DataFrames med indekser: ```python df5 = pd.DataFrame({ 'Value1': [1, 2, 3] }, index=['A', 'B', 'C']) df6 = pd.DataFrame({ 'Value2': [4, 5, 6] }, index=['B', 'C', 'D']) print(df5) print(df6) ``` Her er DataFrames: ```none Value1 A 1 B 2 C 3 Value2 B 4 C 5 D 6 ``` Nå kan vi utføre en `JOIN` -operasjon ved hjelp av indeksene: ```python # JOIN with indices result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True) print(result) ``` Resultatet er en `JOIN` som bruker indeksene fra DataFrames: ```none Value1 Value2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-sammenslaaing-av-dataframe/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-sammenslaaing-av-dataframe/) for AI/LLM consumption.