Med pandas-funktionen DataFrame.merge() kan du kombinera DataFrames 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 omfattande analyser.

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

Python pandas DataFrame merge() -metoden kan acceptera en rad olika parametrar, vilket gör det möjligt för utvecklare att ange hur DataFrames ska kombineras. Den allmänna syntaxen för merge() funktionen ä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 parametrar kan användas med pandas merge?

De olika parametrarna som accepteras av merge() gör att du inte bara kan ange vilka pandas DataFrames som ska kombineras, utan också vilken typ av sammanfogning som ska användas samt andra detaljer.

Parameter Beskrivning Standardvärde
vänster Den första DataFrame som ska slås samman
höger Den andra DataFrame som ska slås samman
hur Typ av sammanfogningsoperation som ska utföras (inner, outer, left, right) inner
på Den eller de kolumner eller indexnivåer som ska användas som nycklar; måste finnas i båda DataFrames.
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 resulterande DataFrame lexicografiskt. 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 illustrerar hur man använder pandas merge() på ett effektivt sätt.

INNER JOIN

En INNER JOIN kombinerar två pandas DataFrames och returnerar endast de rader där nycklarna matchar i båda DataFrames. För att få en bättre uppfattning om hur detta fungerar, låt oss skapa två 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 två resulterande DataFrames 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 funktionen merge():

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

Utmatningen 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 ursprungliga DataFrames.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN slår också samman två DataFrames, men till skillnad från INNER JOIN returnerar 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 innehåller alla rader från båda DataFrames. 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 standardvarianterna av JOIN fungerar på liknande sätt.

Användning av left_on och right_on

Ibland har två DataFrames olika kolumnnamn för sina nycklar. I så fall kan du använda parametrarna left_on och right_on för att ange vilka kolumner som ska användas. Låt oss först skapa två nya 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 två DataFrames 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 parametrarna left_on och right_on för att utföra operationen 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 uttryckligen använda left_on='Key' och right_on='Key2' används motsvarande nyckelkolumner för sammanslagningen.

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 DataFrames som nycklar genom att ställa in parametrarna left_index och right_index till True. Låt oss först skapa två nya DataFrames 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 DataFrames:

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

Resultatet är en JOIN som använder indexen från DataFrames:

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