पंडों में मर्ज () और कंकट () के बीच अंतर

Question 1

के बीच आवश्यक अंतर (रों) क्या है pd.DataFrame.merge()और pd.concat()?

अब तक, यह वही है जो मैंने पाया है, कृपया मेरी समझ कितनी पूर्ण और सटीक है, इस पर टिप्पणी करें:

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

(पंडों डेटा विश्लेषण में उपयोग के मामलों की एक बहुत व्यापक स्पेक्ट्रम को संबोधित करने में महान है। यह एक विशेष काम करने के लिए सबसे अच्छा तरीका क्या है यह पता लगाने के लिए प्रलेखन की खोज करना थोड़ा कठिन हो सकता है।)

Question 2

एक बहुत ही उच्च स्तर का अंतर यह है कि merge()दो (या अधिक) डेटाफ्रेम को आम कॉलम के मानों के आधार पर संयोजित करने के लिए उपयोग किया जाता है (सूचक भी इस्तेमाल किया जा सकता है, उपयोग left_index=Trueऔर / या right_index=True), और concat()एक (या अधिक) डेटाफ्रेम एक को जोड़ने के लिए उपयोग किया जाता है अन्य के नीचे (या बग़ल में, यह निर्भर करता है कि axisविकल्प 0 या 1 पर सेट है)।

join()सूचकांक के आधार पर 2 डेटाफ्रेम को मर्ज करने के लिए उपयोग किया जाता है; merge()विकल्प के साथ उपयोग करने के बजाय left_index=Trueहम उपयोग कर सकते हैं join()।

उदाहरण के लिए:

df1 = pd.DataFrame({'Key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})

df1:
   Key  data1
0   b   0
1   b   1
2   a   2
3   c   3
4   a   4
5   a   5
6   b   6

df2 = pd.DataFrame({'Key': ['a', 'b', 'd'], 'data2': range(3)})

df2:
    Key data2
0   a   0
1   b   1
2   d   2

#Merge
# The 2 dataframes are merged on the basis of values in column "Key" as it is 
# a common column in 2 dataframes

pd.merge(df1, df2)

   Key data1 data2
0   b    0    1
1   b    1    1
2   b    6    1
3   a    2    0
4   a    4    0
5   a    5    0

#Concat
# df2 dataframe is appended at the bottom of df1 

pd.concat([df1, df2])

   Key data1 data2
0   b   0     NaN
1   b   1     NaN
2   a   2     NaN
3   c   3     NaN
4   a   4     NaN
5   a   5     NaN
6   b   6     NaN
0   a   Nan   0
1   b   Nan   1
2   d   Nan   2

Question 3

pd.concatIterableअपने तर्क के रूप में लेता है। इसलिए, यह DataFrameसीधे अपने तर्क के रूप में नहीं ले सकता है। इसके अलावा Dimensionके एस DataFrameधुरी के साथ मेल खाना चाहिए, जबकि श्रृंखलाबद्ध।

pd.mergeDataFrameअपने तर्क के रूप में ले सकता है, और दो DataFrameएस को एक ही कॉलम या इंडेक्स के साथ संयोजित करने के लिए उपयोग किया जाता है , जो इसके साथ नहीं किया जा सकता है pd.concatक्योंकि यह DataFrame में दोहराया कॉलम दिखाएगा।

जबकि जुड़ने का उपयोग DataFrameविभिन्न सूचकांकों के साथ दो एस में शामिल होने के लिए किया जा सकता है ।

Question 4

मैं वर्तमान में pd.DataFrame.merge()और के बीच आवश्यक अंतर को समझने की कोशिश कर रहा हूं pd.concat()।

अच्छा प्रश्न। मुख्य अंतर:

`pd.concat` दोनों कुल्हाड़ियों पर काम करता है।

अन्य अंतर है, है pd.concatहै भीतरी ^{^{डिफ़ॉल्ट}} और बाहरी केवल मिलती है, जबकि pd.DataFrame.merge()गया है छोड़ दिया , सही , बाहरी , भीतरी ^{^{डिफ़ॉल्ट}} मिलती है।

तीसरा उल्लेखनीय अन्य अंतर है: pd.DataFrame.merge()कॉलम प्रत्यय को उसी नाम के साथ विलय करते समय सेट करने का विकल्प होता है, जबकि इसके लिए pd.concatयह संभव नहीं है।

साथ pd.concatडिफ़ॉल्ट रूप से आप एक से अधिक dataframes (की पंक्तियों ढेर करने में सक्षम हैं axis=0) और जब आप सेट axis=1तो आप की नकल pd.DataFrame.merge()समारोह।

के कुछ उपयोगी उदाहरण pd.concat:

df2=pd.concat([df]*2, ignore_index=True) #double the rows of a dataframe

df2=pd.concat([df, df.iloc[[0]]]) # add first row to the end

df3=pd.concat([df1,df2], join='inner', ignore_index=True) # concat two df's

Question 5

उच्च स्तर पर:

.concat()बस DataFrameअनुक्रमणिका पर संरेखित करने के बाद क्षैतिज या लंबवत रूप से एक साथ कई ढेर करता है
.merge()पहले दो DataFrame'चयनित आम कॉलम (ओं) या इंडेक्स को संरेखित करता है , और फिर प्रत्येक की संरेखित पंक्तियों से शेष कॉलम उठाता है DataFrame।

अधिक विशेष रूप से .concat():

एक शीर्ष-स्तरीय पांडा समारोह है
दो या अधिक पंडों को DataFrame लंबवत या क्षैतिज रूप से जोड़ता है
क्षैतिज रूप से संयोजन करते समय केवल सूचकांक पर संरेखित करता है
कोई भी DataFrameडुप्लिकेट इंडेक्स होने पर त्रुटियां ।
आंतरिक जुड़ने के विकल्प के साथ बाहरी जुड़ाव में कमी

और .merge():

दोनों एक शीर्ष-स्तरीय पांडा फ़ंक्शन और एक DataFrameविधि (पांडा 1.0 के अनुसार) के रूप में मौजूद हैं
ठीक दो DataFrameक्षैतिज रूप से जोड़ती है
बुला संरेखित करता है DataFrameके स्तंभ (एस) या सूचकांक दूसरे के साथ DataFrameके स्तंभ (एस) या सूचकांक
एक कार्टेशियन उत्पाद का प्रदर्शन करके शामिल होने वाले कॉलम या इंडेक्स पर डुप्लिकेट मानों को संभालता है
आंतरिक रूप से चूक बाईं, बाहरी और दाईं ओर के विकल्पों के साथ जुड़ती हैं

ध्यान दें कि प्रदर्शन करते समय pd.merge(left, right), यदि leftदो पंक्तियों में शामिल होने वाले कॉलम या इंडेक्स से समान मान होते हैं, तो प्रत्येक पंक्ति एक rightसंबंधित पंक्ति (s) के साथ संयोजित होगी जिसके परिणामस्वरूप कार्टेशियन उत्पाद होता है। दूसरी ओर, यदि .concat()स्तंभों को संयोजित करने के लिए उपयोग किया जाता है , तो हमें यह सुनिश्चित करने की आवश्यकता है कि कोई भी डुप्लिकेट इंडेक्स मौजूद न हो DataFrame।

व्यावहारिक रूप से बोल रहा हूँ:

पर विचार करें .concat()पहले जब सजातीय के संयोजन DataFrameहै, जबकि पर विचार .merge()पहले जब पूरक के संयोजन DataFrame।
यदि लंबवत विलय करने की आवश्यकता है, तो साथ जाएं .concat()। यदि स्तंभों के माध्यम से क्षैतिज रूप से विलय करने की आवश्यकता है .merge(), तो सामान्य रूप से कॉलम पर डिफ़ॉल्ट मर्ज करके जाएं।

संदर्भ: पंडों 1.x कुकबुक

Question 6

मर्ज और कॉनसैट के बीच मुख्य अंतर यह है कि मर्ज आपको उन तालिकाओं के अधिक संरचित "जुड़ने" की अनुमति देता है जहां कॉनकैट का उपयोग अधिक व्यापक और कम संरचित होता है।

मर्ज

दस्तावेज़ीकरण का उल्लेख करते हुए , एक आवश्यक तर्क के रूप में सहीpd.DataFrame.merge लेता है, जिसे आप कुछ पूर्व-निर्धारित संरचित सम्मिलित ऑपरेशन के अनुसार बाईं तालिका और दाईं तालिका में शामिल होने के रूप में सोच सकते हैं। पैरामीटर सही के लिए परिभाषा नोट करें ।

आवश्यक पैरामीटर

सही : DataFrame या नामित श्रृंखला

वैकल्पिक पैरामीटर

कैसे : {'बाएँ', 'दाएँ', 'बाहरी', 'भीतरी'} डिफ़ॉल्ट 'आंतरिक'
on : लेबल या सूची
left_on : लेबल या सूची, या सरणी-जैसा
right_on : लेबल या सूची, या सरणी-जैसा
left_index : बूल, डिफ़ॉल्ट गलत
right_index : बूल, डिफ़ॉल्ट गलत
सॉर्ट : बूल, डिफ़ॉल्ट गलत
प्रत्यय : (str, str), डिफ़ॉल्ट ('_x', '_y') का tuple
कॉपी : बूल, डिफ़ॉल्ट सच
सूचक : बूल या str, डिफ़ॉल्ट गलत
मान्य : str, वैकल्पिक

महत्वपूर्ण: pd.DataFrame.merge एक pd.DataFrameया नामित pd.Seriesवस्तु होने के लिए अधिकार की आवश्यकता होती है ।

उत्पादन

रिटर्न : डेटाफ़्रेम

इसके अलावा, अगर हम पंडों पर मर्ज ऑपरेशन के लिए डॉकस्ट्रिंग की जांच करते हैं, तो नीचे दिया गया है:

एक डेटाबेस (एसक्यूएल) को दो डेटाफ्रेम या सीरीज ऑब्जेक्ट्स के बीच कीज या कीम इंडेक्स के रूप में कॉलम का उपयोग करके ऑपरेशन करें

concat

का संदर्भ लें प्रलेखन के pd.concatउस पैरामीटर के किसी भी नाम नहीं है, पहले ध्यान दें मेज, data_frame, श्रृंखला, मैट्रिक्स , आदि, लेकिन objs बजाय। यही है, आप कई "डेटा कंटेनर" पास कर सकते हैं, जिन्हें निम्न रूप में परिभाषित किया गया है:

Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]

आवश्यक पैरामीटर

objs : श्रृंखला या DataFrame वस्तुओं का एक अनुक्रम या मानचित्रण

वैकल्पिक पैरामीटर

अक्ष : {0 / 'इंडेक्स', 1 / 'कॉलम'}, डिफ़ॉल्ट 0
शामिल हों : {'भीतर', 'बाहरी'}, डिफ़ॉल्ट 'बाहरी'
ign_index : बूल, डिफ़ॉल्ट गलत
चाबियाँ : अनुक्रम, डिफ़ॉल्ट कोई नहीं
स्तर : अनुक्रमों की सूची, डिफ़ॉल्ट कोई नहीं
नाम : सूची, डिफ़ॉल्ट कोई नहीं
Ver_integrity : बूल, डिफ़ॉल्ट गलत
सॉर्ट : बूल, डिफ़ॉल्ट गलत
कॉपी : बूल, डिफ़ॉल्ट सच

उत्पादन

रिटर्न : ऑब्जेक्ट, ओब्ज का प्रकार

उदाहरण

कोड

import pandas as pd

v1 = pd.Series([1, 5, 9, 13])
v2 = pd.Series([10, 100, 1000, 10000])
v3 = pd.Series([0, 1, 2, 3])

df_left = pd.DataFrame({
    "v1": v1,
    "v2": v2,
    "v3": v3
    })
df_right = pd.DataFrame({
    "v4": [5, 5, 5, 5],
    "v5": [3, 2, 1, 0]
    })


df_concat = pd.concat([v1, v2, v3])

# Performing operations on default

merge_result = df_left.merge(df_right, left_index=True, right_index=True)
concat_result = pd.concat([df_left, df_right], sort=False)
print(merge_result)
print('='*20)
print(concat_result)

कोड आउटपुट

   v1     v2  v3  v4  v5
0   1     10   0   5   3
1   5    100   1   5   2
2   9   1000   2   5   1
3  13  10000   3   5   0
====================
     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0

हालांकि, अक्ष पैरामीटर को बदलकर आप कॉनटैट के साथ पहला आउटपुट (मर्ज) प्राप्त कर सकते हैं

concat_result = pd.concat([df_left, df_right], sort=False, axis=1)

निम्नलिखित व्यवहार का निरीक्षण करें,

concat_result = pd.concat([df_left, df_right, df_left, df_right], sort=False)

आउटपुट,

     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0

, जो आप मर्ज के साथ एक समान ऑपरेशन नहीं कर सकते, क्योंकि यह केवल एक ही DataFrame या नामित श्रृंखला की अनुमति देता है।

merge_result = df_left.merge([df_right, df_left, df_right], left_index=True, right_index=True)

आउटपुट,

TypeError: Can only merge Series or DataFrame objects, a <class 'list'> was passed

निष्कर्ष

जैसा कि आपके पास पहले से ही नोटिस हो सकता है कि इनपुट और आउटपुट "मर्ज" और "कॉनकट" के बीच भिन्न हो सकते हैं।

जैसा कि मैंने शुरुआत में उल्लेख किया है, बहुत पहले (मुख्य) अंतर यह है कि "मर्ज" वस्तुओं और मापदंडों के प्रतिबंधित सेट के साथ एक अधिक संरचित कार्य करता है, जहां "कॉन्कैट" एक कम सख्त / व्यापक प्रदर्शन के साथ एक व्यापक सेट के साथ जुड़ता है। वस्तुओं और मापदंडों की।

सभी में, मर्ज में परिवर्तन / (इनपुट) के लिए कम सहिष्णु है और "अवतरण" परिवर्तनों / (इनपुट) के प्रति कम संवेदनशील है। आप "कॉनकट" का उपयोग करके "मर्ज" प्राप्त कर सकते हैं, लेकिन रिवर्स हमेशा सच नहीं होता है।

"मर्ज" ऑपरेशन डेटा फ़्रेम कॉलम (या pd.Seriesऑब्जेक्ट का नाम ) या पंक्ति सूचकांकों का उपयोग करता है, और चूंकि यह उन संस्थाओं का उपयोग करता है जो केवल डेटा फ़्रेम या श्रृंखला के क्षैतिज मर्ज करते हैं, और परिणामस्वरूप ऊर्ध्वाधर ऑपरेशन लागू नहीं करते हैं।

यदि आप अधिक देखना चाहते हैं, तो आप स्रोत कोड में थोड़ा गोता लगा सकते हैं;

अवतल के लिए स्रोत कोड
मर्ज के लिए स्रोत कोड

Question 7

डिफ़ॉल्ट रूप से:
ज्वाइन एक कॉलम-वार लेफ्ट जॉइन
pd.merge है एक कॉलम-वार इनर जॉइन
pd.concat एक पंक्ति-वार बाहरी जॉइन है

pd.concat:
Iterable तर्कों को लेता है। इस प्रकार, यह डेटाफ़्रेम को सीधे नहीं ले सकता (उपयोग [df, df2])
डेटाफ़्रेम के आयाम अक्ष के साथ मेल खाना चाहिए

Join and pd.merge:
DataFrame आर्ग्युमेंट ले सकते हैं

नीचे दिए गए कोड को समझने के लिए चित्र पर क्लिक करें

df1.join(df2)
pd.merge(df1, df2, left_index=True, right_index=True)
pd.concat([df1, df2], axis=1)

पंडों में मर्ज () और कंकट () के बीच अंतर

pd.concat दोनों कुल्हाड़ियों पर काम करता है।

`pd.concat` दोनों कुल्हाड़ियों पर काम करता है।