Ar pandas funkciju DataFrame.merge() varat apvienot Da­taF­ra­mes, iz­man­to­jot atslēgas. Tas ļauj efektīvi apvienot datus no dažādiem avotiem, dodot iespēju veikt vi­s­ap­tve­ro­šā­kas analīzes.

Kāda ir pandas merge() sintakse?

Python pandas DataFrame merge() metode var pieņemt virkni dažādu parametru, ļaujot iz­strā­dā­tā­jiem norādīt, kā Da­taF­ra­mes jākombinē. merge() funkcijas vispārīgā sintakse ir šāda:

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

Kādus pa­ra­met­rus var izmantot ar pandas merge?

Dažādie parametri, ko pieņem merge(), ļauj ne tikai norādīt, kurus pandas Da­taF­ra­mes apvienot, bet arī, kādu sa­vie­no­ju­ma veidu izmantot, kā arī citas detaļas.

Parametrs Apraksts No­klu­sē­ju­ma vērtība
kreisais Pirmais ap­vie­no­ja­mais DataFrame
labais Otrais ap­vie­no­ja­mais DataFrame
kā Veicamā ap­vie­no­ša­nas ope­rā­ci­jas veids (inner, outer, left, right) inner
uz Kolonna(-as) vai indeksa līmenis(-i), kas jāizmanto kā atslēgas; jābūt abos DataFrame
left_on Kolonna(-as) vai indeksa līmenis(-i) kreisajā DataFrame, kas jāizmanto kā atslēga(-as)
labais_uz Labās DataFrame kolonna(-as) vai indeksa līmenis(-i), kas jāizmanto kā atslēga(-as)
left_index Ja True, kā atslēga tiek izmantots kreisā DataFrame indekss False
labais_indekss Ja True, kā atslēga tiek izmantots labās DataFrame indekss. False
sort Ja True, rezultātā iegūto DataFrame atslēgas tiek šķirotas lek­si­kog­rā­fis­ki. False
suffixes Piedēkļi, kas tiek izmantoti, lai atšķirtu kolonnas ar vienādu nosaukumu ("_x", "_y")
kopija Ja False, kopēšana netiek veikta True

Kā lietot pandas merge()

Zemāk ir daži piemēri, kas palīdz ilustrēt, kā efektīvi izmantot pandas merge().

INNER JOIN

INNER JOIN apvieno divus pandas Da­taF­ra­mes un atgriež tikai rindas, kurās atslēgas abos Da­taF­ra­mes saskan. Lai labāk izprastu, kā tas darbojas, iz­vei­do­sim divus Da­taF­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

Abos rezultātā iegūtajos Da­taF­ra­mes izskatās šādi:

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

Tagad mēs varam veikt INNER JOIN, iz­man­to­jot merge() funkciju:

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

Rezultāts parāda, ka DataFrame ir iekļautas tikai rindas, kurām ir atslēgas B un C. Tas ir tāpēc, ka šīs divas atslēgas ir abās sā­kot­nē­jās DataFrame.

Key    Value1    Value2
0     B            2            4
1     C            3            5

OUTER JOIN

An OUTER JOIN arī apvieno divus Da­taF­ra­mes, bet atšķirībā no INNER JOIN, tas atgriež visas rindas un aizpilda trūk­sto­šās vērtības ar NaN.

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

Zemāk redzamajā DataFrame ir iekļautas visas rindas no abiem DataFrame. NaN tiek izmantots trūk­sto­ša­jām vērtībām atslēgā A, kas ir tikai df1, un atslēgā D, kas ir tikai 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

Pārējie standarta varianti JOIN darbojas līdzīgi.

Iz­man­to­jot left_on un right_on

Dažreiz diviem Da­taF­ra­mes ir atšķirīgi kolonnu nosaukumi to atslēgām. Šādā gadījumā varat izmantot left_on un right_on pa­ra­met­rus, lai norādītu, kuras kolonnu izmantot. Vispirms iz­vei­do­sim divus jaunus Da­taF­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

Abas Da­taF­ra­mes izskatās šādi:

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

Mēs varam izmantot left_on un right_on pa­ra­met­rus, lai veiktu JOIN operāciju, iz­man­to­jot dažādas taustiņus:

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

Iz­man­to­jot left_on='Key' un right_on='Key2', ap­vie­no­ša­nai tiek iz­man­to­tas at­bil­sto­šās atslēgas kolonnas.

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

Indeksu iz­man­to­ša­na kā atslēgas

Jūs varat arī izmantot Da­taF­ra­mes indeksus kā atslēgas, iestatot left_index un right_index pa­ra­met­rus uz True. Vispirms iz­vei­do­sim divus jaunus Da­taF­ra­mes ar indeksiem:

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

Šeit ir datu rāmji:

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

Tagad mēs varam veikt JOIN ope­rā­ci­jas, iz­man­to­jot indeksus:

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

Rezultāts ir JOIN, kas izmanto indeksus no Da­taF­ra­mes:

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