लेफ़्ट और राइट जॉइन
एक तालिका की सभी पंक्तियाँ सुरक्षित रखते हुए दूसरी तालिका के रिकॉर्ड मिलाने के लिए left और right joins करें।
लेफ़्ट और राइट जॉइन, CoddyKit पर Pandas & NumPy Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Pandas & NumPy Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
असममित Joins
Inner और outer joins दोनों DataFrames के साथ समान व्यवहार करते हैं। लेकिन अक्सर आप एक तालिका के सभी रिकॉर्ड सुरक्षित रखते हुए उनमें दूसरी तालिका का डेटा जोड़ना चाहते हैं। यहीं left joins और right joins उपयोगी होते हैं। विश्लेषण में ये असममित joins बहुत सामान्य हैं: सभी लेन-देन रखें और जहाँ उपलब्ध हो वहाँ उत्पाद के नाम जोड़ें; सभी उपयोगकर्ता रखें और जिनकी खरीदारी हुई हो उनके लिए अंतिम खरीदारी की तारीख जोड़ें।
Left Join: बाईं सभी पंक्तियाँ सुरक्षित रखें
left join (how='left') बाएँ DataFrame की हर पंक्ति रखता है। जिन पंक्तियों की कुंजी दाएँ DataFrame में मिलती है, उनके दाएँ कॉलमों में मिले हुए मान भर दिए जाते हैं। जिन पंक्तियों का कोई मिलान नहीं होता, उनके दाएँ कॉलमों में NaN भर दिया जाता है। परिणाम में पंक्तियों की संख्या हमेशा बाएँ DataFrame की पंक्तियों की संख्या के बराबर होती है (यदि कुंजियाँ डुप्लिकेट न हों)।
import pandas as pd
orders = pd.DataFrame({
'order_id': [1, 2, 3, 4],
'customer_id': [101, 102, 101, 999],
'amount': [250, 80, 320, 150]
})
customers = pd.DataFrame({
'customer_id': [101, 102, 103],
'name': ['Alice', 'Bob', 'Carol']
})
result = pd.merge(orders, customers, on='customer_id', how='left')
print(result)
# All 4 orders kept; order with customer_id=999 gets NaN for nameLeft Join के परिणाम की संरचना
Left join के बाद, बाएँ DataFrame की जिन पंक्तियों का दाएँ DataFrame में कोई मिलान नहीं मिला, उनके दाएँ तालिका से आए प्रत्येक कॉलम में NaN होगा। दाएँ तालिका के किसी कॉलम पर बूलियन फ़िल्टर लगाकर आप ऐसी बिना-मिलान वाली पंक्तियों की पहचान कर सकते हैं और यह गिन सकते हैं कि बाईं कितनी पंक्तियों का कोई मिलान नहीं मिला — यह डेटा की गुणवत्ता जाँचने का उपयोगी तरीका है।
result = pd.merge(orders, customers, on='customer_id', how='left')
print(result)
# order_id customer_id amount name
# 0 1 101 250 Alice
# 1 2 102 80 Bob
# 2 3 101 320 Alice
# 3 4 999 150 NaN <- no matching customer
# Count unmatched
unmatched = result['name'].isna().sum()
print(f'{unmatched} orders have no customer record')Left Join का उपयोग कब करें
Left joins तब उपयुक्त होते हैं जब आपका बायाँ DataFrame मुख्य तालिका हो और दाईं तालिका सहायक हो। सामान्य स्थितियाँ हैं: तथ्य तालिका में आयाम तालिका की जानकारी जोड़ना (orders + product names), वैकल्पिक मेटाडेटा जोड़ना (users + profile data), या lookup विफल होने पर भी सभी रिकॉर्ड के लिए मापदंड निकालना। अधिकांश विश्लेषणात्मक कोड में right joins की तुलना में left joins बहुत अधिक सामान्य हैं।
# Realistic pattern: enrich all products with optional category data
products = pd.DataFrame({'sku': ['A1', 'B2', 'C3'], 'price': [10, 20, 15]})
categories = pd.DataFrame({'sku': ['A1', 'C3'], 'category': ['Tools', 'Home']})
# Keep all products; add category where available
enriched = pd.merge(products, categories, on='sku', how='left')
print(enriched)
# sku price category
# 0 A1 10 Tools
# 1 B2 20 NaN
# 2 C3 15 HomeRight Join: दाईं सभी पंक्तियाँ सुरक्षित रखें
right join (how='right') left join का उलटा रूप है: यह दाएँ DataFrame की हर पंक्ति रखता है और जहाँ कोई मिलान नहीं मिलता, वहाँ बाएँ तालिका के कॉलमों में NaN भरता है। Right join कम सामान्य है, क्योंकि DataFrame arguments का क्रम बदलकर और left join का उपयोग करके हमेशा यही परिणाम प्राप्त किया जा सकता है, जो पाठकों के लिए अधिक स्पष्ट होता है।
# Right join: keep all customers, attach orders where they exist
result = pd.merge(orders, customers, on='customer_id', how='right')
print(result)
# All 3 customers appear; Carol (103) has NaN for order_id and amount
# Equivalent left join (swap arguments):
result2 = pd.merge(customers, orders, on='customer_id', how='left')
# Same data, just column order differsचारों Join प्रकारों की तुलना
चारों join प्रकारों में अंतर केवल इतना है कि बिना-मिलान वाले पक्ष की कौन-सी पंक्तियाँ सुरक्षित रखी जाती हैं। inner: केवल मिली हुई पंक्तियाँ। outer: दोनों पक्षों की सभी पंक्तियाँ। left: बाईं सभी पंक्तियाँ। right: दाईं सभी पंक्तियाँ। बिना-मिलान वाली प्रविष्टियों के लिए अनुपस्थित पक्ष के कॉलमों में NaN भर दिया जाता है। रिकॉर्ड को चुपचाप हटने या डुप्लिकेट होने से बचाने के लिए सही विकल्प चुनना अत्यंत महत्वपूर्ण है।
# Summary table
# how='inner' : rows in BOTH tables
# how='left' : ALL left rows + matched right
# how='right' : matched left + ALL right rows
# how='outer' : ALL left rows + ALL right rows
# Test each
for how in ['inner', 'left', 'right', 'outer']:
r = pd.merge(orders, customers, on='customer_id', how=how)
print(f'{how}: {len(r)} rows')Left Join के परिणामों में NaN भरना
Left join के बाद बिना-मिलान वाली पंक्तियों के दाएँ तालिका के कॉलमों में NaN होता है। अक्सर आप इन्हें उचित डिफ़ॉल्ट मानों से भरना चाहेंगे — उदाहरण के लिए, अनुपस्थित श्रेणी के लिए 'Unknown' या अनुपस्थित गिनती के लिए 0। परिणाम पर fillna() का उपयोग करें, या join के बाद होने वाली अंकगणितीय क्रियाओं में fill_value दें।
result = pd.merge(products, categories, on='sku', how='left')
result['category'] = result['category'].fillna('Uncategorised')
print(result)
# sku price category
# 0 A1 10 Tools
# 1 B2 20 Uncategorised
# 2 C3 15 HomeLeft Anti-Join: बिना मिलान वाली पंक्तियाँ
how द्वारा सीधे समर्थित न होने वाला एक उपयोगी तरीका anti-join है: केवल उन बाईं पंक्तियों को रखें जिनका दाईं तालिका में कोई मिलान नहीं है। इसे indicator=True के साथ left join करके, फिर _merge == 'left_only' के लिए फ़िल्टर करके लागू करें। यह अनाथ रिकॉर्ड, संदर्भ सूची में न होने वाली नई वस्तुएँ या लेज़र में न पाए जाने वाले लेन-देन ढूँढने के लिए बहुत उपयोगी है।
# Anti-join: orders with no matching customer record
result = pd.merge(orders, customers, on='customer_id',
how='left', indicator=True)
unmatched_orders = result[result['_merge'] == 'left_only'].drop(columns='_merge')
print(unmatched_orders)
# order_id customer_id amount name
# 3 4 999 150 NaNLeft Join से पंक्तियों की संख्या सुरक्षित रखना
जब दाएँ DataFrame में कुंजियाँ विशिष्ट हों, तो left join से बाईं तालिका की पंक्तियों की सटीक संख्या सुरक्षित रहने की गारंटी होती है। लेकिन यदि दाईं तालिका में डुप्लिकेट कुंजी मान हों, तो left join भी inner join की तरह पंक्तियों की संख्या बढ़ा देता है। जब आप one-to-many संबंध की अपेक्षा कर रहे हों, तो हमेशा जाँचें कि आउटपुट में पंक्तियों की संख्या बाईं तालिका की संख्या के बराबर है।
# Right table has duplicate keys -> row multiplication
orders_small = pd.DataFrame({'id': [1, 2], 'amount': [100, 200]})
multi_customer = pd.DataFrame({
'id': [1, 1], # duplicate!
'contact': ['Alice', 'Alice2']
})
result = pd.merge(orders_small, multi_customer, on='id', how='left')
print(len(result)) # 3 rows! order 1 appears twice
print(result)वास्तविक दुनिया का Left Join पैटर्न
यहाँ वास्तविक दुनिया का एक पूर्ण कार्यप्रवाह है: लेन-देन लॉग से शुरू करें, नाम प्राप्त करने के लिए उत्पाद कैटलॉग के साथ left join करें, फिर नाम प्राप्त करने के लिए ग्राहक तालिका के साथ left join करें। अनुपस्थित lookup को डिफ़ॉल्ट मानों से भरें। Left join की यह श्रृंखला प्रत्येक लेन-देन पंक्ति को सुरक्षित रखती है, भले ही संदर्भ तालिकाओं में उत्पाद या ग्राहक का रिकॉर्ड अनुपस्थित हो।
transactions = pd.DataFrame({
'txn_id': [1, 2, 3],
'cust_id': [10, 11, 99],
'prod_id': [20, 21, 20],
'total': [50, 30, 70]
})
custs = pd.DataFrame({'cust_id': [10, 11], 'cust_name': ['Alice', 'Bob']})
prods = pd.DataFrame({'prod_id': [20, 21], 'prod_name': ['Widget', 'Gadget']})
result = (
transactions
.merge(custs, on='cust_id', how='left')
.merge(prods, on='prod_id', how='left')
)
print(result)Left Join बनाम Inner Join का निर्णय
Left और inner join के बीच चुनाव व्यावसायिक तर्क का निर्णय है: क्या आपको बिना lookup मिलान वाले रिकॉर्ड रखने चाहिए या उन्हें चुपचाप हटा देना चाहिए? जब अनुपस्थित lookup स्वीकार्य हों और आप सभी मुख्य रिकॉर्ड रखना चाहते हों, तब left join का उपयोग करें। जब अनुपस्थित lookup का अर्थ हो कि रिकॉर्ड अमान्य है और उसे विश्लेषण से बाहर रखना चाहिए, तब inner join का उपयोग करें। आपने कौन-सा विकल्प और क्यों चुना, यह हमेशा दर्ज करें।
# Left join: keep all transactions (some may have no product name)
result_left = pd.merge(transactions, prods, on='prod_id', how='left')
print('Left join rows:', len(result_left)) # same as transactions
# Inner join: only transactions with known product
result_inner = pd.merge(transactions, prods, on='prod_id', how='inner')
print('Inner join rows:', len(result_inner)) # may be fewerत्वरित जाँच
इस पाठ में left और right joins की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: left join बाएँ DataFrame की सभी पंक्तियाँ सुरक्षित रखता है और बिना-मिलान वाली पंक्तियों के लिए दाएँ कॉलमों में NaN भरता है; right join इसका उलटा रूप है; indicator=True का उपयोग करने वाला anti-join pattern बिना दाएँ मिलान वाली बाईं पंक्तियों को ढूँढता है; और left तथा inner join के बीच चुनाव व्यावसायिक तर्क का निर्णय है। आगे हम कॉलम के बजाय इंडेक्स पर DataFrames को join करने का अध्ययन करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “लेफ़्ट और राइट जॉइन” पाठ निःशुल्क है?
हाँ—“लेफ़्ट और राइट जॉइन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“लेफ़्ट और राइट जॉइन” में मैं क्या सीखूँगा?
एक तालिका की सभी पंक्तियाँ सुरक्षित रखते हुए दूसरी तालिका के रिकॉर्ड मिलाने के लिए left और right joins करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Pandas & NumPy Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Pandas & NumPy Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Pandas & NumPy Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“लेफ़्ट और राइट जॉइन” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Pandas & NumPy Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Pandas & NumPy Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- DataFrames को स्टैक करने के लिए pd.concat
- pd.merge: इनर और आउटर जॉइन
- लेफ़्ट और राइट जॉइन
- इंडेक्स पर जॉइन करना