पायथन पांडास डेटाफ्रेम मर्ज आणि जॉइन करण्यासाठी सखोल मार्गदर्शन. इनर, आऊटर, लेफ्ट, राईट जॉइनसह विविध रणनीती आणि जागतिक डेटा विश्लेषणाचे व्यावहारिक उदाहरण.
पायथन पांडास मर्जिंग: डेटा विश्लेषणसाठी डेटाफ्रेम जॉइनिंग स्ट्रॅटेजीजमध्ये प्रभुत्व मिळवणे
डेटा हाताळणी हा डेटा विश्लेषणाचा एक महत्त्वाचा पैलू आहे आणि पायथनमधील पांडास लायब्ररी यासाठी शक्तिशाली साधने प्रदान करते. या साधनांमध्ये, डेटाफ्रेम विलीन (मर्ज) करणे आणि जोडणे (जॉइन) ही सामान्य स्तंभांवर किंवा निर्देशांकांवर आधारित डेटासेट एकत्रित करण्यासाठी आवश्यक ऑपरेशन्स आहेत. हे सर्वसमावेशक मार्गदर्शक पांडासमधील विविध डेटाफ्रेम जॉइनिंग स्ट्रॅटेजीजची माहिती देते, ज्यामुळे तुम्हाला वेगवेगळ्या स्त्रोतांकडून डेटा प्रभावीपणे एकत्रित आणि विश्लेषण करण्यासाठी ज्ञान मिळेल.
डेटाफ्रेम विलीनीकरण (Merging) आणि जोडणी (Joining) समजून घेणे
डेटाफ्रेम विलीन (मर्ज) करणे आणि जोडणे (जॉइन) म्हणजे एक सामायिक स्तंभ किंवा निर्देशांकावर आधारित दोन किंवा अधिक डेटाफ्रेम्सना एकाच डेटाफ्रेममध्ये एकत्र करणे. `merge` आणि `join` यांच्यातील मुख्य फरक असा आहे की `merge` हे पांडास लायब्ररीचे कार्य आहे आणि ते सामान्यतः स्तंभांवर डेटाफ्रेम्सना जोडते, तर `join` ही डेटाफ्रेमची पद्धत आहे जी प्रामुख्याने निर्देशांकांवर डेटाफ्रेम्सना जोडते, जरी ती स्तंभांसोबत देखील वापरली जाऊ शकते.
मुख्य संकल्पना
- डेटाफ्रेम्स (DataFrames): संभाव्यतः भिन्न प्रकारच्या स्तंभांसह दोन-आयामी लेबल केलेल्या डेटा संरचना.
- सामान्य स्तंभ/निर्देशांक (Common Columns/Indices): डेटाफ्रेम्समध्ये समान नाव आणि डेटा प्रकार असलेले स्तंभ किंवा निर्देशांक, जे विलीनीकरण/जोडणीचा आधार म्हणून काम करतात.
- जोडणीचे प्रकार (Join Types): विलीनीकरण/जोडणी प्रक्रियेदरम्यान न जुळलेल्या पंक्ती हाताळण्यासाठी वेगवेगळ्या रणनीती, ज्यात इनर, आऊटर, लेफ्ट आणि राईट जॉइनचा समावेश आहे.
pd.merge() सह डेटाफ्रेम विलीनीकरण
pd.merge() फंक्शन हे स्तंभांवर आधारित डेटाफ्रेम्स विलीन करण्यासाठी मुख्य साधन आहे. हे एक किंवा अधिक सामान्य स्तंभांवर आधारित डेटा एकत्र करण्याचा लवचिक मार्ग प्रदान करते.
सिन्टॅक्स (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)
पॅरामीटर्स (Parameters)
- left: विलीन करण्यासाठी डावा डेटाफ्रेम.
- right: विलीन करण्यासाठी उजवा डेटाफ्रेम.
- how: करायच्या विलीनीकरणाचा प्रकार ('inner', 'outer', 'left', 'right'). डीफॉल्ट 'inner' आहे.
- on: ज्या स्तंभांवर जोडणी करायची आहे त्यांचे नाव (नावे). हे दोन्ही डेटाफ्रेम्समध्ये असले पाहिजेत.
- left_on: डाव्या डेटाफ्रेममधील स्तंभांचे नाव (नावे) जॉइन की म्हणून वापरण्यासाठी.
- right_on: उजव्या डेटाफ्रेममधील स्तंभांचे नाव (नावे) जॉइन की म्हणून वापरण्यासाठी.
- left_index: True असल्यास, डाव्या डेटाफ्रेममधील निर्देशांक जॉइन की म्हणून वापरले जातील.
- right_index: True असल्यास, उजव्या डेटाफ्रेममधील निर्देशांक जॉइन की म्हणून वापरले जातील.
- sort: परिणामी डेटाफ्रेमला जॉइन कीजनुसार वर्णक्रमानुसार क्रमवारी लावा. डीफॉल्ट False आहे.
- suffixes: ओव्हरलॅपिंग स्तंभ नावांना लागू करण्यासाठी स्ट्रिंग सफिक्सचा टपल. डीफॉल्ट ('_x', '_y') आहे.
- copy: False असल्यास, शक्य असेल तेथे नवीन डेटाफ्रेममध्ये डेटा कॉपी करणे टाळा. डीफॉल्ट True आहे.
- indicator: True असल्यास, प्रत्येक पंक्तीचा स्त्रोत दर्शवणारा '_merge' नावाचा स्तंभ जोडतो.
- validate: विलीनीकरण निर्दिष्ट प्रकाराचे आहे की नाही ते तपासते. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
जोडणीचे प्रकार (Join Types) स्पष्टीकरण
how पॅरामीटर इन pd.merge() केलेल्या जोडणीचा प्रकार निश्चित करते. विविध जोडणीचे प्रकार न जुळलेल्या पंक्तींना वेगवेगळ्या प्रकारे हाताळतात.
इनर जॉइन (Inner Join)
इनर जॉइन केवळ त्या पंक्ती परत करते ज्यात जॉइन कीजवर आधारित दोन्ही डेटाफ्रेम्समध्ये जुळणारे मूल्ये आहेत. न जुळलेल्या मूल्यांच्या पंक्ती परिणामातून वगळल्या जातात.
उदाहरण:
दोन डेटाफ्रेम्स विचारात घ्या:
import pandas as pd
# DataFrame 1: Customer Orders
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: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
आउटपुट:
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
या उदाहरणात, इनर जॉइन customer_id स्तंभावर आधारित df_orders आणि df_customers डेटाफ्रेम्सना एकत्र करते. केवळ ज्या ग्राहकांनी ऑर्डर दिल्या आहेत त्यांचाच परिणामात समावेश केला जातो. ग्राहक 'डेव्हिड' (customer_id 106) वगळला जातो कारण त्याने कोणतीही ऑर्डर दिली नाही.
आऊटर जॉइन (पूर्ण आऊटर जॉइन) (Outer Join (Full Outer Join))
आऊटर जॉइन दोन्ही डेटाफ्रेम्समधील सर्व पंक्ती परत करते, ज्यात न जुळलेल्या पंक्तींचा समावेश आहे. जर एखाद्या पंक्तीला दुसऱ्या डेटाफ्रेममध्ये जुळणारी पंक्ती नसेल, तर संबंधित स्तंभांमध्ये `NaN` (संख्या नाही) मूल्ये असतील.
उदाहरण:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
आउटपुट:
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
आऊटर जॉइनमध्ये सर्व ग्राहक आणि सर्व ऑर्डर्स समाविष्ट आहेत. ग्राहक 104 आणि 105 यांच्याकडे ऑर्डर्स आहेत परंतु कोणतीही ग्राहक माहिती नाही, आणि ग्राहक 106 यांच्याकडे ग्राहक माहिती आहे परंतु कोणतीही ऑर्डर नाही. गहाळ मूल्ये `NaN` म्हणून दर्शविली जातात.
लेफ्ट जॉइन (Left Join)
लेफ्ट जॉइन डाव्या डेटाफ्रेममधील सर्व पंक्ती आणि उजव्या डेटाफ्रेममधील जुळणाऱ्या पंक्ती परत करते. जर डाव्या डेटाफ्रेममधील पंक्तीला उजव्या डेटाफ्रेममध्ये जुळणारी पंक्ती नसेल, तर उजव्या डेटाफ्रेममधील संबंधित स्तंभांमध्ये `NaN` मूल्ये असतील.
उदाहरण:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
आउटपुट:
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
लेफ्ट जॉइनमध्ये df_orders मधील सर्व ऑर्डर्स समाविष्ट आहेत. ग्राहक 104 आणि 105 यांच्याकडे ऑर्डर्स आहेत परंतु कोणतीही ग्राहक माहिती नाही, म्हणून त्या ऑर्डर्ससाठी customer_name आणि country स्तंभ `NaN` आहेत.
राईट जॉइन (Right Join)
राईट जॉइन उजव्या डेटाफ्रेममधील सर्व पंक्ती आणि डाव्या डेटाफ्रेममधील जुळणाऱ्या पंक्ती परत करते. जर उजव्या डेटाफ्रेममधील पंक्तीला डाव्या डेटाफ्रेममध्ये जुळणारी पंक्ती नसेल, तर डाव्या डेटाफ्रेममधील संबंधित स्तंभांमध्ये `NaN` मूल्ये असतील.
उदाहरण:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
आउटपुट:
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
राईट जॉइनमध्ये df_customers मधील सर्व ग्राहक समाविष्ट आहेत. ग्राहक 106 यांच्याकडे ग्राहक माहिती आहे परंतु कोणतीही ऑर्डर नाही, म्हणून त्या ग्राहकासाठी order_id, product_id आणि quantity स्तंभ `NaN` आहेत.
df.join() सह डेटाफ्रेम जॉइनिंग
df.join() पद्धत प्रामुख्याने डेटाफ्रेम्सना त्यांच्या निर्देशांकांवर आधारित जोडण्यासाठी वापरली जाते. ती स्तंभांवर जोडण्यासाठी देखील वापरली जाऊ शकते, परंतु स्तंभ-आधारित जोडणीसाठी pd.merge() वापरणे अधिक सोयीचे आहे.
सिन्टॅक्स (Syntax)
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
पॅरामीटर्स (Parameters)
- other: जोडण्यासाठी दुसरा डेटाफ्रेम.
- on: ज्या स्तंभावर जोडणी करायची आहे त्याचे नाव. जर निर्देशांक जॉइन की म्हणून वापरला जात नसेल तर हे पास करणे आवश्यक आहे.
- how: डाव्या आणि उजव्या संचाच्या ऑपरेशनला कसे हाताळायचे. डीफॉल्ट 'left' आहे.
- lsuffix: डाव्या डेटाफ्रेममधून ओव्हरलॅपिंग स्तंभ नावांना अधिलिखित करण्यासाठी वापरले जाणारे सफिक्स.
- rsuffix: उजव्या डेटाफ्रेममधून ओव्हरलॅपिंग स्तंभ नावांना अधिलिखित करण्यासाठी वापरले जाणारे सफिक्स.
- sort: परिणामी डेटाफ्रेमला जॉइन कीजनुसार वर्णक्रमानुसार क्रमवारी लावा. डीफॉल्ट False आहे.
निर्देशांकावर जोडणी (Joining on Index)
निर्देशांकावर जोडणी करताना, on पॅरामीटर वापरले जात नाही.
उदाहरण:
# DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')
# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
आउटपुट:
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
या उदाहरणात, join() पद्धत निर्देशांकावर (customer_id) लेफ्ट जॉइन करण्यासाठी वापरली जाते. परिणाम pd.merge() वापरून केलेल्या लेफ्ट जॉइनसारखाच आहे, परंतु ही जोडणी स्तंभाऐवजी निर्देशांकावर आधारित आहे.
स्तंभावर जोडणी (Joining on Column)
df.join() वापरून स्तंभावर जोडणी करण्यासाठी, तुम्हाला on पॅरामीटर निर्दिष्ट करणे आवश्यक आहे.
उदाहरण:
# Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
आउटपुट:
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
हे उदाहरण customer_id स्तंभ वापरून df_orders ला df_customers सह जोडणी दर्शविते. लक्षात घ्या की जोडणी करण्यापूर्वी df_customers मध्ये customer_id निर्देशांक म्हणून सेट केला आहे.
ओव्हरलॅपिंग स्तंभांना हाताळणे
डेटाफ्रेम्स विलीन (मर्ज) करताना किंवा जोडताना, ओव्हरलॅपिंग स्तंभ नावे (दोन्ही डेटाफ्रेम्समध्ये समान नावाची स्तंभ) आढळणे सामान्य आहे. पांडास या परिस्थिती हाताळण्यासाठी pd.merge() मध्ये `suffixes` पॅरामीटर आणि df.join() मध्ये `lsuffix` आणि `rsuffix` पॅरामीटर्स प्रदान करते.
pd.merge() मध्ये `suffixes` वापरणे
`suffixes` पॅरामीटर तुम्हाला ओव्हरलॅपिंग स्तंभ नावांना जोडण्यासाठी सफिक्स निर्दिष्ट करण्याची परवानगी देते, जेणेकरून ते वेगळे ओळखता येतील.
उदाहरण:
# DataFrame 1: Product Information
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
आउटपुट:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
या उदाहरणात, product_name आणि price स्तंभ दोन्ही डेटाफ्रेम्समध्ये उपस्थित आहेत. `suffixes` पॅरामीटर डाव्या आणि उजव्या डेटाफ्रेम्समधील स्तंभांना अनुक्रमे `_old` आणि `_new` हे सफिक्स जोडते.
df.join() मध्ये `lsuffix` आणि `rsuffix` वापरणे
`lsuffix` आणि `rsuffix` पॅरामीटर्स df.join() साठी समान कार्यक्षमता प्रदान करतात. `lsuffix` डाव्या डेटाफ्रेमच्या ओव्हरलॅपिंग स्तंभांना जोडले जाते आणि `rsuffix` उजव्या डेटाफ्रेमच्या स्तंभांना जोडले जाते.
उदाहरण:
# Join with lsuffix and 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)
आउटपुट:
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
व्यावहारिक उदाहरणे आणि वापराची प्रकरणे
डेटाफ्रेम्स विलीन (मर्ज) करणे आणि जोडणे हे विविध डेटा विश्लेषण परिस्थितींमध्ये मोठ्या प्रमाणावर वापरले जाते. येथे काही व्यावहारिक उदाहरणे आहेत:
विक्री डेटाला उत्पादनाच्या माहितीसोबत एकत्र करणे
विक्री डेटाला उत्पादनाच्या माहितीसोबत एकत्र करणे हे एक सामान्य वापराचे प्रकरण आहे. समजा तुमच्याकडे विक्री व्यवहारांचा एक डेटाफ्रेम आहे आणि उत्पादनाच्या तपशीलांचा दुसरा डेटाफ्रेम आहे. तुम्ही हे डेटाफ्रेम्स विलीन करून विक्री डेटाला उत्पादनाच्या माहितीने समृद्ध करू शकता.
उदाहरण:
# Sales Transactions Data
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']
})
# Product Information Data
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]
})
# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
आउटपुट:
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
परिणामी डेटाफ्रेम df_sales_enriched मध्ये विक्री व्यवहारांची माहिती आणि संबंधित उत्पादनाची माहिती समाविष्ट आहे, ज्यामुळे विक्रीतील ट्रेंड आणि उत्पादनाच्या कार्यक्षमतेचे अधिक तपशीलवार विश्लेषण करता येते.
ग्राहक डेटाला लोकसंख्याशास्त्रीय माहितीसोबत एकत्र करणे
ग्राहक डेटाला लोकसंख्याशास्त्रीय माहितीसोबत एकत्र करणे हे आणखी एक सामान्य वापराचे प्रकरण आहे. यामुळे लोकसंख्याशास्त्रीय घटकांवर आधारित ग्राहकांच्या वर्तणुकीचे विश्लेषण करता येते.
उदाहरण:
# Customer Data
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']
})
# Demographic Information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
आउटपुट:
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
परिणामी डेटाफ्रेम df_customer_demographics मध्ये ग्राहकांचा डेटा त्यांच्या संबंधित शहरांच्या लोकसंख्याशास्त्रीय माहितीसह समाविष्ट आहे, ज्यामुळे शहराच्या लोकसंख्येवर आधारित ग्राहकांच्या वर्तणुकीचे विश्लेषण करणे शक्य होते.
जागतिक पुरवठा साखळी डेटाचे विश्लेषण करणे
पांडास विलीनीकरण (merging) जागतिक पुरवठा साखळी डेटाचे विश्लेषण करण्यासाठी महत्त्वाचे आहे, जिथे माहिती अनेक सारण्यांमध्ये पसरलेली असते. उदाहरणार्थ, पुरवठादार डेटा, शिपिंग माहिती आणि विक्रीची आकडेवारी जोडल्याने अडचणी उघडकीस येऊ शकतात आणि लॉजिस्टिक्स ऑप्टिमाइझ केले जाऊ शकते.
उदाहरण:
# Supplier Data
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Shipping Data
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']
})
# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
आउटपुट:
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
प्रगत विलीनीकरण तंत्रे
अनेक स्तंभांवर विलीनीकरण
`on` पॅरामीटरला स्तंभांच्या नावांची यादी पास करून तुम्ही अनेक स्तंभांवर आधारित डेटाफ्रेम्स विलीन करू शकता.
उदाहरण:
# 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]
})
# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
आउटपुट:
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
वेगवेगळ्या स्तंभ नावांसह विलीनीकरण
जर जॉइन स्तंभांची नावे दोन डेटाफ्रेम्समध्ये भिन्न असतील, तर तुम्ही `left_on` आणि `right_on` पॅरामीटर्स वापरून विलीनीकरणासाठी वापरायच्या स्तंभांची नावे निर्दिष्ट करू शकता.
उदाहरण:
# 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]
})
# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
आउटपुट:
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
विलीनीकरण विश्लेषणासाठी `indicator` वापरणे
pd.merge() मधील `indicator` पॅरामीटर परिणामी डेटाफ्रेममध्ये `_merge` नावाचा एक स्तंभ जोडतो, जो प्रत्येक पंक्तीचा स्त्रोत दर्शवतो. कोणत्या पंक्ती जुळल्या आणि कोणत्या नाहीत हे समजून घेण्यासाठी हे उपयुक्त आहे.
उदाहरण:
# Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
आउटपुट:
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
_merge स्तंभ दर्शवतो की पंक्ती दोन्ही डेटाफ्रेम्समधून (`both`), फक्त डाव्या डेटाफ्रेममधून (`left_only`), किंवा फक्त उजव्या डेटाफ्रेममधून (`right_only`) आहे.
विलीनीकरण प्रकारांची पडताळणी
`validate` पॅरामीटर हे सुनिश्चित करते की विलीनीकरण ऑपरेशन डेटाफ्रेम्समधील अपेक्षित संबंध प्रकारांशी (उदा. 'one_to_one', 'one_to_many') जुळते. यामुळे डेटा विसंगती आणि त्रुटी टाळण्यास मदत होते.
उदाहरण:
# Example with one-to-one validation
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']
})
# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
जर विलीकरणाने निर्दिष्ट पडताळणीचे उल्लंघन केले (उदा. 'one_to_one' निर्दिष्ट असताना अनेक-ते-एक संबंध), तर `MergeError` वाढविला जाईल, ज्यामुळे तुम्हाला संभाव्य डेटा एकात्मता समस्यांबद्दल सतर्क केले जाईल.
कार्यक्षमतेवरील विचार (Performance Considerations)
डेटाफ्रेम्स विलीन (मर्ज) करणे आणि जोडणे हे संगणकीयदृष्ट्या महाग असू शकते, विशेषतः मोठ्या डेटासेटसाठी. कार्यक्षमता सुधारण्यासाठी येथे काही युक्त्या आहेत:
- योग्य जॉइन प्रकार वापरा: योग्य जॉइन प्रकार निवडल्याने कार्यक्षमतेवर लक्षणीय परिणाम होऊ शकतो. उदाहरणार्थ, जर तुम्हाला फक्त जुळणाऱ्या पंक्तींची आवश्यकता असेल, तर इनर जॉइन वापरा.
- जॉइन स्तंभांना अनुक्रमित करा: जॉइन स्तंभांना अनुक्रमित केल्याने विलीनीकरण प्रक्रिया वेगवान होऊ शकते.
- योग्य डेटा प्रकार वापरा: जॉइन स्तंभांमध्ये सुसंगत डेटा प्रकार असल्याची खात्री करा.
- अनावश्यक प्रती टाळा: डेटाच्या अनावश्यक प्रती तयार करणे टाळण्यासाठी
pd.merge()आणिdf.join()मध्येcopy=Falseसेट करा.
निष्कर्ष
डेटाफ्रेम्स विलीन (मर्ज) करणे आणि जोडणे ही डेटा विश्लेषणातील मूलभूत ऑपरेशन्स आहेत. विविध जॉइन प्रकार आणि तंत्रे समजून घेतल्याने, तुम्ही वेगवेगळ्या स्त्रोतांकडून डेटा प्रभावीपणे एकत्र आणि विश्लेषण करू शकता, ज्यामुळे मौल्यवान अंतर्दृष्टी प्राप्त होईल आणि माहितीपूर्ण निर्णय घेता येतील. विक्री डेटाला उत्पादनाच्या माहितीसोबत एकत्र करण्यापासून ते जागतिक पुरवठा साखळ्यांचे विश्लेषण करण्यापर्यंत, या तंत्रांवर प्रभुत्व मिळवल्याने तुम्हाला जटिल डेटा हाताळणीची कार्ये आत्मविश्वासाने हाताळता येतील. मोठ्या डेटासेटवर काम करताना कार्यक्षमतेच्या परिणामांचा विचार करणे आणि अधिक मजबूत आणि अंतर्दृष्टीपूर्ण विश्लेषणासाठी `indicator` आणि `validate` पॅरामीटर्ससारख्या प्रगत वैशिष्ट्यांचा लाभ घेणे लक्षात ठेवा.