Python Pandas Merging: Osvojte si stratégie spájania DataFrame pre analýzu dát

Manipulácia s dátami je kľúčovým aspektom analýzy dát a knižnica Pandas v Pythone na tento účel poskytuje výkonné nástroje. Medzi týmito nástrojmi sú spájanie a pripájanie DataFrame základné operácie na kombinovanie dátových súborov na základe spoločných stĺpcov alebo indexov. Tento komplexný sprievodca skúma rôzne stratégie pripájania DataFrame v Pandas a vybavuje vás znalosťami na efektívne kombinovanie a analýzu dát z rôznych zdrojov.

Pochopenie spájania a pripájania DataFrame

Spájanie a pripájanie DataFrame zahŕňa kombinovanie dvoch alebo viacerých DataFrame do jedného DataFrame na základe zdieľaného stĺpca alebo indexu. Hlavný rozdiel medzi `merge` a `join` spočíva v tom, že `merge` je funkcia knižnice Pandas a typicky spája DataFrame na stĺpcoch, zatiaľ čo `join` je metóda DataFrame, ktorá spája DataFrame primárne na indexoch, aj keď sa dá použiť aj na stĺpce.

Kľúčové pojmy

• DataFrame: Dvojrozmerné označené dátové štruktúry so stĺpcami potenciálne rôznych typov.
• Spoločné stĺpce/indexy: Stĺpce alebo indexy, ktoré zdieľajú rovnaký názov a dátový typ naprieč DataFrame, slúžiace ako základ pre spájanie/pripájanie.
• Typy pripojení: Rôzne stratégie na spracovanie nezhodných riadkov počas procesu spájania/pripájania, vrátane vnútorných, vonkajších, ľavých a pravých pripojení.

Spájanie DataFrame pomocou `pd.merge()`

Funkcia `pd.merge()` je primárnym nástrojom na spájanie DataFrame na základe stĺpcov. Ponúka flexibilný spôsob kombinovania dát na základe jedného alebo viacerých spoločných stĺpcov.

Syntax

pd.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)

Parametre

• left: Ľavý DataFrame na spájanie.
• right: Pravý DataFrame na spájanie.
• how: Typ spájania, ktorý sa má vykonať ('inner', 'outer', 'left', 'right'). Predvolené je 'inner'.
• on: Názov(y) stĺpca(ov), na ktorom sa má pripojiť. Tieto musia byť nájdené v oboch DataFrame.
• left_on: Názov(y) stĺpca(ov) v ľavom DataFrame na použitie ako kľúče pripojenia.
• right_on: Názov(y) stĺpca(ov) v pravom DataFrame na použitie ako kľúče pripojenia.
• left_index: Ak je pravda, použite index z ľavého DataFrame ako kľúč(e) pripojenia.
• right_index: Ak je pravda, použite index z pravého DataFrame ako kľúč(e) pripojenia.
• sort: Zoradiť výsledný DataFrame lexikograficky podľa kľúčov pripojenia. Predvolené je False.
• suffixes: Dvojica reťazcových prípon na aplikovanie na prekrývajúce sa názvy stĺpcov. Predvolené je ('_x', '_y').
• copy: Ak je False, vyhnite sa kopírovaniu dát do nového DataFrame, kde je to možné. Predvolené je True.
• indicator: Ak je pravda, pridá stĺpec s názvom '_merge', ktorý indikuje zdroj každého riadku.
• validate: Kontroluje, či je spájanie zadaného typu. "one_to_one", "one_to_many", "many_to_one", "many_to_many".

Vysvetlenie typov pripojení

Parameter `how` vo funkcii `pd.merge()` určuje typ vykonaného pripojenia. Rôzne typy pripojení spracovávajú nezhodné riadky rôznymi spôsobmi.

Vnútorné pripojenie (Inner Join)

Vnútorné pripojenie vráti iba tie riadky, ktoré majú zhodné hodnoty v oboch DataFrame na základe kľúčov pripojenia. Riadky s nezhodnými hodnotami sú z výsledku vylúčené.

Príklad:

Zvážte dva DataFrame:

            import pandas as pd

# DataFrame 1: Objednávky zákazníkov
df_orders = pd.DataFrame({
 'order_id': [1, 2, 3, 4, 5],
 'customer_id': [101, 102, 103, 104, 105],
 'product_id': [1, 2, 1, 3, 2],
 'quantity': [2, 1, 3, 1, 2]
})

# DataFrame 2: Informácie o zákazníkoch
df_customers = pd.DataFrame({
 'customer_id': [101, 102, 103, 106],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
 'country': ['USA', 'Canada', 'UK', 'Australia']
})

# Vnútorné pripojenie
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)

            

              
                Copy
              
            
          

Výstup:

   order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK

V tomto príklade vnútorné pripojenie kombinuje DataFrame `df_orders` a `df_customers` na základe stĺpca `customer_id`. Vo výsledku sú zahrnutí iba zákazníci, ktorí uskutočnili objednávky. Zákazník 'David' (customer_id 106) je vylúčený, pretože nemá žiadne objednávky.

Vonkajšie pripojenie (Full Outer Join)

Vonkajšie pripojenie vráti všetky riadky z oboch DataFrame, vrátane nezhodných riadkov. Ak riadok nemá zhodu v druhom DataFrame, zodpovedajúce stĺpce budú obsahovať hodnoty `NaN` (Not a Number).

Príklad:

# Vonkajšie pripojenie
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)

Výstup:

   order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       4.0          104         3.0       1.0           NaN        NaN
4       5.0          105         2.0       2.0           NaN        NaN
5       NaN          106         NaN       NaN         David   Australia

Vonkajšie pripojenie obsahuje všetkých zákazníkov a všetky objednávky. Zákazníci 104 a 105 majú objednávky, ale žiadne informácie o zákazníkovi, a zákazník 106 má informácie o zákazníkovi, ale žiadne objednávky. Chýbajúce hodnoty sú reprezentované ako `NaN`.

Ľavé pripojenie (Left Join)

Ľavé pripojenie vráti všetky riadky z ľavého DataFrame a zhodné riadky z pravého DataFrame. Ak riadok v ľavom DataFrame nemá zhodu v pravom DataFrame, zodpovedajúce stĺpce z pravého DataFrame budú obsahovať hodnoty `NaN`.

Príklad:

# Ľavé pripojenie
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)

Výstup:

   order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Ľavé pripojenie obsahuje všetky objednávky z `df_orders`. Zákazníci 104 a 105 majú objednávky, ale žiadne informácie o zákazníkovi, takže stĺpce `customer_name` a `country` sú pre tieto objednávky `NaN`.

Pravé pripojenie (Right Join)

Pravé pripojenie vráti všetky riadky z pravého DataFrame a zhodné riadky z ľavého DataFrame. Ak riadok v pravom DataFrame nemá zhodu v ľavom DataFrame, zodpovedajúce stĺpce z ľavého DataFrame budú obsahovať hodnoty `NaN`.

Príklad:

# Pravé pripojenie
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)

Výstup:

   order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       NaN          106         NaN       NaN         David   Australia

Pravé pripojenie obsahuje všetkých zákazníkov z `df_customers`. Zákazník 106 má informácie o zákazníkovi, ale žiadne objednávky, takže stĺpce `order_id`, `product_id` a `quantity` sú pre tohto zákazníka `NaN`.

Pripájanie DataFrame pomocou `df.join()`

Metóda `df.join()` sa primárne používa na pripájanie DataFrame na základe ich indexov. Dá sa použiť aj na pripájanie na stĺpce, ale zvyčajne je pohodlnejšie použiť `pd.merge()` pre pripájania na základe stĺpcov.

Syntax

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

Parametre

• other: Druhý DataFrame na pripojenie.
• on: Názov stĺpca na pripojenie. Musí byť odovzdaný, ak sa index nepoužíva ako kľúč pripojenia.
• how: Ako spracovať operáciu ľavých a pravých množín. Predvolené je 'left'.
• lsuffix: Prípona na použitie z ľavého DataFrame na prepísanie prekrývajúcich sa názvov stĺpcov.
• rsuffix: Prípona na použitie z pravého DataFrame na prepísanie prekrývajúcich sa názvov stĺpcov.
• sort: Zoradiť výsledný DataFrame lexikograficky podľa kľúčov pripojenia. Predvolené je False.

Pripájanie na index

Pri pripájaní na index sa parameter `on` nepoužíva.

Príklad:

# DataFrame 1: Objednávky zákazníkov s Customer ID ako index
df_orders_index = df_orders.set_index('customer_id')

# DataFrame 2: Informácie o zákazníkoch s Customer ID ako index
df_customers_index = df_customers.set_index('customer_id')

# Pripájanie na index (ľavé pripojenie)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)

Výstup:

             order_id  product_id  quantity customer_name country
customer_id                                                    
101                 1           1         2         Alice     USA
102                 2           2         1           Bob  Canada
103                 3           1         3       Charlie      UK
104                 4           3         1           NaN     NaN
105                 5           2         2           NaN     NaN

V tomto príklade sa metóda `join()` použije na vykonanie ľavého pripojenia na index (`customer_id`). Výsledok je podobný ako pri ľavom pripojení pomocou `pd.merge()`, ale pripojenie je založené na indexe namiesto stĺpca.

Pripájanie na stĺpec

Na pripájanie na stĺpec pomocou `df.join()` musíte zadať parameter `on`.

Príklad:

# Pripájanie na stĺpec
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)

Výstup:

   order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Tento príklad demonštruje pripájanie `df_orders` k `df_customers` pomocou stĺpca `customer_id`. Všimnite si, že `customer_id` je nastavený ako index v `df_customers` pred vykonaním pripojenia.

Spracovanie prekrývajúcich sa stĺpcov

Pri spájaní alebo pripájaní DataFrame je bežné naraziť na prekrývajúce sa názvy stĺpcov (stĺpce s rovnakým názvom v oboch DataFrame). Pandas poskytuje parameter `suffixes` vo funkcii `pd.merge()` a parametre `lsuffix` a `rsuffix` v metóde `df.join()` na spracovanie týchto situácií.

Použitie `suffixes` vo funkcii `pd.merge()`

Parameter `suffixes` vám umožňuje špecifikovať prípony, ktoré sa pridajú k prekrývajúcim sa názvom stĺpcov, aby sa rozlíšili.

Príklad:

# DataFrame 1: Informácie o produktoch
df_products1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Produkt A', 'Produkt B', 'Produkt C'],
 'price': [10, 20, 15]
})

# DataFrame 2: Informácie o produktoch (s potenciálne aktualizovanými cenami)
df_products2 = pd.DataFrame({
 'product_id': [1, 2, 4],
 'product_name': ['Produkt A', 'Produkt B', 'Produkt D'],
 'price': [12, 18, 25]
})

# Spájanie s príponami
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)

Výstup:

   product_id product_name_old  price_old product_name_new  price_new
0           1      Produkt A         10       Product A         12
1           2      Product B         20       Product B         18

V tomto príklade sú stĺpce `product_name` a `price` prítomné v oboch DataFrame. Parameter `suffixes` pridáva prípony `_old` a `_new` na rozlíšenie stĺpcov z ľavého a pravého DataFrame.

Použitie `lsuffix` a `rsuffix` v metóde `df.join()`

Parametre `lsuffix` a `rsuffix` poskytujú podobnú funkcionalitu pre `df.join()`. `lsuffix` pripája k prekrývajúcim sa stĺpcom ľavého DataFrame a `rsuffix` k pravému DataFrame.

Príklad:

# Pripojenie s lsuffix a rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)

Výstup:

          product_name_old  price_old product_name_new  price_new
product_id                                                     
1                 Product A       10.0        Product A       12.0
2                 Product B       20.0        Product B       18.0
3                 Product C       15.0            NaN        NaN
4                       NaN        NaN        Product D       25.0

Praktické príklady a prípady použitia

Spájanie a pripájanie DataFrame sa široko používa v rôznych scenároch analýzy dát. Tu sú niektoré praktické príklady:

Kombinovanie údajov o predaji s informáciami o produkte

Bežným prípadom použitia je kombinovanie údajov o predaji s informáciami o produkte. Predpokladajme, že máte DataFrame obsahujúci predajné transakcie a iný DataFrame obsahujúci detaily produktu. Tieto DataFrame môžete spojiť, aby ste obohatili údaje o predaji o informácie o produkte.

Príklad:

# Údaje o predajných transakciách
df_sales = pd.DataFrame({
 'transaction_id': [1, 2, 3, 4, 5],
 'product_id': [101, 102, 103, 101, 104],
 'quantity': [2, 1, 3, 1, 2],
 'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})

# Údaje o informáciách o produktoch
df_products = pd.DataFrame({
 'product_id': [101, 102, 103, 104],
 'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
 'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
 'price': [1200, 25, 75, 300]
})

# Spájanie údajov o predaji s informáciami o produkte
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)

Výstup:

   transaction_id  product_id  quantity sales_date product_name     category   price
0               1         101         2   2023-01-15       Laptop  Electronics  1200
1               2         102         1   2023-02-20        Mouse  Electronics    25
2               3         103         3   2023-03-10     Keyboard  Electronics    75
3               4         101         1   2023-04-05       Laptop  Electronics  1200
4               5         104         2   2023-05-01      Monitor  Electronics   300

Výsledný DataFrame `df_sales_enriched` obsahuje predajné transakcie spolu s príslušnými informáciami o produkte, čo umožňuje podrobnejšiu analýzu trendov predaja a výkonnosti produktov.

Kombinovanie údajov o zákazníkoch s demografickými informáciami

Ďalším bežným prípadom použitia je kombinovanie údajov o zákazníkoch s demografickými informáciami. To umožňuje analyzovať správanie zákazníkov na základe demografických faktorov.

Príklad:

# Údaje o zákazníkoch
df_customers = pd.DataFrame({
 'customer_id': [1, 2, 3, 4, 5],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})

# Údaje o demografických informáciách
df_demographics = pd.DataFrame({
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
 'population': [8419000, 8982000, 13960000, 5312000, 3769000],
 'average_income': [75000, 65000, 85000, 90000, 55000]
})

# Spájanie údajov o zákazníkoch s demografickými informáciami
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)

Výstup:

   customer_id customer_name      city  population  average_income
0            1         Alice  New York     8419000           75000
1            2           Bob    London     8982000           65000
2            3       Charlie     Tokyo    13960000           85000
3            4         David    Sydney     5312000           90000
4            5           Eve    Berlin     3769000           55000

Výsledný DataFrame `df_customer_demographics` obsahuje údaje o zákazníkoch spolu s demografickými informáciami pre ich príslušné mestá, čo umožňuje analýzu správania zákazníkov na základe demografie miest.

Analýza údajov o globálnom dodávateľskom reťazci

Spájanie Pandas je cenné pri analýze údajov o globálnom dodávateľskom reťazci, kde sú informácie často rozložené vo viacerých tabuľkách. Napríklad prepojenie údajov o dodávateľoch, informácií o preprave a údajov o predaji môže odhaliť úzke miesta a optimalizovať logistiku.

Príklad:

# Údaje o dodávateľoch
df_suppliers = pd.DataFrame({
 'supplier_id': [1, 2, 3],
 'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
 'location': ['Taiwan', 'Germany', 'China']
})

# Údaje o preprave
df_shipments = pd.DataFrame({
 'shipment_id': [101, 102, 103, 104],
 'supplier_id': [1, 2, 3, 1],
 'destination': ['USA', 'Canada', 'Australia', 'Japan'],
 'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})


# Spájanie údajov o dodávateľoch a preprave
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')

print(df_supply_chain)

Výstup:

   shipment_id  supplier_id destination shipment_date supplier_name location
0          101            1         USA    2023-01-10     GlobalTech   Taiwan
1          102            2      Canada    2023-02-15      EuroParts  Germany
2          103            3   Australia    2023-03-20     AsiaSource    China
3          104            1       Japan    2023-04-25     GlobalTech   Taiwan

Pokročilé techniky spájania

Spájanie na viacerých stĺpcoch

DataFrame môžete spájať na základe viacerých stĺpcov odovzdaním zoznamu názvov stĺpcov do parametra `on`.

Príklad:

# DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'quantity': [10, 15, 20, 25]
})

# DataFrame 2
df2 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'price': [5, 7, 8, 10]
})

# Spájanie na viacerých stĺpcoch
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)

Výstup:

   product_id color  quantity  price
0           1   red        10      5
1           1  blue        15      7
2           2   red        20      8
3           2  blue        25     10

Spájanie s rôznymi názvami stĺpcov

Ak sa kľúče pripojenia v dvoch DataFrame líšia, môžete použiť parametre `left_on` a `right_on` na špecifikovanie názvov stĺpcov, ktoré sa majú použiť na spájanie.

Príklad:

# DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Product A', 'Product B', 'Product C']
})

# DataFrame 2
df2 = pd.DataFrame({
 'id': [1, 2, 4],
 'price': [10, 20, 25]
})

# Spájanie s rôznymi názvami stĺpcov
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)

Výstup:

   product_id product_name   id   price
0           1    Product A  1.0    10.0
1           2    Product B  2.0    20.0
2           3    Product C  NaN     NaN

Použitie `indicator` pre analýzu spájania

Parameter `indicator` vo funkcii `pd.merge()` pridá do výsledného DataFrame stĺpec s názvom `_merge`, ktorý indikuje zdroj každého riadku. To je užitočné na pochopenie toho, ktoré riadky boli zhodné a ktoré nie.

Príklad:

# Spájanie s indikátorom
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)

Výstup:

   order_id  customer_id  product_id  quantity customer_name    country      _merge
0       1.0          101         1.0       2.0         Alice        USA        both
1       2.0          102         2.0       1.0           Bob     Canada        both
2       3.0          103         1.0       3.0       Charlie         UK        both
3       4.0          104         3.0       1.0           NaN        NaN   left_only
4       5.0          105         2.0       2.0           NaN        NaN   left_only
5       NaN          106         NaN       NaN         David   Australia  right_only

Stĺpec `_merge` indikuje, či riadok pochádza z oboch DataFrame (`both`), iba z ľavého DataFrame (`left_only`) alebo iba z pravého DataFrame (`right_only`).

Overenie typov spájania

Parameter `validate` zabezpečuje, že operácia spájania je v súlade s očakávanými typmi vzťahov medzi DataFrame (napr. 'one_to_one', 'one_to_many'). To pomáha predchádzať nekonzistentnostiám a chybám v dátach.

Príklad:

# Príklad s overením one-to-one
df_users = pd.DataFrame({
 'user_id': [1, 2, 3],
 'username': ['john_doe', 'jane_smith', 'peter_jones']
})

df_profiles = pd.DataFrame({
 'user_id': [1, 2, 3],
 'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})

# Vykonanie one-to-one spájania s overením
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')

print(merged_df)

Ak spájanie porušuje zadané overenie (napr. vzťah many-to-one pri zadaní 'one_to_one'), bude vyvolaná chyba `MergeError`, ktorá vás upozorní na potenciálne problémy s integritou dát.

Úvahy o výkone

Spájanie a pripájanie DataFrame môže byť výpočtovo náročné, najmä pre veľké dátové sady. Tu je niekoľko tipov na zlepšenie výkonu:

• Použite vhodný typ pripojenia: Výber správneho typu pripojenia môže výrazne ovplyvniť výkon. Napríklad, ak potrebujete iba zhodné riadky, použite vnútorné pripojenie.
• Indexujte kľúče pripojenia: Indexovanie kľúčov pripojenia môže zrýchliť proces spájania.
• Použite vhodné dátové typy: Zabezpečte, aby kľúče pripojenia mali kompatibilné dátové typy.
• Vyhnite sa zbytočným kópiám: Nastavte `copy=False` v `pd.merge()` a `df.join()`, aby ste sa vyhli vytváraniu zbytočných kópií dát.

Záver

Spájanie a pripájanie DataFrame sú základné operácie v analýze dát. Pochopením rôznych typov pripojení a techník môžete efektívne kombinovať a analyzovať údaje z rôznych zdrojov, odhaliť cenné poznatky a podporiť informované rozhodovanie. Od kombinovania údajov o predaji s informáciami o produkte až po analýzu globálnych dodávateľských reťazcov, zvládnutie týchto techník vám umožní s istotou zvládnuť zložité úlohy manipulácie s dátami. Nezabudnite zvážiť dôsledky výkonu pri práci s veľkými dátovými sadami a využiť pokročilé funkcie, ako sú parametre `indicator` a `validate`, pre robustnejšiu a prehľadnejšiu analýzu.