Med pandas-funk­tio­nen DataFrame.merge() kan du kombinera Da­taFrames med hjälp av nycklar. Detta gör att du effektivt kan kombinera data från olika källor, vilket gör det möjligt att utföra mer om­fat­tan­de analyser.

Vad är syntaxen för pandas merge()?

Python pandas DataFrame merge() -metoden kan acceptera en rad olika pa­ra­met­rar, vilket gör det möjligt för ut­veck­la­re att ange hur Da­taFrames ska kom­bi­ne­ras. Den allmänna syntaxen för merge() funk­tio­nen är följande:

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

Vilka pa­ra­met­rar kan användas med pandas merge?

De olika pa­ra­met­rar­na som ac­cep­te­ras av merge() gör att du inte bara kan ange vilka pandas Da­taFrames som ska kom­bi­ne­ras, utan också vilken typ av sam­man­fog­ning som ska användas samt andra detaljer.

Parameter Be­skriv­ning Stan­dard­vär­de
vänster Den första DataFrame som ska slås samman
höger Den andra DataFrame som ska slås samman
hur Typ av sam­man­fog­nings­o­pe­ra­tion som ska utföras (inner, outer, left, right) inner
på Den eller de kolumner eller in­dex­ni­vå­er som ska användas som nycklar; måste finnas i båda Da­taFrames.
left_on Kolumn(er) eller indexnivå(er) i den vänstra DataFrame som ska användas som nyckel(er)
right_on Kolumn(er) eller indexnivå(er) i den högra DataFrame som ska användas som nyckel(ar)
left_index Om True används indexet för den vänstra DataFrame som nyckel False
right_index Om True används indexet för den högra DataFrame som nyckel. False
sortera Om True, sorteras nycklarna i den re­sul­te­ran­de DataFrame lex­i­co­gra­fiskt. False
suffix Suffix som används för att skilja kolumner med samma namn åt. ("_x", "_y")
kopia Om False, undviks en kopia. True

Hur man använder pandas merge()

Nedan följer några exempel som il­lu­stre­rar hur man använder pandas merge() på ett effektivt sätt.

INNER JOIN

En INNER JOIN kom­bi­ne­rar två pandas Da­taFrames och re­tur­ne­rar endast de rader där nycklarna matchar i båda Da­taFrames. För att få en bättre upp­fatt­ning om hur detta fungerar, låt oss skapa två Da­taFrames:

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 två re­sul­te­ran­de Da­taFrames ser ut så här:

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 utföra en INNER JOIN med hjälp av funk­tio­nen merge():

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

Ut­mat­ning­en visar att endast raderna som har nycklarna B och C ingår i DataFrame. Detta beror på att dessa två nycklar finns i båda de ur­sprung­li­ga Da­taFrames.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN slår också samman två Da­taFrames, men till skillnad från INNER JOIN re­tur­ne­rar den alla rader och fyller i saknade värden med NaN.

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

DataFrame nedan in­ne­hål­ler alla rader från båda Da­taFrames. NaN används för de saknade värdena i nyckel A, som endast finns i df1, och nyckel D, som endast finns 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
Notis

De andra stan­dard­va­ri­an­ter­na av JOIN fungerar på liknande sätt.

An­vänd­ning av left_on och right_on

Ibland har två Da­taFrames olika ko­lumn­namn för sina nycklar. I så fall kan du använda pa­ra­met­rar­na left_on och right_on för att ange vilka kolumner som ska användas. Låt oss först skapa två nya Da­taFrames:

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 två Da­taFrames ser ut så här:

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

Vi kan använda pa­ra­met­rar­na left_on och right_on för att utföra ope­ra­tio­nen JOIN med olika nycklar:

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

Genom att ut­tryck­li­gen använda left_on='Key' och right_on='Key2' används mot­sva­ran­de nyc­kel­ko­lum­ner för sam­man­slag­ning­en.

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

Använda index som nycklar

Du kan också använda indexen i Da­taFrames som nycklar genom att ställa in pa­ra­met­rar­na left_index och right_index till True. Låt oss först skapa två nya Da­taFrames med index:

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

Här är Da­taFrames:

Value1
A        1
B        2
C        3
    Value2
B        4
C        5
D        6

Nu kan vi utföra en JOIN -operation med hjälp av indexen:

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

Re­sul­ta­tet är en JOIN som använder indexen från Da­taFrames:

Value1  Value2
B        2        4
C        3        5
Gå till huvudmeny