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

वाक्य - विन्यास

• डेटा ढांचा। मर्ज ( दायाँ, कैसे = 'भीतरी', = = कोई नहीं, left_on = कोई नहीं, right_on = कोई नहीं, left_index = गलत, right_index = गलत, सॉर्ट = गलत, प्रत्यय = ('_ x', '_y'), copy = True सूचक = गलत )

• स्तंभ या अनुक्रमणिका द्वारा डेटाबेस-शैली में शामिल होने के लिए डेटाफ़्रेम वस्तुओं को मर्ज करें।

• यदि स्तंभों पर कॉलम में शामिल होते हैं, तो DataFrame इंडेक्स को अनदेखा किया जाएगा। अन्यथा यदि किसी स्तंभ या स्तंभ पर अनुक्रमणिका या अनुक्रमित पर अनुक्रमणिका में शामिल होने पर, सूचकांक को पारित किया जाएगा।

पैरामीटर

मर्ज

उदाहरण के लिए, दो टेबल दिए गए हैं,

टी 1

id    x        y
8    42        1.9
9    30        1.9

टी 2

id    signal
8    55
8    56    
8    59
9    57
9    58    
9    60

लक्ष्य नई तालिका T3 प्राप्त करना है:

id    x        y        s1        s2        s3
8    42        1.9        55        56        58
9    30        1.9        57        58        60

जो कॉलम s1 , s2 और s3 , प्रत्येक पंक्ति के अनुरूप ( id प्रति पंक्तियों की संख्या हमेशा तय होती है और 3 के बराबर होती है)

join करने से (जो तर्क पर एक वैकल्पिक लेता है जो एक कॉलम या कई कॉलम नाम हो सकता है, जो निर्दिष्ट करता है कि पारित डेटाफ़्रेम को डेटा कॉलम में उस कॉलम पर संरेखित किया जाना है)। तो समाधान नीचे दिखाया जा सकता है:

df = df1.merge (df2.groupby ('id') ['सिग्नल']] लागू करें (लैम्ब्डा x: x.reset_index (ड्रॉप = ट्रू))।

df
Out[63]: 
   id   x    y   0   1   2
0   8  42  1.9  55  56  59
1   9  30  1.9  57  58  60

अगर मैं उन्हें अलग करता हूं:

df2t = df2.groupby('id')['signal'].apply(lambda x: x.reset_index(drop=True)).unstack().reset_index()

df2t
Out[59]: 
   id   0   1   2
0   8  55  56  59
1   9  57  58  60

df = df1.merge(df2t)

df
Out[61]: 
   id   x    y   0   1   2
0   8  42  1.9  55  56  59
1   9  30  1.9  57  58  60

दो डेटाफ़्रेम को मर्ज करना

In [1]: df1 = pd.DataFrame({'x': [1, 2, 3], 'y': ['a', 'b', 'c']})

In [2]: df2 = pd.DataFrame({'y': ['b', 'c', 'd'], 'z': [4, 5, 6]})

In [3]: df1
Out[3]: 
   x  y
0  1  a
1  2  b
2  3  c   

In [4]: df2
Out[4]: 
   y  z
0  b  4
1  c  5
2  d  6

आंतरिक रूप से जुड़ा:

दो डेटाफ़्रेम से कुंजियों के प्रतिच्छेदन का उपयोग करता है।

In [5]: df1.merge(df2) # by default, it does an inner join on the common column(s)
Out[5]: 
   x  y  z
0  2  b  4
1  3  c  5

वैकल्पिक रूप से दो डेटाफ़्रेम से कुंजियों का प्रतिच्छेदन निर्दिष्ट करें।

In [5]: merged_inner = pd.merge(left=df1, right=df2, left_on='y', right_on='y')
Out[5]: 
   x  y  z
0  2  b  4
1  3  c  5

बाहरी जुड़ाव:

दो डेटाफ़्रेम से कुंजियों के मिलन का उपयोग करता है।

In [6]: df1.merge(df2, how='outer')
Out[6]: 
     x  y    z
0  1.0  a  NaN
1  2.0  b  4.0
2  3.0  c  5.0
3  NaN  d  6.0

बाँया जोड़:

बाएं डेटाफ़्रेम से केवल कुंजियों का उपयोग करता है।

In [7]: df1.merge(df2, how='left')
Out[7]: 
   x  y    z
0  1  a  NaN
1  2  b  4.0
2  3  c  5.0

राइट जॉइन करें

सही DataFrame से केवल कुंजियों का उपयोग करता है।

In [8]: df1.merge(df2, how='right')
Out[8]: 
     x  y  z
0  2.0  b  4
1  3.0  c  5
2  NaN  d  6

कई डेटा फ़्रेमों (क्षैतिज और लंबवत) को मिलाना / जोड़ना / जोड़ना

नमूना डेटा फ़्रेम उत्पन्न करें:

In [57]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})

In [58]: df1 = pd.DataFrame({'col1':[11,12,13], 'col2': [21,22,23]})

In [59]: df2 = pd.DataFrame({'col1':[111,112,113], 'col2': [121,122,123]})

In [60]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})

In [61]: df1
Out[61]:
   col1  col2
0    11    21
1    12    22
2    13    23

In [62]: df2
Out[62]:
   col1  col2
0   111   121
1   112   122
2   113   123

In [63]: df3
Out[63]:
   col1  col2
0   211   221
1   212   222
2   213   223

मर्ज / ज्वाइन / कॉन्टेक्ट डेटा फ्रेम [df1, df2, df3] लंबवत - पंक्तियाँ जोड़ें

In [64]: pd.concat([df1,df2,df3], ignore_index=True)
Out[64]:
   col1  col2
0    11    21
1    12    22
2    13    23
3   111   121
4   112   122
5   113   123
6   211   221
7   212   222
8   213   223

क्षैतिज रूप से (अनुक्रमणिका द्वारा संरेखित) डेटा मर्ज / सम्मिलित / सम्मिलित करें:

In [65]: pd.concat([df1,df2,df3], axis=1)
Out[65]:
   col1  col2  col1  col2  col1  col2
0    11    21   111   121   211   221
1    12    22   112   122   212   222
2    13    23   113   123   213   223

मर्ज, जॉइन और कॉनैट

मर्जिंग कुंजी नाम समान हैं

pd.merge(df1, df2, on='key')

मुख्य नाम जोड़ना अलग हैं

pd.merge(df1, df2, left_on='l_key', right_on='r_key')

विभिन्न प्रकार के जुड़ने वाले

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

एकाधिक कुंजियों में विलय

pd.merge(df1, df2, on=['key1', 'key2'])

ओवरलैपिंग कॉलम का उपचार

pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))

विलय कुंजी के बजाय पंक्ति सूचकांक का उपयोग करना

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

.join कॉलम के अपवाद के रूप में .join सिंटैक्स के उपयोग से बचें

बाएं डेटाफ्रेम इंडेक्स और राइट डेटाफ्रेम कॉलम पर विलय

pd.merge(df1, df2, right_index=True, left_on='l_key')

डेटाफ्रेम से संबंधित

लंबवत रूप से चिपके हुए

pd.concat([df1, df2, df3], axis=0)

क्षैतिज रूप से सरेस से जोड़ा हुआ

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

ज्वाइन और मर्ज में क्या अंतर है

डेटाफ़्रेम को left और right पर विचार करें

left = pd.DataFrame([['a', 1], ['b', 2]], list('XY'), list('AB'))
left

   A  B
X  a  1
Y  b  2

right = pd.DataFrame([['a', 3], ['b', 4]], list('XY'), list('AC'))
right

   A  C
X  a  3
Y  b  4

join
के बारे में सोचो join अपने-अपने अनुक्रमित के आधार पर dataframes गठबंधन के लिए इच्छुक है। अगर कोई कॉलम ओवरलैपिंग कर रहे हैं, join आप बाईं dataframe से अतिव्यापी स्तंभ नाम के एक प्रत्यय जोड़ना चाहते हैं। हमारे दो डेटाफ्रेम में ओवरलैपिंग कॉलम नाम A ।

left.join(right, lsuffix='_')

  A_  B  A  C
X  a  1  a  3
Y  b  2  b  4

ध्यान दें कि सूचकांक संरक्षित है और हमारे पास 4 कॉलम हैं। 2 कॉलम left और 2 right ।

यदि अनुक्रमणिका संरेखित नहीं हुई

left.join(right.reset_index(), lsuffix='_', how='outer')

    A_    B index    A    C
0  NaN  NaN     X    a  3.0
1  NaN  NaN     Y    b  4.0
X    a  1.0   NaN  NaN  NaN
Y    b  2.0   NaN  NaN  NaN

मैंने बिंदु को बेहतर ढंग से चित्रित करने के लिए एक बाहरी जोड़ का उपयोग किया। यदि इंडेक्स संरेखित नहीं करते हैं, तो परिणाम इंडेक्स का संघ होगा।

हम जुड़ाव कुंजी के रूप में उपयोग करने के लिए बाएं डेटाफ़्रेम में एक विशिष्ट कॉलम का उपयोग करने के लिए join को कह सकते हैं, लेकिन यह अभी भी दाईं ओर से सूचकांक का उपयोग करेगा।

left.reset_index().join(right, on='index', lsuffix='_')

  index A_  B  A  C
0     X  a  1  a  3
1     Y  b  2  b  4

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

merge एक संयुक्त डेटाफ़्रेम लौटाएगा जिसमें सूचकांक नष्ट हो जाएगा।

यह सरल उदाहरण ओवरलैपिंग कॉलम को 'A' मानता है और इसके आधार पर संयोजन करता है।

left.merge(right)

   A  B  C
0  a  1  3
1  b  2  4

ध्यान दें कि सूचकांक [0, 1] और अब ['X', 'Y']

आप स्पष्ट रूप से निर्दिष्ट कर सकते हैं कि आप अनुक्रमणिका को left_index या right_index left_index साथ मर्ज कर रहे हैं

left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])

  A_  B  A  C
X  a  1  a  3
Y  b  2  b  4

और यह बिल्कुल ऊपर दिए गए join उदाहरण की तरह दिखता है।