Pandas & NumPy Academy · पाठ

Series पर वेक्टराइज़्ड ऑपरेशन

Q: क्या “Series पर वेक्टराइज़्ड ऑपरेशन” पाठ निःशुल्क है?

हाँ—“Series पर वेक्टराइज़्ड ऑपरेशन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Q: क्या Pandas & NumPy Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Pandas & NumPy Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

Q: “Series पर वेक्टराइज़्ड ऑपरेशन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

Q: क्या मैं इस Pandas & NumPy Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Pandas & NumPy Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

दो Series के बीच अंकगणित कीजिए, index alignment को स्वतः संभालिए और संरेखित लुप्त मानों को NaN से भरिए।

पाठ 3, कुल 4 में से13 चरण

Series पर वेक्टराइज़्ड ऑपरेशन, CoddyKit पर Pandas & NumPy Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Pandas & NumPy Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

वेक्टराइज़्ड ऑपरेशनों की आवश्यकता क्यों है

NumPy की तरह, Pandas Series भी वेक्टराइज़्ड ऑपरेशनों का समर्थन करती हैं, जो Python लूप के बिना हर तत्व पर अंकगणित, तुलना और फ़ंक्शन लागू करते हैं। इससे कोड संक्षिप्त और तेज़ दोनों बनता है। पर्दे के पीछे, हर ऑपरेशन NumPy की C-स्तरीय रूटीन को सौंप दिया जाता है, लेकिन Pandas एक महत्वपूर्ण अतिरिक्त सुविधा देता है: ऑपरेशन करने से पहले स्वचालित इंडेक्स संरेखण।

import pandas as pd

revenue = pd.Series([1000, 2000, 1500], index=['Jan', 'Feb', 'Mar'])
tax_rate = 0.2
net = revenue * (1 - tax_rate)   # vectorized -- no loop
print(net)

दो Series के बीच अंकगणित

जब आप दो Series को जोड़ते, घटाते, गुणा या विभाजित करते हैं, तो Pandas पहले उन्हें इंडेक्स लेबल के आधार पर संरेखित करता है। केवल उन स्थानों पर परिणाम मिलता है जहाँ दोनों Series में लेबल मौजूद हो; बिना मिलान वाले लेबलों पर NaN मिलता है। यह व्यवहार गलत-संरेखित डेटा से होने वाली छिपी त्रुटियों को रोकता है — उदाहरण के लिए, अलग-अलग क्रम में संग्रहीत दो डेटा स्रोतों से जनवरी के आँकड़े जोड़ते समय।

import pandas as pd

a = pd.Series([10, 20, 30], index=['x', 'y', 'z'])
b = pd.Series([1, 2, 3], index=['y', 'z', 'w'])

print(a + b)
# w     NaN
# x     NaN
# y    21.0
# z    32.0

संरेखित ऑपरेशनों में NaN भरना

गलत-संरेखित ऑपरेशनों में NaN के फैलाव से बचने के लिए fill_value= पैरामीटर के साथ .add(), .sub(), .mul() और .div() जैसी अंकगणितीय विधियों का उपयोग करें। ऑपरेशन करने से पहले यह किसी एक Series में अनुपस्थित लेबल के स्थान पर दिया गया मान रखता है — जोड़ के लिए सामान्यतः 0 और गुणा के लिए 1।

import pandas as pd

a = pd.Series([10, 20, 30], index=['x', 'y', 'z'])
b = pd.Series([1, 2, 3], index=['y', 'z', 'w'])

result = a.add(b, fill_value=0)
print(result)
# w     3.0
# x    10.0
# y    21.0
# z    32.0

Series पर scalar अंकगणित

किसी scalar के साथ अंकगणितीय ऑपरेशन हर तत्व पर लागू होता है और उसी इंडेक्स वाली नई Series बनाता है। यह वेक्टराइज़ेशन का सबसे सरल रूप है: s + 5, s * 100, s ** 2। Scalar अंकगणित कभी NaN उत्पन्न नहीं करता और इसका उपयोग इकाई रूपांतरण, सामान्यीकरण तथा समय-श्रृंखला में ऑफ़सेट जोड़ने के लिए किया जाता है।

import pandas as pd

prices_eur = pd.Series([1.0, 2.5, 4.0], index=['a', 'b', 'c'])
exchange = 1.08
prices_usd = prices_eur * exchange
print(prices_usd.round(2))
# a    1.08
# b    2.70
# c    4.32

Series पर NumPy ufuncs लागू करना

NumPy ufuncs Pandas Series पर सहज रूप से काम करते हैं और उसी इंडेक्स वाली Series लौटाते हैं। इसका अर्थ है कि आप पहले उसे array में बदले बिना सीधे Series पर np.sqrt(s), np.log1p(s) या np.exp(s) कॉल कर सकते हैं। परिणाम एक नई Series होती है, जिसमें मूल लेबल सुरक्षित रहते हैं।

import pandas as pd
import numpy as np

s = pd.Series([0, 1, 4, 9, 16], index=list('abcde'))
print(np.sqrt(s))
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# e    4.0

Series पर तुलना ऑपरेशन

तुलना ऑपरेटर (==, !=, >, <, >=, <=) प्रत्येक तत्व के लिए बूलियन Series लौटाते हैं। फ़िल्टर करने के लिए यही आधार होते हैं: मिलती हुई पंक्तियाँ चुनने के लिए बूलियन Series को .loc में दें। दो Series की तुलना करते समय Pandas इंडेक्स के आधार पर संरेखण भी करता है।

import pandas as pd

s = pd.Series([3, 7, 2, 9, 1], index=list('abcde'))
print(s > 4)
# a    False
# b     True
# c    False
# d     True
# e    False
print(s[s > 4])  # b:7  d:9

वेक्टराइज़्ड ऑपरेशनों की श्रृंखला बनाना

क्योंकि हर ऑपरेशन एक नई Series लौटाता है, आप एक ही expression में कई रूपांतरणों की श्रृंखला बना सकते हैं। यह पढ़ने में आसान होता है और अनावश्यक मध्यवर्ती चर बनाने से बचाता है। जटिल पाइपलाइन के लिए कोष्ठकों का उपयोग करके श्रृंखला को कई पंक्तियों में बाँटें। श्रृंखला बनाना अपरिवर्तनीय डेटा के साथ functional programming के Pandas समकक्ष है।

import pandas as pd
import numpy as np

raw_scores = pd.Series([55, 80, 45, 90, 72])
normalised = (raw_scores - raw_scores.min()) / (raw_scores.max() - raw_scores.min())
print(normalised.round(2))
# 0    0.22
# 1    0.78
# 2    0.00
# 3    1.00
# 4    0.60

वेक्टराइज़्ड ऑपरेशनों में NaN संभालना

NaN संक्रामक होता है: NaN से जुड़ी किसी भी अंकगणितीय गणना का परिणाम NaN होता है। ऑपरेशन से पहले मान बदलने के लिए s.fillna(value) का उपयोग करें, या aggregation विधियों में skipna=True पैरामीटर दें। pd.isna(s) फ़ंक्शन NaN वाली स्थितियों को चिह्नित करने वाली बूलियन Series लौटाता है — आँकड़े निकालने से पहले डेटा की जाँच के लिए इसका उपयोग करें।

import pandas as pd
import numpy as np

s = pd.Series([1.0, np.nan, 3.0, np.nan, 5.0])
print(s + 10)
# 0    11.0  2    13.0  4    15.0 -- NaN stays NaN

print(s.fillna(0) + 10)
# 0    11.0  1    10.0  2    13.0  3    10.0  4    15.0

Series पर abs(), clip() और round()

Pandas Series कई NumPy-जैसी विधियाँ सीधे उपलब्ध कराती हैं: s.abs(), s.clip(lower, upper) और s.round(decimals) सभी तत्व-दर-तत्व रूपांतरण लागू करके नई Series लौटाती हैं। ये NumPy ufunc कॉल के समतुल्य हैं, लेकिन method syntax का उपयोग करती हैं और Series का इंडेक्स तथा नाम सुरक्षित रखती हैं।

import pandas as pd

s = pd.Series([-2.5, 1.3, -0.7, 4.9, -3.1])
print(s.abs())          # [2.5 1.3 0.7 4.9 3.1]
print(s.clip(-2, 2))    # [-2.  1.3 -0.7  2. -2. ]
print(s.round(0))       # [-2.  1.  -1.   5.  -3.]

वृद्धि दरों के लिए pct_change()

s.pct_change() लगातार तत्वों के बीच प्रतिशत परिवर्तन निकालता है: (वर्तमान - पिछला) / पिछला। पहला तत्व NaN होता है, क्योंकि उसका कोई पिछला मान नहीं होता। महीने-दर-महीने वृद्धि दर, वित्तीय दैनिक रिटर्न और समय-श्रृंखला मॉडल के लिए परिवर्तन-दर वाली विशेषताएँ निकालने का यह मानक ऑपरेशन है।

import pandas as pd

monthly_revenue = pd.Series([100, 120, 110, 140],
                            index=['Q1', 'Q2', 'Q3', 'Q4'])
growth = monthly_revenue.pct_change()
print(growth.round(3))
# Q1      NaN
# Q2    0.200
# Q3   -0.083
# Q4    0.273

Series पर cumsum() और cumprod()

s.cumsum() चलते हुए योगों की Series लौटाता है और s.cumprod() चलते हुए गुणनों की Series लौटाता है। इनका उपयोग संचयी राजस्व, चक्रवृद्धि निवेश रिटर्न या चलते हुए शब्द-गणना निकालने के लिए किया जाता है। ये मूल इंडेक्स लेबल सुरक्षित रखते हैं, जिससे समय या श्रेणी के अनुसार संचयी Series का आलेख बनाना आसान होता है।

import pandas as pd

daily_sales = pd.Series([100, 150, 80, 200],
                        index=['Mon', 'Tue', 'Wed', 'Thu'])
print(daily_sales.cumsum())
# Mon    100
# Tue    250
# Wed    330
# Thu    530

त्वरित जाँच

इस पाठ से Series पर वेक्टराइज़्ड ऑपरेशनों के बारे में अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: अंकगणितीय ऑपरेटर बिना लूप के Series पर प्रत्येक तत्व के लिए लागू होते हैं, Pandas ऑपरेशन से पहले दो Series को इंडेक्स लेबल के आधार पर स्वचालित रूप से संरेखित करता है और बिना मिलान वाली स्थितियों पर NaN रखता है, तथा fill_value, pct_change और cumsum जैसी विधियाँ विश्लेषणात्मक कार्यों के लिए वेक्टराइज़्ड ऑपरेशनों का विस्तार करती हैं। आगे हम त्वरित सारांश के लिए describe, value_counts और map जैसी उपयोगी Series विधियाँ देखेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Series पर वेक्टराइज़्ड ऑपरेशन” पाठ निःशुल्क है?

हाँ—“Series पर वेक्टराइज़्ड ऑपरेशन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।