pandas 0.23 - 15. Merge, join, and concatenate

मर्ज करें, जुड़ें, और संक्षिप्त करें




pandas

मर्ज करें, जुड़ें, और संक्षिप्त करें

पांडा शामिल होने / मर्ज-प्रकार के संचालन के मामले में अनुक्रमित और संबंधपरक बीजगणित कार्यक्षमता के लिए विभिन्न प्रकार के सेट लॉजिक के साथ श्रृंखला, डेटाफ़्रेम, और पैनल ऑब्जेक्ट्स को आसानी से एक साथ संयोजित करने के लिए विभिन्न सुविधाएं प्रदान करता है।

सम्वेदनशील वस्तु

अन्य अक्षों पर अनुक्रमणिका (यदि कोई हो) के वैकल्पिक सेट लॉजिक (संघ या चौराहे) का प्रदर्शन करते समय concat() (मुख्य पंडों के नाम स्थान में) एक अक्ष के साथ तालमेल संचालन के भारी उठाने का कार्य करता है। ध्यान दें कि मैं "यदि कोई हो तो" कहो क्योंकि श्रृंखला के लिए केवल एक ही संभव धुरी है।

concat सभी विवरणों में गोता लगाने से पहले और यह क्या कर सकता है, यहां एक सरल उदाहरण है:

In [1]: df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
   ...:                     'B': ['B0', 'B1', 'B2', 'B3'],
   ...:                     'C': ['C0', 'C1', 'C2', 'C3'],
   ...:                     'D': ['D0', 'D1', 'D2', 'D3']},
   ...:                     index=[0, 1, 2, 3])
   ...: 

In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
   ...:                     'B': ['B4', 'B5', 'B6', 'B7'],
   ...:                     'C': ['C4', 'C5', 'C6', 'C7'],
   ...:                     'D': ['D4', 'D5', 'D6', 'D7']},
   ...:                      index=[4, 5, 6, 7])
   ...: 

In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
   ...:                     'B': ['B8', 'B9', 'B10', 'B11'],
   ...:                     'C': ['C8', 'C9', 'C10', 'C11'],
   ...:                     'D': ['D8', 'D9', 'D10', 'D11']},
   ...:                     index=[8, 9, 10, 11])
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat(frames)
_images / merging_concat_basic.png

Ndarrays, numpy.concatenate , pandas.concat पर इसके सिबलिंग फंक्शन की तरह, एक सूची या सजातीय-टाइप की गई वस्तुओं का pandas.concat लेता है और उन्हें "कुछ अन्य कुल्हाड़ियों के साथ क्या करना है" के कुछ कॉन्फ़िगर करने योग्य हैंडलिंग के साथ उन्हें pandas.concat है:

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
  • objs : श्रृंखला, DataFrame, या पैनल ऑब्जेक्ट्स का एक अनुक्रम या मानचित्रण। यदि एक तानाशाही पारित किया जाता है, तो छांटे गए कुंजियों को keys तर्क के रूप में उपयोग किया जाएगा, जब तक कि इसे पारित नहीं किया जाता है, जिस स्थिति में मूल्यों का चयन किया जाएगा (नीचे देखें)। जब तक वे सभी नहीं हैं, तब तक किसी भी वस्तु को चुपचाप नहीं गिराया जाएगा, इस मामले में एक वैल्यूएयर उठाया जाएगा।
  • axis : {0, 1,…}, डिफ़ॉल्ट 0. अक्ष को साथ ले जाने के लिए।
  • join : {'भीतर', 'बाहरी'}, डिफ़ॉल्ट 'बाहरी'। अन्य अक्ष पर अनुक्रमणिकाओं को कैसे संभालना है (तों)। संघ के लिए बाहरी और चौराहे के लिए आंतरिक।
  • ignore_index : बूलियन, डिफ़ॉल्ट गलत। यदि सही है, तो अनुक्रमण अक्ष पर इंडेक्स मान का उपयोग न करें। परिणामी अक्ष को 0,…, n - 1 के रूप में लेबल किया जाएगा। यह तब उपयोगी होता है जब आप ऐसी वस्तुओं का संघटन कर रहे होते हैं, जहां संघनन अक्ष में सार्थक अनुक्रमण जानकारी नहीं होती है। नोट करें कि अन्य अक्षों पर सूचकांक मान अभी भी जुड़ने में सम्मानित हैं।
  • join_axes : इंडेक्स ऑब्जेक्ट्स की सूची। आंतरिक / बाहरी सेट तर्क प्रदर्शन करने के बजाय अन्य n - 1 कुल्हाड़ियों के लिए उपयोग करने के लिए विशिष्ट अनुक्रमित।
  • keys : अनुक्रम, डिफ़ॉल्ट कोई नहीं। बाहरी स्तर के रूप में पारित कुंजियों का उपयोग करके पदानुक्रमित सूचकांक का निर्माण करें। यदि कई स्तर पास हो गए हैं, तो ट्यूपल्स होने चाहिए।
  • levels : अनुक्रमों की सूची, डिफ़ॉल्ट कोई नहीं। MultiIndex निर्माण के लिए उपयोग करने के लिए विशिष्ट स्तर (अद्वितीय मान)। अन्यथा वे कुंजियों से हीन हो जाएंगे।
  • names : सूची, डिफ़ॉल्ट कोई नहीं। परिणामी पदानुक्रमित सूचकांक में स्तरों के लिए नाम।
  • verify_integrity : बूलियन, डिफ़ॉल्ट गलत। जांचें कि क्या नए कॉन्टेनेटेड अक्ष में डुप्लिकेट हैं। यह वास्तविक डेटा संगति के सापेक्ष बहुत महंगा हो सकता है।
  • copy : बूलियन, डिफ़ॉल्ट सही। यदि गलत है, तो डेटा को अनावश्यक रूप से कॉपी न करें।

थोड़ा सा संदर्भ के बिना इनमें से कई तर्क बहुत मायने नहीं रखते हैं। उपरोक्त उदाहरण को फिर से देखें। मान लीजिए कि हम कटा हुआ डेटाफ्रेम के प्रत्येक टुकड़े के साथ विशिष्ट कुंजी को जोड़ना चाहते थे। हम keys तर्क का उपयोग करके ऐसा कर सकते हैं:

In [6]: result = pd.concat(frames, keys=['x', 'y', 'z'])
_images / merging_concat_keys.png

जैसा कि आप देख सकते हैं (यदि आपने बाकी दस्तावेज़ पढ़े हैं), तो परिणामी वस्तु के सूचकांक में एक श्रेणीबद्ध सूचकांक है । इसका अर्थ है कि अब हम कुंजी द्वारा प्रत्येक चंक को चुन सकते हैं:

In [7]: result.loc['y']
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

यह देखने के लिए एक खिंचाव नहीं है कि यह बहुत उपयोगी कैसे हो सकता है। नीचे इस कार्यक्षमता पर अधिक विवरण।

ध्यान दें

यह ध्यान देने योग्य है कि concat() और (इसलिए append() ) डेटा की पूरी प्रतिलिपि बनाता है, और इस फ़ंक्शन का लगातार पुन: उपयोग करने से एक महत्वपूर्ण प्रदर्शन हिट हो सकता है। यदि आपको कई डेटासेट पर ऑपरेशन का उपयोग करने की आवश्यकता है, तो सूची समझ का उपयोग करें।

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)

दूसरे अक्षों पर तर्क सेट करें

जब एक साथ कई DataFrames को ग्लूइंग किया जाता है, तो आपके पास एक विकल्प होता है कि दूसरे अक्षों को कैसे संभाला जाए (एक समवर्ती होने के अलावा)। यह निम्नलिखित तीन तरीकों से किया जा सकता है:

  • उन सभी के मिलन में join='outer' , join='outer' । यह डिफ़ॉल्ट विकल्प है क्योंकि इसके परिणामस्वरूप शून्य जानकारी का नुकसान होता है।
  • चौराहा लेना, join='inner'
  • join_axes तर्क के join_axes , एक विशिष्ट सूचकांक का उपयोग करें।

इनमें से प्रत्येक विधि का एक उदाहरण यहां दिया गया है। सबसे पहले, डिफ़ॉल्ट में join='outer' व्यवहार:

In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
   ...:                     'D': ['D2', 'D3', 'D6', 'D7'],
   ...:                     'F': ['F2', 'F3', 'F6', 'F7']},
   ...:                    index=[2, 3, 6, 7])
   ...: 

In [9]: result = pd.concat([df1, df4], axis=1, sort=False)
_images / merging_concat_axis1.png

चेतावनी

संस्करण में परिवर्तित किया गया 0.23.0।

join='outer' साथ डिफ़ॉल्ट व्यवहार join='outer' अन्य अक्ष (इस मामले में कॉलम) को सॉर्ट करने के लिए है। पांडा के भविष्य के संस्करण में, डिफ़ॉल्ट को सॉर्ट नहीं करना होगा। हमने अब नए व्यवहार का विकल्प चुनने के लिए sort=False निर्दिष्ट किया।

यहाँ एक ही बात के साथ join='inner' :

In [10]: result = pd.concat([df1, df4], axis=1, join='inner')
_images / merging_concat_axis1_inner.png

अंत में, मान लें कि हम मूल डेटा से सटीक इंडेक्स का पुन: उपयोग करना चाहते थे:

In [11]: result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
_images / merging_concat_axis1_join_axes.png

उपांग का उपयोग करते हुए

DataFrame append() लिए एक उपयोगी शॉर्टकट Series और DataFrame पर append() उदाहरण के तरीके हैं। ये विधियां वास्तव में संक्षिप्त रूप से पूर्ववर्ती concat । वे axis=0 साथ संघात करते हैं, अर्थात् सूचकांक:

In [12]: result = df1.append(df2)
_images / merging_append1.png

DataFrame के मामले में, अनुक्रमणिका को DataFrame होना चाहिए, लेकिन कॉलम होने की आवश्यकता नहीं है:

In [13]: result = df1.append(df4)
_images / merging_append2.png

append को append लिए कई वस्तुओं को ले जा सकता है:

In [14]: result = df1.append([df2, df3])
_images / merging_append3.png

ध्यान दें

append() विधि के विपरीत, जो मूल सूची में append() और None लौटाता है, यहाँ append() df1 संशोधित नहीं करता है और इसकी प्रतिलिपि df2 संलग्न के साथ df2 है।

अनुक्रमण अक्ष पर अनुक्रमणिका को अनदेखा करना

DataFrame s के लिए जो एक सार्थक सूचकांक नहीं है, आप उन्हें जोड़ना चाह सकते हैं और इस तथ्य को अनदेखा कर सकते हैं कि उनके पास ओवरले इंडेक्स हो सकते हैं। ऐसा करने के लिए, ignore_index तर्क का उपयोग करें:

In [15]: result = pd.concat([df1, df4], ignore_index=True)
_images / merging_concat_ignore_index.png

यह append() लिए एक मान्य तर्क भी है:

In [16]: result = df1.append(df4, ignore_index=True)
_images / merging_append_ignore_index.png

मिश्रित ndims के साथ संबंध

आप Series और DataFrame एस के मिश्रण को मिला सकते हैं। Series स्तंभ नाम के साथ Series के नाम के रूप में DataFrame बदल जाएगी।

In [17]: s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')

In [18]: result = pd.concat([df1, s1], axis=1)
_images / merging_concat_mixed_ndim.png

ध्यान दें

चूँकि हम किसी DataFrame एक Series को DataFrame कर रहे हैं, हम DataFrame.assign() साथ एक ही परिणाम प्राप्त कर सकते हैं। DataFrame ऑब्जेक्ट्स ( DataFrame या Series ) की एक मनमानी संख्या को DataFrame , concat उपयोग करें।

यदि अनाम Series पास की जाती है तो उन्हें लगातार क्रमांकित किया जाएगा।

In [19]: s2 = pd.Series(['_0', '_1', '_2', '_3'])

In [20]: result = pd.concat([df1, s2, s2, s2], axis=1)
_images / merging_concat_unnamed_series.png

ignore_index=True पास ignore_index=True सभी नाम संदर्भों को छोड़ देगा।

In [21]: result = pd.concat([df1, s1], axis=1, ignore_index=True)
_images / merging_concat_series_ignore_index.png

समूह कुंजियों के साथ अधिक संक्षिप्त

keys तर्क का एक सामान्य उपयोग मौजूदा Series आधार पर एक नया DataFrame बनाते समय स्तंभ नामों को ओवरराइड करने के लिए है। ध्यान दें कि परिणामी DataFrame को माता-पिता Series के नाम के उत्तराधिकार में देने पर डिफ़ॉल्ट व्यवहार कैसे होता है, जब ये मौजूद थे।

In [22]: s3 = pd.Series([0, 1, 2, 3], name='foo')

In [23]: s4 = pd.Series([0, 1, 2, 3])

In [24]: s5 = pd.Series([0, 1, 4, 5])

In [25]: pd.concat([s3, s4, s5], axis=1)
Out[25]: 
   foo  0  1
0    0  0  0
1    1  1  1
2    2  2  4
3    3  3  5

keys तर्क के माध्यम से हम मौजूदा कॉलम नामों को ओवरराइड कर सकते हैं।

In [26]: pd.concat([s3, s4, s5], axis=1, keys=['red','blue','yellow'])
Out[26]: 
   red  blue  yellow
0    0     0       0
1    1     1       1
2    2     2       4
3    3     3       5

आइए प्रस्तुत पहले उदाहरण के एक बदलाव पर विचार करें:

In [27]: result = pd.concat(frames, keys=['x', 'y', 'z'])
_images / merging_concat_group_keys2.png

आप इस बात के लिए एक तानाशाही पास कर सकते हैं कि किस स्थिति में keys तर्क के लिए तानाशाही कुंजी का उपयोग किया जाएगा (जब तक कि अन्य कुंजियाँ निर्दिष्ट नहीं की जाती हैं):

In [28]: pieces = {'x': df1, 'y': df2, 'z': df3}

In [29]: result = pd.concat(pieces)
_images / merging_concat_dict.png
In [30]: result = pd.concat(pieces, keys=['z', 'y'])
_images / merging_concat_dict_keys.png

बनाए गए MultiIndex में वे स्तर होते हैं जो पास कीज़ और DataFrame टुकड़ों के सूचकांक से DataFrame होते हैं:

In [31]: result.index.levels
Out[31]: FrozenList([['z', 'y'], [4, 5, 6, 7, 8, 9, 10, 11]])

यदि आप अन्य स्तरों को निर्दिष्ट करना चाहते हैं (जैसा कि कभी-कभी मामला होगा), तो आप levels तर्क का उपयोग करके ऐसा कर सकते हैं:

In [32]: result = pd.concat(pieces, keys=['x', 'y', 'z'],
   ....:                 levels=[['z', 'y', 'x', 'w']],
   ....:                 names=['group_key'])
   ....: 
_images / merging_concat_dict_keys_names.png
In [33]: result.index.levels
Out[33]: FrozenList([['z', 'y', 'x', 'w'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])

यह काफी गूढ़ है, लेकिन यह वास्तव में GroupBy जैसी चीजों को लागू करने के लिए आवश्यक है जहां एक श्रेणीगत चर का क्रम सार्थक है।

एक DataFrame में पंक्तियों को लागू करना

जबकि विशेष रूप से कुशल नहीं है (चूंकि एक नई वस्तु बनाई जानी चाहिए), आप एक एकल पंक्ति को जोड़ सकते हैं एक DataFrame को एक Series या DataFrame पारित करने के लिए append , जो ऊपर के रूप में एक नया DataFrame लौटाता है।

In [34]: s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])

In [35]: result = df1.append(s2, ignore_index=True)
_images / merging_append_series_as_row.png

आपको DataFrame को इसके सूचकांक को छोड़ने का निर्देश देने के लिए इस पद्धति के साथ ignore_index उपयोग करना चाहिए। यदि आप सूचकांक को संरक्षित करना चाहते हैं, तो आपको उचित रूप से अनुक्रमित DataFrame का निर्माण करना चाहिए और उन वस्तुओं को जोड़ना या जोड़ना चाहिए।

आप डाइट या श्रृंखला की सूची भी पास कर सकते हैं:

In [36]: dicts = [{'A': 1, 'B': 2, 'C': 3, 'X': 4},
   ....:          {'A': 5, 'B': 6, 'C': 7, 'Y': 8}]
   ....: 

In [37]: result = df1.append(dicts, ignore_index=True)
_images / merging_append_dits.png

डेटाबेस-शैली DataFrame जॉइनिंग / विलय

पांडा में पूर्ण-विशेषताओं, उच्च प्रदर्शन -इन-मेमोरी शामिल हैं जो मुहावरेदार रूप से SQL जैसे रिलेशनल डेटाबेस के समान कार्य करते हैं। ये तरीके अन्य खुले स्रोत कार्यान्वयन की तुलना में (कुछ मामलों में अच्छी तरह से बेहतर परिमाण के एक आदेश पर) बेहतर प्रदर्शन करते हैं (जैसे base::merge.data.frame आर में base::merge.data.frame )। इसका कारण सावधान एल्गोरिथम डिज़ाइन और DataFrame में डेटा का आंतरिक लेआउट है।

कुछ उन्नत रणनीतियों के लिए cookbook की cookbook देखें।

वे उपयोगकर्ता जो SQL से परिचित हैं, लेकिन नए पांडा के साथ तुलना में दिलचस्पी ले सकते हैं।

पांडा एक एकल फ़ंक्शन प्रदान करता है, merge() , सभी मानक डेटाबेस के लिए प्रवेश बिंदु DataFrame ऑब्जेक्ट्स के बीच संचालन में शामिल DataFrame है:

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True,
         suffixes=('_x', '_y'), copy=True, indicator=False,
         validate=None)
  • left : एक DataFrame ऑब्जेक्ट।
  • right : एक और DataFrame ऑब्जेक्ट।
  • on : कॉलम या इंडेक्स लेवल के नामों पर शामिल होने के लिए। बाएँ और दाएँ दोनों DataFrame ऑब्जेक्ट में पाया जाना चाहिए। यदि पारित नहीं किया गया है और left_index और right_index False , तो डेटा फ़्रेम्स में कॉलम का चौराहा जुड़ने की कुंजी होने का अनुमान लगाया जाएगा।
  • left_on : कुंजी के रूप में उपयोग करने के लिए बाएं DataFrame से कॉलम या इंडेक्स स्तर। या तो स्तंभ नाम, सूचकांक स्तर के नाम हो सकते हैं, या DataFrame की लंबाई के बराबर लंबाई के साथ सरणियाँ हो सकती हैं।
  • right_on : कुंजी के रूप में उपयोग करने के लिए सही DataFrame से कॉलम या इंडेक्स स्तर। या तो स्तंभ नाम, सूचकांक स्तर के नाम हो सकते हैं, या DataFrame की लंबाई के बराबर लंबाई के साथ सरणियाँ हो सकती हैं।
  • left_index : यदि यह True , तो बाईं DataFrame से अनुक्रमणिका (पंक्ति लेबल) का उपयोग उसकी ज्वाइन की (कुंजी) के रूप में करें। एक MultiFndex (पदानुक्रमित) के साथ एक DataFrame के मामले में, स्तरों की संख्या सही DataFrame से जुड़ने की कुंजी की संख्या से मेल खाना चाहिए।
  • right_index : दाएँ DataFrame के लिए left_index समान उपयोग
  • how : 'left' , 'right' , 'outer' , 'inner'inner तक inner । प्रत्येक विधि के अधिक विस्तृत विवरण के लिए नीचे देखें।
  • sort करें: परिणाम को क्रमबद्ध करें लेक्सोग्राफिक क्रम में सम्मिलित कुंजियों द्वारा डेटाफ़्रेम। True मायने में चूक, False सेट करने से कई मामलों में प्रदर्शन में काफी सुधार होगा।
  • suffixes : अतिव्यापी स्तंभों पर लागू करने के लिए स्ट्रिंग प्रत्यय का एक टपल। ('_x', '_y') लिए डिफ़ॉल्ट।
  • copy : हमेशा पास किए गए डेटाफ़्रेम ऑब्जेक्ट्स से डेटा (डिफ़ॉल्ट True ) की प्रतिलिपि बनाएँ, तब भी जब रेनडेक्सिंग आवश्यक नहीं है। कई मामलों में टाला नहीं जा सकता है, लेकिन प्रदर्शन / स्मृति उपयोग में सुधार हो सकता है। जिन मामलों में नकल से बचा जा सकता है, वे कुछ हद तक पैथोलॉजिकल हैं, लेकिन फिर भी यह विकल्प प्रदान नहीं किया जाता है।
  • indicator : आउटपुट के लिए एक कॉलम जोड़ें DataFrame जिसे प्रत्येक पंक्ति के स्रोत पर जानकारी के साथ _merge कहा जाता है। _merge प्रकार है और टिप्पणियों के लिए left_only मान पर ले जाता है जिसकी मर्ज कुंजी केवल 'left' DataFrame में दिखाई देती है, right_only टिप्पणियों के लिए जिनकी मर्ज कुंजी केवल 'right' DataFame में दिखाई देती है, और यदि अवलोकन की मर्ज कुंजी दोनों में मिलती है। ।
  • validate : स्ट्रिंग, डिफ़ॉल्ट कोई नहीं। यदि निर्दिष्ट किया गया है, तो जाँचें कि मर्ज निर्दिष्ट प्रकार का है।

    • "One_to_one" या "1: 1": जाँच करता है कि मर्ज कीज़ बाएँ और दाएँ दोनों डेटासेट में अद्वितीय हैं।
    • "One_to_many" या "1: m": जाँचता है कि मर्ज कुंजियाँ बाएं डेटासेट में अद्वितीय हैं या नहीं।
    • "Many_to_one" या "m: 1": यह जाँचता है कि क्या सही कुंजी दाएं डाटासेट में विलीन है।
    • "Many_to_many" या "m: m": अनुमत है, लेकिन चेक में परिणाम नहीं होता है।

    संस्करण में नया 0.21.0।

ध्यान दें

इंडेक्स लेवल को on , left_on , और right_on पैरामीटर निर्दिष्ट करने के लिए सपोर्ट 0.23.0 वर्जन में जोड़ा गया था।

वापसी का प्रकार left जैसा ही होगा। यदि left एक DataFrame और right DataFrame का उपवर्ग है, तो रिटर्न प्रकार अभी भी DataFrame

merge पंडों के नामस्थान में एक फ़ंक्शन है, और यह DataFrame उदाहरण विधि merge() रूप में भी उपलब्ध है, जिसमें DataFrame को अंतर्निहित रूप से बाएं ऑब्जेक्ट में शामिल माना जाता है।

संबंधित join() विधि, इंडेक्स-ऑन-इंडेक्स (डिफ़ॉल्ट रूप से) और कॉलम (एस) -ऑन-इंडेक्स में शामिल होने के लिए आंतरिक रूप से merge का उपयोग करता है। यदि आप केवल इंडेक्स पर शामिल हो रहे हैं, तो आप अपने आप को कुछ टाइपिंग को बचाने के लिए DataFrame.join का उपयोग करना चाह सकते हैं।

मर्ज विधियों पर संक्षिप्त प्राइमर (संबंधपरक बीजगणित)

SQL जैसे रिलेशनल डेटाबेस के अनुभवी उपयोगकर्ता संरचनाओं ( DataFrame ऑब्जेक्ट्स) जैसे दो SQL- टेबल के बीच जुड़ने के संचालन का वर्णन करने के लिए उपयोग की जाने वाली शब्दावली से परिचित होंगे। ऐसे कई मामले हैं जिन पर विचार करना बहुत जरूरी है:

  • एक-से-एक जुड़ता है: उदाहरण के लिए जब दो DataFrame ऑब्जेक्ट्स को उनकी अनुक्रमणिका में शामिल करना (जिसमें अद्वितीय मान होना चाहिए)।
  • कई-टू-वन जॉइन करता है: उदाहरण के लिए जब एक इंडेक्स (यूनीक) को एक अलग DataFrame में एक या एक से अधिक कॉलम से DataFrame
  • कई-से-कई जुड़ते हैं: स्तंभों पर कॉलम जोड़ते हैं।

ध्यान दें

स्तंभों पर स्तंभों को DataFrame (संभवतः कई-से-कई DataFrame हों), पास DataFrame गए DataFrame ऑब्जेक्ट्स पर कोई भी अनुक्रमणिका छोड़ दी जाएगी

यह कई-से-कई सम्मिलित मामले के परिणाम को समझने में कुछ समय बिताने के लायक है। एसक्यूएल / मानक संबंधपरक बीजगणित में, यदि एक महत्वपूर्ण संयोजन दोनों तालिकाओं में एक से अधिक बार दिखाई देता है, तो परिणामी तालिका में संबंधित डेटा का कार्टेशियन उत्पाद होगा। यहां एक विशिष्ट कुंजी संयोजन के साथ एक बहुत ही बुनियादी उदाहरण दिया गया है:

In [38]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
   ....:                      'A': ['A0', 'A1', 'A2', 'A3'],
   ....:                      'B': ['B0', 'B1', 'B2', 'B3']})
   ....: 

In [39]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
   ....:                       'C': ['C0', 'C1', 'C2', 'C3'],
   ....:                       'D': ['D0', 'D1', 'D2', 'D3']})
   ....: 

In [40]: result = pd.merge(left, right, on='key')
_images / merging_merge_on_key.png

यहां एकाधिक सम्मिलित कुंजियों के साथ एक अधिक जटिल उदाहरण है। केवल left और right में दिखाई देने वाली कुंजियाँ मौजूद हैं (अंतरजाल), क्योंकि डिफ़ॉल्ट रूप से how='inner'

In [41]: left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
   ....:                      'key2': ['K0', 'K1', 'K0', 'K1'],
   ....:                      'A': ['A0', 'A1', 'A2', 'A3'],
   ....:                      'B': ['B0', 'B1', 'B2', 'B3']})
   ....: 

In [42]: right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
   ....:                       'key2': ['K0', 'K0', 'K0', 'K0'],
   ....:                       'C': ['C0', 'C1', 'C2', 'C3'],
   ....:                       'D': ['D0', 'D1', 'D2', 'D3']})
   ....: 

In [43]: result = pd.merge(left, right, on=['key1', 'key2'])
_images / merging_merge_on_key_multiple.png

merge करने का तर्क निर्दिष्ट करता है कि परिणाम तालिका में किन कुंजियों को शामिल किया जाना है। यदि एक कुंजी संयोजन बाएं या दाएं तालिकाओं में प्रकट नहीं होता है , तो शामिल तालिका में मान NA । यहाँ how विकल्पों और उनके SQL समकक्ष नामों का सारांश दिया गया है:

मर्ज करने की विधि SQL नाम से जुड़ें विवरण
left LEFT OUTER JOIN केवल बाएं फ्रेम से कुंजियों का उपयोग करें
right RIGHT OUTER JOIN केवल सही फ्रेम से कुंजियों का उपयोग करें
outer FULL OUTER JOIN दोनों फ्रेम से चाबियों के मिलन का उपयोग करें
inner INNER JOIN दोनों फ़्रेमों से कुंजियों के प्रतिच्छेदन का उपयोग करें
In [44]: result = pd.merge(left, right, how='left', on=['key1', 'key2'])
_images / merging_merge_on_key_left.png
In [45]: result = pd.merge(left, right, how='right', on=['key1', 'key2'])
_images / merging_merge_on_key_right.png
In [46]: result = pd.merge(left, right, how='outer', on=['key1', 'key2'])
_images / merging_merge_on_key_outer.png
In [47]: result = pd.merge(left, right, how='inner', on=['key1', 'key2'])
_images / merging_merge_on_key_inner.png

यहाँ डेटाफ़्रेम में डुप्लिकेट जॉइन कीज़ के साथ एक और उदाहरण दिया गया है:

In [48]: left = pd.DataFrame({'A' : [1,2], 'B' : [2, 2]})

In [49]: right = pd.DataFrame({'A' : [4,5,6], 'B': [2,2,2]})

In [50]: result = pd.merge(left, right, on='B', how='outer')
_images / merging_merge_on_key_dup.png

चेतावनी

डुप्लिकेट कुंजियों पर शामिल होने / विलय करने से एक लौटा हुआ फ्रेम हो सकता है जो पंक्ति आयामों का गुणन है, जिसके परिणामस्वरूप मेमोरी अतिप्रवाह हो सकता है। बड़े डेटाफ़्रेम में शामिल होने से पहले कुंजी में डुप्लिकेट मानों को प्रबंधित करना उपयोगकर्ता की ज़िम्मेदारी है।

डुप्लिकेट कुंजी के लिए जाँच कर रहा है

संस्करण में नया 0.21.0।

उपयोगकर्ता अपने मर्ज कीज़ में अप्रत्याशित डुप्लिकेट हैं या नहीं, यह जांचने के लिए validate तर्क का उपयोग कर सकते हैं। मर्ज के संचालन से पहले मुख्य विशिष्टता की जाँच की जाती है और इसलिए मेमोरी ओवरफ्लो से बचाव करना चाहिए। उपयोगकर्ता डेटा संरचनाओं को अपेक्षित रूप से सुनिश्चित करने के लिए कुंजी विशिष्टता की जांच करना भी एक अच्छा तरीका है।

निम्नलिखित उदाहरण में, सही DataFrame में B डुप्लिकेट मान हैं। जैसा कि यह एक-से-एक मर्ज नहीं है - जैसा कि validate तर्क में निर्दिष्ट है - एक अपवाद उठाया जाएगा।

In [51]: left = pd.DataFrame({'A' : [1,2], 'B' : [1, 2]})

In [52]: right = pd.DataFrame({'A' : [4,5,6], 'B': [2, 2, 2]})
In [53]: result = pd.merge(left, right, on='B', how='outer', validate="one_to_one")
...
MergeError: Merge keys are not unique in right dataset; not a one-to-one merge

यदि उपयोगकर्ता को सही DataFrame में डुप्लिकेट के बारे में पता है, लेकिन यह सुनिश्चित करना चाहता है कि बाएँ DataFrame में कोई डुप्लिकेट नहीं हैं, तो कोई validate='one_to_many' तर्क का उपयोग कर सकता है, जो अपवाद नहीं उठाएगा।

In [53]: pd.merge(left, right, on='B', how='outer', validate="one_to_many")
Out[53]: 
   A_x  B  A_y
0    1  1  NaN
1    2  2  4.0
2    2  2  5.0
3    2  2  6.0

मर्ज सूचक

merge() तर्क indicator स्वीकार करता है। यदि True , तो _merge नामक एक श्रेणीबद्ध प्रकार का स्तंभ आउटपुट ऑब्जेक्ट में जोड़ा जाएगा जो मान लेता है:

अवलोकन मूल _merge मान _merge
केवल 'left' फ़्रेम में मर्ज करें left_only
केवल 'right' फ़्रेम में मर्ज करें right_only
दोनों फ्रेम में कीज को मर्ज करें both
In [54]: df1 = pd.DataFrame({'col1': [0, 1], 'col_left':['a', 'b']})

In [55]: df2 = pd.DataFrame({'col1': [1, 2, 2],'col_right':[2, 2, 2]})

In [56]: pd.merge(df1, df2, on='col1', how='outer', indicator=True)
Out[56]: 
   col1 col_left  col_right      _merge
0     0        a        NaN   left_only
1     1        b        2.0        both
2     2      NaN        2.0  right_only
3     2      NaN        2.0  right_only

indicator तर्क स्ट्रिंग तर्कों को भी स्वीकार करेगा, जिस स्थिति में संकेतक फ़ंक्शन सूचक स्तंभ के लिए नाम के रूप में पारित स्ट्रिंग के मूल्य का उपयोग करेगा।

In [57]: pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
Out[57]: 
   col1 col_left  col_right indicator_column
0     0        a        NaN        left_only
1     1        b        2.0             both
2     2      NaN        2.0       right_only
3     2      NaN        2.0       right_only

मर्ज की डोरियां

संस्करण में नया 0.19.0।

विलय में शामिल कुंजियों के dtype को संरक्षित करेगा।

In [58]: left = pd.DataFrame({'key': [1], 'v1': [10]})

In [59]: left
Out[59]: 
   key  v1
0    1  10

In [60]: right = pd.DataFrame({'key': [1, 2], 'v1': [20, 30]})

In [61]: right
Out[61]: 
   key  v1
0    1  20
1    2  30

हम शामिल कुंजी को संरक्षित करने में सक्षम हैं:

In [62]: pd.merge(left, right, how='outer')
Out[62]: 
   key  v1
0    1  10
1    1  20
2    2  30

In [63]: pd.merge(left, right, how='outer').dtypes