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:

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

Hvilke parametere kan brukes med pandas merge?

De ulike parametrene som aksepteres av merge() lar deg ikke bare spesifisere hvilke pandas DataFrames 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:

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

De to resulterende DataFrames ser slik ut:

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():

# INNER JOIN
result = pd.merge(df1, df2, how='inner', on='Key')
print(result)
python

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.

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.

# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Key')
print(result)
python

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.

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:

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

De to DataFrames ser slik ut:

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:

# Join with different key column names
result = pd.merge(df3, df4, how='inner', left_on='Key', right_on='Key2')
print(result)
python

Ved å eksplisitt bruke left_on='Key' og right_on='Key2', blir de tilsvarende nøkkelkolonnene brukt til sammenslåingen.

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:

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

Her er DataFrames:

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:

# JOIN with indices
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)
python

Resultatet er en JOIN som bruker indeksene fra DataFrames:

Value1  Value2
B        2        4
C        3        5
Go to Main Menu