Med pandas-funk­tio­nen DataFrame.merge() kan du kombinere Da­ta­F­ra­mes ved hjælp af nøgler. Dette giver dig mulighed for effektivt at kombinere data fra for­skel­li­ge kilder, så du kan udføre mere om­fat­ten­de analyser.

Hvad er syntaksen for pandas merge()?

Python pandas DataFrame merge() kan acceptere en række for­skel­li­ge parametre, hvilket giver udviklere mulighed for at spe­ci­fi­ce­re, hvordan Da­ta­F­ra­mes skal kom­bi­ne­res. Den generelle syntaks for 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 parametre kan bruges med pandas merge?

De for­skel­li­ge parametre, der ac­cep­te­res af merge(), giver dig mulighed for ikke kun at angive, hvilke pandas Da­ta­F­ra­mes der skal kom­bi­ne­res, men også hvilken type sam­men­kob­ling der skal bruges, samt andre detaljer.

Parameter Be­skri­vel­se Stan­dard­vær­di
venstre Den første DataFrame, der skal flettes
højre Den anden DataFrame, der skal flettes
hvordan Den type sam­men­føj­nings­o­pe­ra­tion, der skal udføres (inner, outer, left, right) inner
på Den eller de kolonner eller in­deks­ni­veau­er, der skal bruges som nøgler; skal være til stede i begge Da­ta­F­ra­mes
left_on Den eller de kolonner eller in­deks­ni­veau­er i den venstre DataFrame, der skal bruges som nøgle(r)
right_on Kolonne(r) eller in­deks­ni­veau(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 re­sul­te­ren­de DataFrame lek­si­ko­gra­fisk. 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 il­lu­stre­rer, hvordan man bruger pandas merge() effektivt.

INNER JOIN

En INNER JOIN kom­bi­ne­rer to pandas Da­ta­F­ra­mes og re­tur­ne­rer kun de rækker, hvor nøglerne matcher i begge Da­ta­F­ra­mes. For at få en bedre idé om, hvordan dette fungerer, skal vi oprette to Da­ta­F­ra­mes:

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 re­sul­te­ren­de Da­ta­F­ra­mes ser således ud:

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 funk­tio­nen merge():

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

Outputtet viser, at kun de rækker, der har nøglerne B og C, er in­klu­de­ret i DataFrame. Dette skyldes, at disse to nøgler findes i begge de op­rin­de­li­ge Da­ta­F­ra­mes.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN fletter også to Da­ta­F­ra­mes, men i mod­sæt­ning til INNER JOIN re­tur­ne­rer den alle rækker og udfylder manglende værdier med NaN.

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

DataFrame nedenfor in­de­hol­der alle rækker fra begge Da­ta­F­ra­mes. 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.

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 stan­dard­va­ri­an­ter af JOIN fungerer på samme måde.

Brug af left_on og right_on

Nogle gange har to Da­ta­F­ra­mes for­skel­li­ge ko­lon­ne­nav­ne for deres nøgler. I dette tilfælde kan du bruge pa­ra­me­tre­ne left_on og right_on til at angive, hvilke kolonner der skal bruges. Lad os først oprette to nye Da­ta­F­ra­mes:

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 Da­ta­F­ra­mes ser således ud:

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 pa­ra­me­tre­ne left_on og right_on til at udføre ope­ra­tio­nen JOIN ved hjælp af for­skel­li­ge nøgler:

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

Ved eksplicit at bruge left_on='Key' og right_on='Key2' anvendes de til­sva­ren­de nøg­le­ko­lon­ner til sam­men­læg­nin­gen.

Key    Value1 Key2    Value2
0     B            2        B            4
1     C            3        C            5

Brug af indekser som nøgler

Du kan også bruge in­dek­ser­ne i Da­ta­F­ra­mes som nøgler ved at indstille pa­ra­me­tre­ne left_index og right_index til True. Lad os først oprette to nye Da­ta­F­ra­mes 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 Da­ta­F­ra­mes:

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 in­dek­ser­ne:

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

Re­sul­ta­tet er en JOIN, der bruger in­dek­ser­ne fra Da­ta­F­ra­mes:

Value1  Value2
B        2        4
C        3        5
Gå til ho­ved­me­nu­en