Kuinka yhdistää Da­taFra­mes pandas merge() -toi­min­nol­la

Pandas-toi­min­nol­la DataFrame.merge() voit yhdistää DataFrame-kehyksiä avainten avulla. Näin voit yhdistää te­hok­kaas­ti eri lähteistä peräisin olevia tietoja ja suorittaa kat­ta­vam­pia ana­lyy­se­ja.

Mikä on pandas merge():n syntaksi?

Python pandas DataFrame merge() -menetelmä voi hyväksyä erilaisia pa­ra­met­re­ja, joiden avulla ke­hit­tä­jät voivat määrittää, miten Da­taFra­mes-kehykset tulisi yhdistää. merge() yleinen syntaksi on seuraava:

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)

Mitä pa­ra­met­re­ja voidaan käyttää pandas merge kanssa?

merge() hy­väk­sy­mien eri pa­ra­met­rien avulla voit määrittää paitsi yh­dis­tet­tä­vät pandas Da­taFra­mes -kehykset myös käy­tet­tä­vän lii­tos­tyy­pin ja muut yk­si­tyis­koh­dat.

Kuinka käyttää pandas merge()

Alla on muutamia esi­merk­ke­jä, jotka auttavat ha­vain­nol­lis­ta­maan pandas merge() tehokasta käyttöä.

INNER JOIN

INNER JOIN yhdistää kaksi pandas-DataFrame-taulukkoa ja palauttaa vain rivit, joiden avaimet vastaavat molempia DataFrame-tau­lu­koi­ta. Jotta voimme paremmin ymmärtää, miten tämä toimii, luodaan kaksi DataFrame-taulukkoa:

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)

Tuloksena saadut kaksi DataFrame-taulukkoa näyttävät tältä:

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

Nyt voimme suorittaa INNER JOIN käyt­tä­mäl­lä merge() -funktiota:

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

Tu­lok­ses­ta näkyy, että vain rivit, joilla on avaimet B ja C, si­säl­ty­vät DataFrame-kehykseen. Tämä johtuu siitä, että nämä kaksi avainta ovat olemassa mo­lem­mis­sa al­ku­pe­räi­sis­sä DataFrame-ke­hyk­sis­sä.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN yhdistää myös kaksi DataFrame-taulukkoa, mutta toisin kuin INNER JOIN, se palauttaa kaikki rivit ja täyttää puuttuvat arvot arvolla NaN.

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

Alla oleva DataFrame sisältää kaikki rivit mo­lem­mis­ta DataFrame-tau­lu­kois­ta. NaN käytetään puut­tu­vien arvojen kor­vaa­mi­seen avaimessa A, joka on vain df1 ssä, ja avaimessa D, joka on vain df2:ssa.

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

Käyt­tä­mäl­lä left_on ja right_on

Joskus kahdella DataFrame-ke­hyk­sel­lä on eri sa­rak­kei­den nimet avai­mi­naan. Tällöin voit käyttää pa­ra­met­re­ja left_on ja right_on mää­rit­tääk­se­si, mitä sa­rak­kei­ta käytetään. Luodaan ensin kaksi uutta DataFrame-kehystä:

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)

Kaksi DataFrame-taulukkoa näyttävät seu­raa­val­ta:

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

Voimme käyttää pa­ra­met­re­ja left_on ja right_on suo­rit­taak­sem­me toiminnon JOIN eri avaimilla:

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

Käyt­tä­mäl­lä ni­men­omai­ses­ti left_on='Key' ja right_on='Key2', vastaavat avain­ko­lum­nit käytetään yh­dis­tä­mi­seen.

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

Indeksien käyttö avaimina

Voit myös käyttää DataFrame-tau­lu­koi­den indeksejä avaimina aset­ta­mal­la pa­ra­met­rit left_index ja right_index arvoon True. Luodaan ensin kaksi uutta DataFrame-taulukkoa in­dek­seil­lä:

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)

Tässä ovat Da­taFra­mes:

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

Nyt voimme suorittaa JOIN indeksejä käyt­tä­mäl­lä:

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

Tuloksena on JOIN, joka käyttää Da­taFra­mes-indeksejä:

Value1  Value2
B        2        4
C        3        5