Funkt­siooni pandas DataFrame.merge() abil saate kom­bi­nee­rida Da­taF­ra­mes’i võtmeid kasutades. See võimaldab teil tõhusalt kom­bi­nee­rida eri­ne­va­test al­li­ka­test pärit andmeid, mis võimaldab teil teha põh­ja­li­ku­maid analüüse.

Mis on pandas merge() süntaks?

Python pandas DataFrame merge() meetod võtab vastu mit­me­su­gu­seid pa­ra­meetreid, mis võimaldab aren­da­ja­tel määrata, kuidas Da­taF­ra­mes’i tuleks kom­bi­nee­rida. merge() funkt­siooni üldine süntaks on järgmine:

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

Milliseid pa­ra­meetreid saab kasutada pandas merge-ga?

merge() poolt akt­sep­tee­ri­ta­vad erinevad pa­ra­meet­rid või­mal­da­vad teil määrata mitte ainult, millised pandas Da­taF­ra­mes’id ühendada, vaid ka millist liitmist kasutada, samuti muid detaile.

Pa­ra­mee­ter Kirjeldus Vaikimisi väärtus
vasak Esimene ühendatav and­me­raa­mis­tik
parem Teine ühendatav andmestik
kuidas Teos­ta­tava ühen­da­mise tüüp (inner, outer, left, right) inner
on Võtmetena ka­su­ta­ta­vad veerud või in­deksi­ta­se­med; peavad olema olemas mõlemas DataFrame’is
vasakul Vasaku DataFrame’i veerg(ud) või in­deksi­ta­sand(id), mida tuleks kasutada võtmena
right_on Pa­rem­poolse DataFrame’i veerg(ud) või in­deksi­ta­sand(id), mida tuleks kasutada võtmena
left_index Kui True, ka­su­ta­takse vasaku DataFrame’i indeksit võtmena False
right_index Kui True, ka­su­ta­takse pa­rem­poolse DataFrame’i indeksit võtmena. False
sort Kui True, sor­tee­ri­takse tu­le­mus­liku DataFrame’i võtmed lek­si­kog­raa­fi­li­selt. False
sufiksid Sufiksid, mida ka­su­ta­takse sama nimega veergude eris­ta­miseks. ("_x", "_y")
ko­pee­ri­mine Kui False, siis koopiat ei tehta True

Kuidas kasutada pandas merge()

Allpool on toodud mõned näited, mis aitavad il­lust­ree­rida, kuidas pandas merge() efek­tiiv­selt kasutada.

INNER JOIN

INNER JOIN ühendab kaks pandas Da­taF­ra­mes’i ja tagastab ainult need read, mille võtmed mõlemas Da­taF­ra­mes’is ühtivad. Et paremini mõista, kuidas see toimib, loome kaks Da­taF­ra­mes’i:

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

Kaks tu­le­mu­seks saadud and­me­st­ruk­tuuri näevad välja järgmised:

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

Nüüd saame teha INNER JOIN, kasutades funkt­siooni merge():

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

Väljund näitab, et ainult read, millel on võtmed B ja C, on lisatud DataFrame’i. Seda seetõttu, et need kaks võtit on olemas mõlemas algses DataFrame’is.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN ühendab samuti kaks DataFrame’i, kuid erinevalt INNER JOIN tagastab see kõik read ja täidab puuduvad väärtused NaNga.

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

Allpool olev DataFrame sisaldab mõlema DataFrame’i kõiki ridu. NaN ka­su­ta­takse puuduvate väärtuste jaoks võtmes A, mis on ainult df1, ja võtmes D, mis on ainult df2-s.

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

Teised JOIN stan­dard­va­rian­did töötavad sarnaselt.

Kasutades left_on ja right_on

Mõnikord on kahel DataFrame’il erinevad vee­ru­ni­med võtmetena. Sel juhul saate kasutada pa­ra­meetreid left_on ja right_on, et määrata, milliseid veerge kasutada. Esmalt loome kaks uut DataFrame’i:

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

Kaks DataFrame’i näevad välja järgmised:

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

Me saame kasutada pa­ra­meetreid left_on ja right_on, et teostada ope­rat­siooni JOIN erinevate võtmete abil:

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

Sel­ge­sõ­na­li­selt kasutades left_on='Key' ja right_on='Key2', ka­su­ta­takse vastavaid võt­me­veerge ühen­da­miseks.

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

Indeksite ka­su­ta­mine võtmetena

Võite kasutada ka Da­taF­ra­mes’i indeksite võtmeid, sea­dis­ta­des pa­ra­meet­rid left_index ja right_index väär­tu­sele True. Esmalt loome kaks uut Da­taF­ra­mes’i in­deksi­tega:

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

Siin on and­me­st­ruk­tuu­rid:

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

Nüüd saame indeksite abil teha JOIN ope­rat­siooni:

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

Tu­le­mu­seks on JOIN, mis kasutab Da­taF­ra­mes’i indekseid:

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