Pandas & NumPy Academy · पाठ

एक्सपैंडिंग विंडो

expanding().sum() से प्रत्येक बिंदु तक आरंभ से सभी पंक्तियों को शामिल करने वाले संचयी आँकड़े निकालें।

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

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

विस्तारित विंडो क्या है

एक विस्तारित विंडो Series की बिल्कुल शुरुआत से लेकर वर्तमान पंक्ति तक की सभी पंक्तियों को शामिल करती है — विंडो स्थिर रहने के बजाय हर नई पंक्ति के साथ बढ़ती जाती है। पंक्ति 0 पर इसमें केवल एक मान होता है; पंक्ति 5 पर छह मान होते हैं; और पंक्ति 100 पर 101 मान होते हैं। विस्तारित विंडो का उपयोग संचयी आँकड़े निकालने के लिए किया जाता है, जो डेटासेट की शुरुआत से वर्तमान समय तक का चलता हुआ कुल, चलता हुआ औसत या चलता हुआ अधिकतम दर्शाते हैं।

import pandas as pd
import numpy as np

sales = pd.Series(
    [100, 150, 120, 200, 180, 160, 220, 190],
    index=pd.date_range('2024-01-01', periods=8)
)

# Expanding mean — grows with each row
df = pd.DataFrame({'sales': sales})
df['cumulative_mean'] = df['sales'].expanding().mean()
print(df)

expanding() मेथड

Series.expanding(min_periods=1) एक Expanding ऑब्जेक्ट लौटाता है। min_periods पैरामीटर (डिफ़ॉल्ट 1) पहला गैर-NaN परिणाम निकालने के लिए आवश्यक अवलोकनों की न्यूनतम संख्या निर्धारित करता है। rolling(n) के विपरीत, expanding() में विंडो स्थिर नहीं होती — यह हमेशा शुरुआत से शुरू होती है। कोई भी एग्रीगेशन जोड़ें: .sum(), .mean(), .std(), .min(), .max()।

import pandas as pd
import numpy as np

np.random.seed(42)
monthly_revenue = pd.Series(
    np.random.randint(500, 1500, 12),
    index=pd.date_range('2024-01', periods=12, freq='ME'),
    name='revenue'
)

df = pd.DataFrame({'revenue': monthly_revenue})
df['cumsum'] = df['revenue'].expanding().sum()
df['cummean'] = df['revenue'].expanding().mean()
df['cummax'] = df['revenue'].expanding().max()
df['cummin'] = df['revenue'].expanding().min()
print(df)

Pandas cumsum, cumprod, cummax, cummin

सबसे सामान्य संचयी आँकड़ों के लिए Pandas, expanding() की आवश्यकता के बिना, Series और DataFrame पर सीधे मेथड उपलब्ध कराता है: cumsum(), cumprod(), cummax() और cummin()। ये अनुकूलित कार्यान्वयन हैं और इनके expanding() समकक्षों की तुलना में थोड़े तेज़ हैं। वर्ष-से-तारीख आय (cumsum) या अब तक की अधिकतम कीमत (cummax) जैसे सामान्य व्यावसायिक मेट्रिक्स के लिए इन शॉर्टकट का उपयोग करें।

import pandas as pd
import numpy as np

prices = pd.Series(
    [100, 95, 110, 105, 120, 115, 130, 125],
    index=pd.date_range('2024-01-01', periods=8)
)

df = pd.DataFrame({'price': prices})
df['cummax'] = df['price'].cummax()    # all-time high
df['cummin'] = df['price'].cummin()    # all-time low
df['cumsum'] = df['price'].cumsum()    # cumulative total
df['cumprod'] = (1 + df['price'].pct_change()).cumprod()  # growth index
print(df.round(3))

Expanding के साथ वर्ष-से-तारीख गणना

विस्तारित विंडो का एक सामान्य उपयोग वर्ष-से-तारीख (YTD) आय निकालना है। प्रत्येक दिन के लिए आप वर्तमान वर्ष की 1 जनवरी से उस दिन तक की पूरी आय का योग चाहते हैं। यह प्रत्येक वर्ष के समूह के भीतर cumsum() लागू करने जितना ही सरल है। इसे groupby(year).cumsum() से लागू करें — हर कैलेंडर वर्ष की शुरुआत में cumsum फिर से शुरू होता है और पूरे वर्ष में संचय करता रहता है।

import pandas as pd
import numpy as np

np.random.seed(0)
dates = pd.date_range('2023-01-01', '2024-06-30', freq='ME')
daily = pd.DataFrame({
    'date': dates,
    'revenue': np.random.randint(100, 500, len(dates))
})

# Year-to-date cumulative revenue
daily['year'] = daily['date'].dt.year
daily['ytd_revenue'] = daily.groupby('year')['revenue'].cumsum()
daily = daily.drop(columns='year')
print(daily.tail(10).to_string(index=False))

विस्तारित विंडो का मानक विचलन

expanding().std() शुरुआत से वर्तमान पंक्ति तक के सभी डेटा का उपयोग करके चलता हुआ मानक विचलन निकालता है। यह निगरानी करने के लिए उपयोगी है कि किसी मेट्रिक की परिवर्तनशीलता समय के साथ बढ़ रही है या घट रही है — उदाहरण के लिए, यह देखना कि व्यवसाय के परिपक्व होने के साथ किसी उत्पाद की दैनिक बिक्री का अनुमान लगाना आसान हो रहा है या कठिन। रोलिंग std के विपरीत, जो केवल हाल की परिवर्तनशीलता दर्शाता है, विस्तारित std पूरे ऐतिहासिक फैलाव को समाहित करता है।

import pandas as pd
import numpy as np

np.random.seed(42)
sales = pd.Series(
    np.concatenate([
        np.random.normal(100, 5, 30),   # stable period
        np.random.normal(100, 25, 30)   # volatile period
    ]),
    index=pd.date_range('2024-01-01', periods=60)
)

df = pd.DataFrame({'sales': sales})
df['expanding_std'] = df['sales'].expanding().std()
df['rolling_30d_std'] = df['sales'].rolling(30).std()
print(df.tail(10).round(2))

Rolling और Expanding की तुलना

मुख्य अंतर यह है: रोलिंग विंडो हाल के प्रदर्शन (पिछले n दिनों) को दर्शाती हैं और बहुत पुराने डेटा से प्रभावित नहीं होतीं, जबकि विस्तारित विंडो पूरे इतिहास को शामिल करती हैं और इसलिए स्थिर मानों की ओर धीरे-धीरे अभिसरित होती हैं। जब आपका ध्यान हालिया रुझानों पर हो, तब rolling का उपयोग करें (7-दिन का चल औसत 90-दिन के औसत की तुलना में हाल के बदलावों पर अधिक तेज़ी से प्रतिक्रिया देता है)। जब आपको अब तक के आँकड़े या YTD मेट्रिक्स चाहिए, जिन्हें पुराने डेटा को कभी नहीं भूलना चाहिए, तब expanding का उपयोग करें।

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(10)
data = pd.Series(
    np.random.randn(60).cumsum() + 50,
    index=pd.date_range('2024-01-01', periods=60)
)

df = pd.DataFrame({'value': data})
df['rolling_10'] = data.rolling(10).mean()
df['expanding'] = data.expanding().mean()

df.plot(figsize=(12, 5), title='Rolling 10-day Mean vs. Expanding Mean')
plt.ylabel('Value')
plt.show()

कस्टम संचयी आँकड़ों के लिए Expanding Apply

expanding().apply(func) शुरुआत से वर्तमान पंक्ति तक के सभी डेटा पर एक कस्टम फ़ंक्शन लागू करता है, ठीक वैसे ही जैसे rolling().apply() करता है। इससे ऐसे संचयी आँकड़े निकाले जा सकते हैं जो पहले से उपलब्ध नहीं हैं — उदाहरण के लिए, संचयी परिवर्तन गुणांक (std/mean), चलता हुआ माध्यिका या संचयी Sharpe अनुपात। फ़ंक्शन को अब तक देखे गए सभी मानों की NumPy array मिलती है और उसे एक अदिश मान लौटाना आवश्यक है।

import pandas as pd
import numpy as np

np.random.seed(0)
returns = pd.Series(
    np.random.normal(0.001, 0.02, 60),
    index=pd.date_range('2024-01-01', periods=60)
)

# Cumulative Sharpe ratio (mean/std of returns)
def sharpe(arr):
    if len(arr) < 2:
        return float('nan')
    return arr.mean() / arr.std() * (252 ** 0.5)  # annualised

df = pd.DataFrame({'returns': returns})
df['cum_sharpe'] = df['returns'].expanding().apply(sharpe, raw=True)
print(df.tail(8).round(4))

NaN को संभालने वाली विस्तारित विंडो

विस्तारित विंडो डिफ़ॉल्ट रूप से NaN मानों को छोड़ देती हैं — Series के बीच में मौजूद NaN को संचयी योग या औसत निकालते समय अनदेखा किया जाता है। आप skipna=True से इसकी जाँच कर सकते हैं (अधिकांश Pandas एग्रीगेशन में यही डिफ़ॉल्ट होता है)। जब आपकी समय शृंखला में वास्तव में अनुपलब्ध मान हों (जैसे सप्ताहांत पर ट्रेडिंग न होना), तब विस्तारित आँकड़े अब तक देखे गए केवल गैर-NaN मानों से निकाले जाएंगे, जो आमतौर पर वांछित व्यवहार है।

import pandas as pd
import numpy as np

data = pd.Series([10, np.nan, 20, 30, np.nan, 40, 50])

# cumsum skips NaN by default
df = pd.DataFrame({'value': data})
df['cumsum'] = df['value'].cumsum()      # NaN propagates in cumsum!
df['expanding_sum'] = df['value'].expanding().sum()  # NaN skipped

print(df)
print('\nNote: cumsum propagates NaN; expanding().sum() skips it.')

चलते हुए बेंचमार्क के लिए विस्तारित विंडो

चलते हुए बेंचमार्क निकालने के लिए विस्तारित विंडो आदर्श हैं: अब तक का अधिकतम, अब तक की सबसे अच्छी तिमाही या लॉन्च के बाद से सबसे कम त्रुटि दर। इन KPI के लिए सभी ऐतिहासिक मान याद रखना आवश्यक है — रोलिंग विंडो पुराने रिकॉर्ड भूल जाएगी। cummax() या cummin() का उपयोग करने पर प्रत्येक बिंदु पर चलता हुआ सर्वश्रेष्ठ (या सबसे खराब) मान मिलता है, जिससे यह ट्रैक करना आसान हो जाता है कि नए रिकॉर्ड कब बने।

import pandas as pd
import numpy as np

np.random.seed(5)
sales = pd.Series(
    np.random.randint(100, 300, 20),
    index=pd.date_range('2024-01-01', periods=20),
    name='daily_sales'
)

df = pd.DataFrame({'sales': sales})
df['all_time_max'] = df['sales'].cummax()
df['new_record'] = df['sales'] == df['all_time_max']

print('Days where a new sales record was set:')
print(df[df['new_record']].drop(columns='new_record'))

व्यावहारिक उदाहरण: संचयी रिटर्न

वित्त में, संचयी रिटर्न बताते हैं कि शुरुआत की तारीख से प्रत्येक अगली तारीख तक किसी निवेश में कितनी वृद्धि हुई है। दैनिक प्रतिशत रिटर्न से शुरुआत करने पर (1 + daily_return) का संचयी गुणनफल कुल वृद्धि कारक देता है। यहाँ विस्तारित गुणनफल, रोलिंग गुणनफल की तुलना में अधिक स्वाभाविक है — आपको केवल पिछले n दिनों की नहीं, बल्कि निवेश शुरू होने के बाद से कुल वृद्धि को ट्रैक करना है।

import pandas as pd
import numpy as np

np.random.seed(7)
start_price = 100
daily_returns = pd.Series(
    np.random.normal(0.0005, 0.015, 252),
    index=pd.date_range('2024-01-01', periods=252)
)

# Cumulative return = product of (1 + r_i)
cum_returns = (1 + daily_returns).cumprod()
portfolio_value = start_price * cum_returns

print(f'Start value: ${start_price:.2f}')
print(f'End value:   ${portfolio_value.iloc[-1]:.2f}')
print(f'Total return: {(portfolio_value.iloc[-1]/start_price - 1)*100:.1f}%')

Expanding, Rolling और cumsum का उपयोग कब करें

सही तरीका चुनने के लिए दिशानिर्देश:

सरल संचयी एग्रीगेशन के लिए cumsum() / cummax() / cummin() का उपयोग करें — ये सबसे तेज़ विकल्प हैं।
जब आपको संचयी चलते हुए औसत या विचरण की आवश्यकता हो, तब expanding().mean() / std() का उपयोग करें।
ऐसे जटिल अब तक के आँकड़ों के लिए, जो पहले से उपलब्ध नहीं हैं, expanding().apply(custom_func) का उपयोग करें।
जब वर्तमान मान पर केवल हाल का इतिहास प्रभाव डालना चाहिए, तब expanding के बजाय rolling(n) का उपयोग करें।

त्वरित जाँच

इस पाठ में बताई गई विस्तारित विंडो की अपनी समझ जाँचें।

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

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

इस पाठ में आपने सीखा: expanding() Series की शुरुआत से बढ़ती हुई विंडो पर संचयी आँकड़े निकालता है; cumsum/cummax/cummin सामान्य संचयी प्रक्रियाओं के लिए अनुकूलित शॉर्टकट हैं; और विस्तारित विंडो अब तक के रिकॉर्ड, YTD मेट्रिक्स तथा संचयी निवेश रिटर्न के लिए आदर्श हैं। आगे हम घातांकीय रूप से भारित चल औसत (EWMA) का अध्ययन करेंगे — इसमें हाल के अवलोकनों को अधिक भार दिया जाता है।

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

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

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

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

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

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

क्या “एक्सपैंडिंग विंडो” पाठ निःशुल्क है?

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

“एक्सपैंडिंग विंडो” में मैं क्या सीखूँगा?

expanding().sum() से प्रत्येक बिंदु तक आरंभ से सभी पंक्तियों को शामिल करने वाले संचयी आँकड़े निकालें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Pandas & NumPy Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

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

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

“एक्सपैंडिंग विंडो” पाठ पूरा करने में कितना समय लगता है?

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

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

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

इस पाठ्यक्रम के सभी पाठ

← Pandas & NumPy Academy पर वापस जाएँ