# Sådan flettes DataFrames med pandas merge() Med pandas-funktionen `DataFrame.merge()` kan du kombinere DataFrames ved hjælp af nøgler. Dette giver dig mulighed for effektivt at kombinere data fra forskellige kilder, så du kan udføre mere omfattende analyser. ## Hvad er syntaksen for pandas `merge()`? Python pandas DataFrame `merge()` kan acceptere en række forskellige parametre, hvilket giver udviklere mulighed for at specificere, hvordan DataFrames skal kombineres. Den generelle syntaks for `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 Pandas `merge()` funktionen svarer til JOIN-operationen i SQL. Erfaring med relationsdatabaser som [SQL](https://www.ionos.com/da-dk/digitalguide/server/know-how/hvad-er-sql/) kan gøre det lettere at forstå, hvordan pandas DataFrame `merge()` -metoden fungerer. Husk dog, at der er nogle forskelle. I pandas vil værdier, der evalueres til *null*, også blive flettet, hvis begge nøglekolonner har værdier, der evalueres til *null*. ### Hvilke parametre kan bruges med pandas `merge`? De forskellige parametre, der accepteres af `merge()`, giver dig mulighed for ikke kun at angive, hvilke [pandas DataFrames](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-dataframe/) der skal kombineres, men også hvilken type sammenkobling der skal bruges, samt andre detaljer.
Parameter Beskrivelse Standardværdi
venstre Den første DataFrame, der skal flettes
højre Den anden DataFrame, der skal flettes
hvordan Den type sammenføjningsoperation, der skal udføres (`inner`, `outer`, `left`, `right`) `inner`
på Den eller de kolonner eller indeksniveauer, der skal bruges som nøgler; skal være til stede i begge DataFrames
left\_on Den eller de kolonner eller indeksniveauer i den venstre DataFrame, der skal bruges som nøgle(r)
right\_on Kolonne(r) eller indeksniveau(er) i den højre DataFrame, der skal bruges som nøgle(r)
left\_index Hvis `True`, bruges indekset for den venstre DataFrame som nøgle `False`
right\_index Hvis `True`, bruges indekset for den højre DataFrame som nøgle. `False`
sort Hvis `True`, sorteres nøglerne i den resulterende DataFrame leksikografisk. `False`
suffikser Suffikser, der bruges til at skelne mellem kolonner med samme navn. `("_x", "_y")`
kopi Hvis `False`, undgås en kopi. `True`
## Sådan bruges pandas `merge()` Nedenfor er nogle eksempler, der illustrerer, hvordan man bruger pandas `merge()` effektivt. ### `INNER JOIN` En INNER JOIN kombinerer to pandas DataFrames og **returnerer kun de rækker, hvor nøglerne matcher i begge DataFrames**. For at få en bedre idé om, hvordan dette fungerer, skal vi oprette 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 således ud: ```none Key Value1 0 A 1 1 B 2 2 C 3 Key Value2 0 B 4 1 C 5 2 D 6 ``` Nu kan vi udføre en `INNER JOIN` ved hjælp af funktionen `merge()`: ```python # INNER JOIN result = pd.merge(df1, df2, how='inner', on='Key') print(result) ``` Outputtet viser, at kun de rækker, der har nøglerne B og C, er inkluderet i DataFrame. Dette skyldes, at disse to nøgler findes i **begge de oprindelige DataFrames**. ```none Key Value1 Value2 0 B 2 4 1 C 3 5 ``` ### `OUTER JOIN` An `OUTER JOIN` fletter også to DataFrames, men i modsætning til `INNER JOIN` returnerer den **alle rækker** og udfylder **manglende værdier med `NaN`**. ```python # OUTER JOIN result = pd.merge(df1, df2, how='outer', on='Key') print(result) ``` DataFrame nedenfor indeholder **alle rækker fra begge DataFrames**. `NaN` bruges til de manglende værdier i nøgle A, som kun findes i `df1`, og nøgle D, som kun findes 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 øvrige standardvarianter af `JOIN` fungerer på samme måde. ### Brug af `left_on` og `right_on` Nogle gange har to DataFrames forskellige kolonnenavne for deres nøgler. I dette tilfælde kan du bruge parametrene `left_on` og `right_on` til at angive, hvilke kolonner der skal bruges. Lad os først oprette 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 således ud: ```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 bruge parametrene `left_on` og `right_on` til at udføre operationen `JOIN` ved hjælp af forskellige nøgler: ```python # Join with different key column names result = pd.merge(df3, df4, how='inner', left_on='Key', right_on='Key2') print(result) ``` Ved eksplicit at bruge `left_on='Key'` og `right_on='Key2'` anvendes de tilsvarende nøglekolonner til sammenlægningen. ```none Key Value1 Key2 Value2 0 B 2 B 4 1 C 3 C 5 ``` ### Brug af indekser som nøgler Du kan også bruge **indekserne i DataFrames som nøgler** ved at indstille parametrene `left_index` og `right_index` til `True`. Lad os først oprette 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 ``` Nu kan vi udføre en `JOIN` operation ved hjælp af indekserne: ```python # JOIN with indices result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True) print(result) ``` Resultatet er en `JOIN`, der bruger indekserne fra DataFrames: ```none Value1 Value2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-sammenfletning-af-dataframe/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-sammenfletning-af-dataframe/) for AI/LLM consumption.