pandas में DataFrames को जोड़ना: merge(), concat() और join()

शुरू करें उस लाइब्रेरी को इंपोर्ट करके जिसका उपयोग आप पूरे ट्यूटोरियल में करेंगे: pandas

import pandas as pd
संचालित द्वारा

इस ट्यूटोरियल में आप सभी ऑपरेशंस उन्हीं डमी DataFrames पर करेंगे जिन्हें आप बनाएंगे। एक DataFrame बनाने के लिए, आप इस तरह का Python डिक्शनरी उपयोग कर सकते हैं:

dummy_data1 = {
        'id': ['1', '2', '3', '4', '5'],
        'Feature1': ['A', 'C', 'E', 'G', 'I'],
        'Feature2': ['B', 'D', 'F', 'H', 'J']}
संचालित द्वारा

यहाँ, डिक्शनरी dummy_data1 की कीज़ कॉलम नाम हैं, और सूचियों में मौजूद मान प्रत्येक ऑब्ज़र्वेशन या पंक्ति के अनुरूप डेटा है। इसे pandas DataFrame में बदलने के लिए, आप pandas की DataFrame() फ़ंक्शन के साथ columns आर्ग्युमेंट का उपयोग करेंगे ताकि अपने कॉलम्स के नाम दे सकें:

df1 = pd.DataFrame(dummy_data1, columns = ['id', 'Feature1', 'Feature2'])

df1
संचालित द्वारा

जैसा कि आप देख सकते हैं, अब आपके पास तीन कॉलम—id, Feature1 और Feature2—के साथ एक DataFrame है। एक अतिरिक्त बिना-नाम वाला कॉलम भी है जिसे pandas पंक्तियों के लेबल के रूप में स्वतः बनाता है। पिछले DataFrame df1 की तरह ही, आप दो और DataFrames df2 और df3 बनाएंगे:

dummy_data2 = {
        'id': ['1', '2', '6', '7', '8'],
        'Feature1': ['K', 'M', 'O', 'Q', 'S'],
        'Feature2': ['L', 'N', 'P', 'R', 'T']}
संचालित द्वारा

df2 = pd.DataFrame(dummy_data2, columns = ['id', 'Feature1', 'Feature2'])

df2
संचालित द्वारा

dummy_data3 = {
        'id': ['1', '2', '3', '4', '5', '7', '8', '9', '10', '11'],
        'Feature3': [12, 13, 14, 15, 16, 17, 15, 12, 13, 23]}
संचालित द्वारा

df3 = pd.DataFrame(dummy_data3, columns = ['id', 'Feature3'])

df3
संचालित द्वारा

 concat()

सिर्फ DataFrames को पंक्तियों के साथ जोड़ने के लिए आप pandas में concat() फ़ंक्शन का उपयोग कर सकते हैं। आपको concat() फ़ंक्शन को आर्ग्युमेंट के रूप में DataFrames के नामों की सूची पास करनी होगी:

df_row = pd.concat([df1, df2])

df_row
संचालित द्वारा

आप देख सकते हैं कि अब df1 और df2 दोनों DataFrames पंक्तियों के साथ जोड़कर एक ही DataFrame df_row बन गए हैं। हालांकि, पंक्ति लेबल गलत लग रहे हैं। अगर आप चाहते हैं कि जॉइन के अनुसार पंक्ति लेबल अपने-आप समायोजित हो जाएँ, तो concat() फ़ंक्शन कॉल करते समय ignore_index आर्ग्युमेंट को True सेट करें:

df_row_reindex = pd.concat([df1, df2], ignore_index=True)

df_row_reindex
संचालित द्वारा

अब पंक्ति लेबल सही हैं!

pandas आपको एक और विकल्प देता है कि कंकैटिनेशन के बाद DataFrames को किसी कुंजी से लेबल कर दें, ताकि आपको पता रहे कि कौन-सा डेटा किस DataFrame से आया है। इसके लिए आप अतिरिक्त आर्ग्युमेंट keys पास कर सकते हैं, जिसमें DataFrames के लेबल नामों की सूची होती है। यहाँ आप वही कंकैटिनेशन करेंगे, लेकिन df1 और df2 के लिए क्रमशः x और y कीज़ के साथ।

frames = [df1,df2]
df_keys = pd.concat(frames, keys=['x', 'y'])

df_keys
संचालित द्वारा

कीज़ बताने से किसी विशेष DataFrame के अनुरूप डेटा निकालना भी आसान हो जाता है। आप loc मेथड का उपयोग करके उस DataFrame df2 का डेटा निकाल सकते हैं जिसका लेबल y था:

df_keys.loc['y']
संचालित द्वारा

आप concat() को डिक्शनरी भी पास कर सकते हैं; ऐसे में (जब तक अन्य keys निर्दिष्ट न हों) डिक्शनरी कीज़ ही keys आर्ग्युमेंट के रूप में उपयोग होंगी:

pieces = {'x': df1, 'y': df2}

df_piece = pd.concat(pieces)

df_piece
संचालित द्वारा

ध्यान देने योग्य है कि concat() डेटा की एक पूरी कॉपी बनाता है, और इसे बार-बार उपयोग करना प्रदर्शन पर बड़ा असर डाल सकता है। बड़े पैमाने के डेटा ऑपरेशंस के लिए, हाई-परफॉर्मेंस डेटा मैनिप्युलेशन के लिए pandas 2.0 बनाम polars का अन्वेषण करें। यदि आपको कई डेटासेट्स पर यह ऑपरेशन करना है, तो लिस्ट कॉम्प्रिहेंशन का उपयोग करें।

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)
संचालित द्वारा

कॉलम के साथ DataFrames को जोड़ने के लिए, आप axis पैरामीटर को 1 के रूप में निर्दिष्ट कर सकते हैं:

df_col = pd.concat([df1,df2], axis=1)

df_col
संचालित द्वारा

pandas Merge DataFrames

DataFrames से संबंधित एक और सर्वव्यापी ऑपरेशन है मर्जिंग। दो DataFrames एक ही एंटिटी के बारे में अलग-अलग तरह की जानकारी रख सकते हैं और किसी कॉमन फीचर/कॉलम से जुड़े हो सकते हैं। इन DataFrames को जोड़ने के लिए, pandas concat(), merge(), join() आदि जैसे कई फ़ंक्शंस देता है। इस सेक्शन में, आप pandas के merge() फ़ंक्शन का उपयोग करना सीखेंगे।

आप df_row (जिसे आपने df1 और df2 को पंक्तियों के साथ कंकैटिनेट करके बनाया था) और df3 को कॉमन कॉलम (या की) id पर जॉइन कर सकते हैं। ऐसा करने के लिए, merge() फ़ंक्शन को DataFrames के नाम और अतिरिक्त आर्ग्युमेंट on में कॉमन कॉलम का नाम, यहाँ id, पास करें:

df_merge_col = pd.merge(df_row, df3, on='id')

df_merge_col
संचालित द्वारा

आप देख सकते हैं कि अब DataFrames कॉमन id कॉलम में मौजूद कॉमन मानों के आधार पर एक DataFrame में मर्ज हो गए हैं। उदाहरण के लिए, यहाँ id मान 1 df_row में A, B और K, L दोनों के साथ मौजूद था, इसलिए यह id अंतिम DataFrame df_merge_col में दो बार आई और Feature3 का मान 12 (जो df3 से आया) दोहराया गया।

ऐसा हो सकता है कि जिन कॉलम्स पर आप DataFrames को मर्ज करना चाहते हैं उनके नाम अलग हों (जैसा कि यहाँ नहीं है)। ऐसे मर्ज के लिए, आपको left_on में लेफ्ट DataFrame का कॉलम नाम और right_on में राइट DataFrame का कॉलम नाम निर्दिष्ट करना होगा, जैसे:

df_merge_difkey = pd.merge(df_row, df3, left_on='id', right_on='id')

df_merge_difkey
संचालित द्वारा

आप pd.concat() का उपयोग करके DataFrame में पंक्तियाँ भी जोड़ सकते हैं। पहले पंक्ति डेटा के साथ एक नया DataFrame बनाएँ, फिर उसे मूल DataFrame के साथ कंकैटिनेट करें:

add_row = pd.DataFrame([['10', 'X1', 'X2', 'X3']], 
                       columns=['id', 'Feature1', 'Feature2', 'Feature3'])

df_add_row = pd.concat([df_merge_col, add_row], ignore_index=True)

df_add_row
संचालित द्वारा

pandas जॉइन के प्रकार

इस सेक्शन में, आप किसी कॉमन कॉलम/की के आधार पर pandas DataFrames को मर्ज करने के लिए उपलब्ध विभिन्न जॉइन लॉजिक का अभ्यास करेंगे। इन जोइन्स के पीछे की लॉजिक वही है जो SQL में टेबल्स को जॉइन करते समय होती है। अगर आप SQL में inner बनाम outer जोइन्स से परिचित हैं, तो ये कॉन्सेप्ट्स आपको जान-पहचान के लगेंगे।

फुल आउटर जॉइन

FULL OUTER JOIN लेफ्ट और राइट आउटर जॉइन दोनों के नतीजों को मिलाता है। जॉइन किया गया DataFrame दोनों DataFrames के सभी रिकॉर्ड्स रखेगा और किसी भी तरफ मिलान न होने पर NaN मान भर देगा। आप merge() फ़ंक्शन में how आर्ग्युमेंट को outer सेट करके फुल आउटर जॉइन कर सकते हैं:

df_outer = pd.merge(df1, df2, on='id', how='outer')

df_outer
संचालित द्वारा

आप देख सकते हैं कि परिणामस्वरूप DataFrame में दोनों टेबल्स की सभी एंट्रियाँ हैं और किसी भी तरफ मिलान न होने पर NaN मान हैं। एक और बात ध्यान देने योग्य है कि कॉलम नामों के साथ जो सफिक्स जुड़ा है जिससे पता चलता है कि कौन-सा कॉलम किस DataFrame से आया। डिफ़ॉल्ट सफिक्स x और y होते हैं, लेकिन आप merge() फ़ंक्शन में suffixes आर्ग्युमेंट देकर इन्हें बदल सकते हैं:

df_suffix = pd.merge(df1, df2, left_on='id',right_on='id',how='outer',suffixes=('_left','_right'))

df_suffix
संचालित द्वारा

इनर जॉइन

INNER JOIN केवल वही रिकॉर्ड देता है जो DataFrame A और DataFrame B दोनों में मिलते हैं। इनर जॉइन करने के लिए merge() फ़ंक्शन के how आर्ग्युमेंट में inner पास करें:

df_inner = pd.merge(df1, df2, on='id', how='inner')

df_inner
संचालित द्वारा

राइट जॉइन

RIGHT JOIN DataFrame B (राइट DataFrame) के सभी रिकॉर्ड देता है, और जहाँ मिलान उपलब्ध है वहाँ DataFrame A (लेफ्ट DataFrame) के मिलते-जुलते रिकॉर्ड्स दिखाता है। अगर मिलान नहीं है, तो राइट साइड पर null होगा। राइट जॉइन करने के लिए merge() के how आर्ग्युमेंट में right पास करें:

df_right = pd.merge(df1, df2, on='id', how='right')

df_right
संचालित द्वारा

लेफ्ट जॉइन

LEFT JOIN DataFrame A (लेफ्ट DataFrame) के सभी रिकॉर्ड देता है, और जहाँ मिलान उपलब्ध है वहाँ DataFrame B (राइट DataFrame) के मिलते-जुलते रिकॉर्ड्स दिखाता है। अगर मिलान नहीं है, तो लेफ्ट साइड पर null होगा। लेफ्ट जॉइन करने के लिए merge() के how आर्ग्युमेंट में left पास करें:

df_left = pd.merge(df1, df2, on='id', how='left')

df_left
संचालित द्वारा

इंडेक्स पर जॉइनिंग

कभी-कभी आपको इंडेक्सेस या पंक्ति लेबल्स पर जॉइन करना पड़ सकता है। ऐसा करने के लिए, आपको right_index (राइट DataFrame के इंडेक्सेस के लिए) और left_index (लेफ्ट DataFrame के इंडेक्सेस के लिए) को True सेट करना होगा:

df_index = pd.merge(df1, df2, right_index=True, left_index=True)

df_index
संचालित द्वारा

pandas Join

pandas का DataFrame.join() मेथड यूनिक इंडेक्सेस पर DataFrames को जॉइन करने के लिए उपयोग होता है। आप वैकल्पिक आर्ग्युमेंट `on` का उपयोग करके कॉलम नामों को इंडेक्स पर जॉइन कर सकते हैं और how आर्ग्युमेंट से दो ऑब्जेक्ट्स के बीच ऑपरेशन नियंत्रित कर सकते हैं। डिफ़ॉल्ट रूप से, यह इनर जॉइन का उपयोग करेगा। 

pandas में दो DataFrames जॉइन करना

आइए .join का उपयोग करके दो डेटा फ्रेम्स को जॉइन करें। हमने कॉलम ओवरलैपिंग एरर से बचने के लिए `lsuffix` और `rsuffix` प्रदान किए हैं। यह कॉलम पर नहीं बल्कि इंडेक्स पर जॉइन करता है, इसलिए हमें या तो ‘id’ कॉलम बदलना होगा या सफिक्स देना होगा।

df2.join(df3, lsuffix='_left', rsuffix='_right')

हम `on` आर्ग्युमेंट का उपयोग करके कॉलम्स को इंडेक्स पर भी जॉइन कर सकते हैं। जॉइन सफलतापूर्वक लागू करने के लिए, हमें df3 के ‘id’ कॉलम को इंडेक्स में सेट करना होगा और `on` आर्ग्युमेंट में ‘id’ कॉलम देना होगा। डिफ़ॉल्ट रूप से, यह लेफ्ट जॉइन का उपयोग करेगा।   

df2.join(df3.set_index('id'), on='id')

बिल्कुल merge फ़ंक्शन की तरह, हम `how` आर्ग्युमेंट देकर join का ऑपरेशन बदल सकते हैं। हमारे मामले में, हम इनर जॉइन का उपयोग करेंगे। 

df2.join(df3.set_index('id'), on='id', how = "inner")

टाइम-सीरीज़ फ्रेंडली मर्जिंग

pandas टाइम-सीरीज़ DataFrames को मर्ज करने के लिए विशेष फ़ंक्शंस प्रदान करता है। शायद सबसे उपयोगी और लोकप्रिय merge_asof() फ़ंक्शन है। merge_asof() एक ऑर्डर्ड लेफ्ट-जॉइन जैसा है, फर्क यह है कि आप बराबर कीज़ की बजाय निकटतम की पर मैच करते हैं। लेफ्ट DataFrame की प्रत्येक पंक्ति के लिए, आप राइट DataFrame की वह अंतिम पंक्ति चुनते हैं जिसकी on की लेफ्ट की की तुलना में कम हो। दोनों DataFrames को की के आधार पर सॉर्ट किया हुआ होना चाहिए।

वैकल्पिक रूप से asof मर्ज ग्रुप-वाइज मर्ज भी कर सकता है। यह on की पर निकटतम मैच के अलावा by की पर समानता से मैच करता है।

उदाहरण के लिए, आपके पास ट्रेड्स और कोट्स हो सकते हैं, और आप उन्हें asof मर्ज करना चाहते हैं। यहाँ लेफ्ट DataFrame trades है और राइट DataFrame quotes है। इन्हें time की पर asof मर्ज किया गया है और उनके टिकर सिंबल के आधार पर ग्रुप-वाइज मर्ज किया गया है।

trades = pd.DataFrame({
    'time': pd.to_datetime(['20160525 13:30:00.023',
                            '20160525 13:30:00.038',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.048']),
    'ticker': ['MSFT', 'MSFT','GOOG', 'GOOG', 'AAPL'],
    'price': [51.95, 51.95,720.77, 720.92, 98.00],
    'quantity': [75, 155,100, 100, 100]},
    columns=['time', 'ticker', 'price', 'quantity'])

quotes = pd.DataFrame({
    'time': pd.to_datetime(['20160525 13:30:00.023',
                            '20160525 13:30:00.023',
                            '20160525 13:30:00.030',
                            '20160525 13:30:00.041',
                            '20160525 13:30:00.048',
                            '20160525 13:30:00.049',
                            '20160525 13:30:00.072',
                            '20160525 13:30:00.075']),
    'ticker': ['GOOG', 'MSFT', 'MSFT','MSFT', 'GOOG', 'AAPL', 'GOOG','MSFT'],
    'bid': [720.50, 51.95, 51.97, 51.99,720.50, 97.99, 720.50, 52.01],
    'ask': [720.93, 51.96, 51.98, 52.00,720.93, 98.01, 720.88, 52.03]},
    columns=['time', 'ticker', 'bid', 'ask'])संचालित द्वारा

trades
संचालित द्वारा

quotes
संचालित द्वारा

df_merge_asof = pd.merge_asof(trades, quotes,
              on='time',
              by='ticker')

df_merge_asof
संचालित द्वारा

अगर आप ध्यान से देखें, तो AAPL टिकर वाली पंक्ति में NaN आने का कारण समझ आएगा। क्योंकि राइट DataFrame quotes में AAPL टिकर के लिए लेफ्ट टेबल के समय 13:30:00.048 से कम कोई time मान नहीं था, इसलिए bid और ask कॉलम में NaN आ गए।

आप time कॉलम के लिए एक पूर्वनिर्धारित टॉलरेंस स्तर भी सेट कर सकते हैं। मान लीजिए कि आप केवल quote time और trade time के बीच 2ms के भीतर asof मर्ज करना चाहते हैं, तो आपको tolerance आर्ग्युमेंट देना होगा:

df_merge_asof_tolerance = pd.merge_asof(trades, quotes,
              on='time',
              by='ticker',
              tolerance=pd.Timedelta('2ms'))

df_merge_asof_tolerance
संचालित द्वारा

ऊपर और पिछले परिणाम के बीच फर्क नोट करें। अगर समय की टॉलरेंस 2ms के भीतर नहीं है तो पंक्तियाँ मर्ज नहीं होतीं।

निष्कर्ष

इस ट्यूटोरियल में, आपने pandas लाइब्रेरी के concat() और merge() फ़ंक्शंस का उपयोग करके विभिन्न लॉजिक के आधार पर DataFrames को कंकैटिनेट और मर्ज करना सीखा। अंत में, आपने टाइम-सीरीज़ DataFrames को मर्ज करने के लिए विशेष फ़ंक्शन merge_asof() का अभ्यास किया। रास्ते में, आपने DataFrame इंडेक्सेस के साथ काम करना भी सीखा। pandas में DataFrames को जॉइन करने के लिए कई अन्य विकल्प हैं; मैं आपको इसकी बेहतरीन डॉक्यूमेंटेशन देखने के लिए प्रोत्साहित करता हूँ। शुभकामनाएँ!

इस ट्यूटोरियल को लिखने में सहायता के लिए यह pandas डॉक्यूमेंटेशन इस्तेमाल किया गया।

अगर आप pandas के बारे में और सीखना चाहते हैं, तो DataCamp का Data Manipulation with pandas कोर्स लें और हमारा Python Pandas में DataFrames ट्यूटोरियल देखें।

DataCamp के पास कई और उपयोगी pandas ट्यूटोरियल भी हैं, जिनमें शामिल हैं:

• CSV डेटा को pandas में इंपोर्ट करना
• pandas में कॉलम जोड़ना
• pandas में मानों को सॉर्ट करना
• pandas में डुप्लिकेट्स हटाना drop_duplicates के साथ
• pandas groupby के साथ डेटा को ग्रुप करना
• pandas में DataFrame इंडेक्सेस रीसेट करना

हैप्पी लर्निंग!