Statistics & Aggregation Functions in Pandas: Complete Guide

Data ka asli insight tab milta hai jab aap numbers ko summarize, group, aur aggregate karein. Sikhiye 10 powerful statistical aur aggregation functions jo raw data ko actionable business intelligence mein convert karte hain.

📑 Is Masterclass Guide Mein Aap Kya Sikhenge:

Data summarization aur statistical analysis ke 10 professional tools:

• Central Tendency: mean(), median(), mode() — Data ka center kahan hai
• Spread Measures: std(), var() — Data kitna spread/scattered hai
• Aggregation Basics: sum(), count(), min(), max() — Quick column summaries
• Group Intelligence: groupby() — Category-wise data summarization
• Multi-Aggregation: agg() — Multiple statistics ek saath nikalna
• Cross-Tabulation: pivot_table() — Excel-style summary tables banana

🔍 Kya Hai: mean() column ke sabhi numerical values ka arithmetic average calculate karta hai — sabhi values ka sum divide by total count. Yeh data ka "center point" batata hai aur sabse commonly used central tendency measure hai.

🎯 Kyu Use Hota Hai: Business decisions mein averages critical hain — average salary kitni hai, average order value kya hai, average delivery time kitna hai. Mean se baseline expectations set hoti hain aur comparisons hote hain — "Is employee ki salary average se zyada hai ya kam?".

💡 Kab Use Hota Hai: KPI calculations (Average Order Value, Average Revenue Per User), missing value imputation, baseline comparisons, performance benchmarks, aur jab data approximately symmetric/normal distributed ho.

💻 Real-World Code Examples:

Example 1: Employee dataset mein overall average salary aur department-wise average salary nikalna.

import pandas as pd
employees = pd.read_csv("employees.csv")
# Overall average salary
print(f"Average Salary: ₹{employees['Salary'].mean():,.2f}")
# Department-wise average
dept_avg = employees.groupby("Department")["Salary"].mean().sort_values(ascending=False)
print(dept_avg)

Example 2: E-commerce mein Average Order Value (AOV) calculate karna — key business KPI.

# Overall AOV
aov = ecommerce["Revenue"].mean()
print(f"Average Order Value: ₹{aov:,.2f}")
# Monthly AOV trend
ecommerce["Month"] = pd.to_datetime(ecommerce["OrderDate"]).dt.month
monthly_aov = ecommerce.groupby("Month")["Revenue"].mean().round(2)
print(monthly_aov)

📊 Expected Output:

# Average Salary: ₹68,450.25

# Department-wise Average:
# Department   Salary
# IT           82500.00
# Finance      75200.50
# Marketing    62400.00
# HR           55800.75
# Operations   48200.00

# Average Order Value: ₹2,450.75
# Monthly AOV:
# Month 1:  2320.50
# Month 12: 3890.40  # Festive season spike!

✅ Best Practices:

• Mean outliers se heavily influenced hota hai — ek CEO ki ₹50 lakh salary puri company ki average salary distort kar degi. Skewed data mein median zyada reliable hai.
• mean() by default NaN values skip karta hai (skipna=True). Agar NaN include karke mean chahiye (rarely needed) toh skipna=False pass karein.
• Missing value imputation mein mean use karne se pehle check karein ki data normally distributed hai — skewed data ke liye median imputation better hai.

💬 Crack the Interview:

🔍 Kya Hai: median() data ko sorted order mein rakhne ke baad exact middle value return karta hai. Even count mein do middle values ka average hota hai. Yeh outlier-resistant central tendency measure hai jo skewed data mein mean se zyada accurate picture deta hai.

🎯 Kyu Use Hota Hai: Income data, property prices, transaction amounts — yeh sab highly right-skewed hote hain jahan kuch extreme values mean ko distort karte hain. Median "typical" value batata hai — "typical Indian household income" median se better represent hota hai, mean se nahi.

💡 Kab Use Hota Hai: Skewed data analysis (salaries, prices, amounts), outlier-resistant imputation, real estate price analysis, median household income reports, aur jab bhi "typical" value chahiye na ki "average" value.

💻 Real-World Code Examples:

Example 1: Salary data mein mean vs median compare karke skewness detect karna.

salary_mean   = employees["Salary"].mean()
salary_median = employees["Salary"].median()
print(f"Mean Salary:   ₹{salary_mean:,.2f}")
print(f"Median Salary: ₹{salary_median:,.2f}")
print(f"Difference:    ₹{salary_mean - salary_median:,.2f}")
if salary_mean > salary_median * 1.1:
    print("⚠️ Data is RIGHT-SKEWED — use median for imputation!")

Example 2: Missing salary values ko median se impute karna (outlier-resistant approach).

# Group-wise median imputation (best practice)
print(f"Missing Salaries Before: {employees['Salary'].isna().sum()}")
employees["Salary"] = employees.groupby("Department")["Salary"].transform(
    lambda x: x.fillna(x.median())
)
print(f"Missing Salaries After:  {employees['Salary'].isna().sum()}")

📊 Expected Output:

# Mean Salary:   ₹68,450.25
# Median Salary: ₹62,000.00
# Difference:    ₹6,450.25
# ⚠️ Data is RIGHT-SKEWED — use median for imputation!

# Missing Salaries Before: 280
# Missing Salaries After:  0    # All filled with
group median!

✅ Best Practices:

• Mean - Median ka difference bada hai toh data skewed hai. Mean > Median = right skewed (positive skew). Mean < Median = left skewed (negative skew).
• Missing value imputation mein group-wise median (department-wise, category-wise) overall median se always better hai kyunki groups ka distribution different hota hai.
• Median even count mein do middle values ka average deta hai — yeh existing value nahi bhi ho sakta dataset mein, lekin statistically correct representation hai.

💬 Crack the Interview:

🔍 Kya Hai: mode() column mein sabse frequently occurring value (most common value) return karta hai. Yeh categorical data ke liye primary central tendency measure hai. Agar multiple values same highest frequency rakhti hain toh sab return hoti hain (multi-modal).

🎯 Kyu Use Hota Hai: Categorical columns (Department, City, Gender) mein mean/median meaningless hai — mode batata hai ki sabse common category kaunsi hai. Missing categorical values impute karne ke liye mode sabse standard approach hai.

💡 Kab Use Hota Hai: Categorical missing value imputation, most popular product/category finding, default value assignment, survey response analysis, aur market research mein dominant preference identify karne ke liye.

💻 Real-World Code Examples:

Example 1: Employee dataset mein sabse common department, city aur rating find karna.

print("Most Common Department:", employees["Department"].mode()[0])
print("Most Common City:", employees["City"].mode()[0])
print("Most Common Rating:", employees["Rating"].mode()[0])

Example 2: Missing categorical values ko mode se impute karna (group-wise approach).

# Missing City values fill with overall mode
city_mode = employees["City"].mode()[0]
employees["City"] = employees["City"].fillna(city_mode)
# Group-wise mode imputation (Department-wise City mode)
employees["City"] = employees.groupby("Department")["City"].transform(
    lambda x: x.fillna(x.mode()[0] if not x.mode().empty else "Unknown")
)

📊 Expected Output:

# Most Common Department: IT       (3200 employees)
# Most Common City: Mumbai          (2850 employees)
# Most Common Rating: 4             (3500 employees)

✅ Best Practices:

• mode() DataFrame return karta hai (Series nahi) kyunki multi-modal possible hai. Hamesha [0] index lagayein first mode access karne ke liye.
• Group-wise mode mein empty group handle karein — agar kisi group mein koi non-null value nahi toh mode() empty hoga aur error aayega. Lambda mein error handling zaroori hai.
• High cardinality columns mein mode meaningless ho sakta hai — agar top mode ki frequency bhi low hai toh "Unknown" category assign karna better hai.

💬 Crack the Interview:

🔍 Kya Hai: std() Standard Deviation calculate karta hai — yeh measure karta hai ki data values mean se kitni door spread hain. Low std = values tightly clustered hain mean ke around. High std = values widely scattered hain. Yeh variance ka square root hota hai.

🎯 Kyu Use Hota Hai: Sirf average jaanna kaafi nahi — do companies ki average salary same ho sakti hai lekin ek mein sab 60K kamayein aur doosri mein kuch 20K kuch 1 Lakh. std() yeh inequality/variability quantify karta hai. Risk assessment, quality control, aur consistency measurement mein critical hai.

💡 Kab Use Hota Hai: Z-Score outlier detection (Formula: (value-mean)/std), financial risk assessment (portfolio volatility), manufacturing quality control (tolerance limits), aur feature scaling (StandardScaler divides by std).

💻 Real-World Code Examples:

Example 1: Department-wise salary consistency compare karna — konsa department mein zyada pay inequality hai.

# Overall salary spread
print(f"Salary Std: ₹{employees['Salary'].std():,.2f}")
# Department-wise consistency comparison
dept_stats = employees.groupby("Department")["Salary"].agg(["mean", "std"]).round(2)
dept_stats["CV%"] = ((dept_stats["std"] / dept_stats["mean"]) * 100).round(1)
print(dept_stats.sort_values("CV%", ascending=False))

Example 2: E-commerce delivery time consistency check — standard delivery window within 1 std.

delivery_mean = ecommerce["Delivery_Days"].mean()
delivery_std  = ecommerce["Delivery_Days"].std()
print(f"Avg Delivery: {delivery_mean:.1f} days")
print(f"Std Dev: {delivery_std:.1f} days")
print(f"68% orders delivered between {delivery_mean-delivery_std:.1f} - {delivery_mean+delivery_std:.1f} days")

📊 Expected Output:

# Salary Std: ₹28,500.80
# Department Consistency:
# Department   mean       std        CV%
# Marketing    62400.00   25800.50   41.3%  # Most unequal!
# IT           82500.00   22100.00   26.8%
# Finance      75200.50   18500.25   24.6%
# HR           55800.75   12400.00   22.2%  # Most consistent

# Avg Delivery: 4.2 days
# Std Dev: 1.8 days
# 68% orders delivered between 2.4 - 6.0 days

✅ Best Practices:

• Pandas std() by default ddof=1 use karta hai (sample standard deviation). Population std ke liye std(ddof=0) pass karein. ML aur statistics mein sample std (ddof=1) standard hai.
• Different units/scales ke columns compare karne ke liye Coefficient of Variation (CV = std/mean * 100) use karein — yeh unit-independent comparison enable karta hai.
• Normal distribution mein: 68% data within ±1 std, 95% within ±2 std, 99.7% within ±3 std (Empirical Rule).

💬 Crack the Interview:

🔍 Kya Hai: var() Variance calculate karta hai — yeh mean se har value ke deviation ka squared average hai. Mathematically: var = std². Variance data ki variability ka fundamental measure hai jo statistical tests, ANOVA, aur ML algorithms mein directly use hota hai.

🎯 Kyu Use Hota Hai: Variance statistical modeling ka backbone hai — ANOVA (group comparison) mein within-group vs between-group variance compare hoti hai. PCA mein maximum variance wale components select hote hain. Low variance features ML models mein useless hote hain aur remove kiye jaate hain.

💡 Kab Use Hota Hai: ANOVA statistical tests, PCA (Principal Component Analysis), feature selection (VarianceThreshold), portfolio risk calculation (financial variance), aur statistical model assumptions verification mein.

💻 Real-World Code Examples:

Example 1: Low variance features identify karke ML model se remove karna.

# Calculate variance of all numeric columns
numeric_cols = employees.select_dtypes(include=["number"]).columns
variances = employees[numeric_cols].var().sort_values()
print("Column Variances:")
print(variances.round(2))
# Identify near-zero variance columns (useless for ML)
low_var = variances[variances 0.01].index.tolist()
print(f"\nLow Variance Columns (Remove): {low_var}")

Example 2: Department-wise salary variance compare karke pay equity analysis.

dept_variance = employees.groupby("Department")["Salary"].var().sort_values(ascending=False)
print("Salary Variance by Department:")
print(dept_variance.round(2))
print(f"\nVerify: std² = var → {employees['Salary'].std()**2:.2f} = {employees['Salary'].var():.2f}")

📊 Expected Output:

# Column Variances:
# Flag_Active      0.00    # ⚠️ Near-zero — remove!
# Rating           0.85
# Age            103.02
# Salary   812295640.64    # High variance — important feature

# Salary Variance by Department:
# Marketing    665640025.00   # Highest inequality
# IT           488410000.00
# HR           153760000.00   # Most equitable

# Verify: std² = var → 812295640.64 = 812295640.64 ✅

✅ Best Practices:

• var() ki value squared units mein hoti hai (salary variance "rupees²" mein). Interpretation ke liye std() (same units) zyada intuitive hai. Variance mathematical calculations mein use hota hai.
• ML mein VarianceThreshold feature selector use karein: from sklearn.feature_selection import VarianceThreshold; selector = VarianceThreshold(threshold=0.01)
• var() bhi ddof=1 default use karta hai Pandas mein (sample variance). NumPy mein ddof=0 default hai — cross-library calculations mein consistent rakhein.

💬 Crack the Interview:

🔍 Kya Hai: sum() total calculate karta hai, count() non-null values count karta hai, min() smallest value, max() largest value return karta hai. Yeh chaar fundamental aggregation functions hain jo data summarization ki building blocks hain.

🎯 Kyu Use Hota Hai: Business mein sabse basic questions yahi hote hain — total revenue kitna hai (sum), kitne orders aaye (count), cheapest product kya hai (min), highest salary kya hai (max). Yeh functions standalone bhi use hote hain aur groupby() ke saath combined bhi.

💡 Kab Use Hota Hai: Revenue totals, transaction counts, salary ranges, age boundaries, inventory levels, aur har woh scenario jahan quick numerical summary chahiye — individually ya groupby ke saath.

💻 Real-World Code Examples:

Example 1: E-commerce business ka complete financial snapshot ek hi block mein.

print("📊 Business Dashboard")
print(f"Total Revenue:   ₹{ecommerce['Revenue'].sum():,.2f}")
print(f"Total Orders:    {ecommerce['OrderID'].count():,}")
print(f"Cheapest Order:  ₹{ecommerce['Revenue'].min():,.2f}")
print(f"Biggest Order:   ₹{ecommerce['Revenue'].max():,.2f}")
print(f"Revenue Range:   ₹{ecommerce['Revenue'].max() - ecommerce['Revenue'].min():,.2f}")

Example 2: Employee data mein age aur salary boundaries check karke impossible values detect karna.

# Data quality check using min/max
print(f"Age Range: {employees['Age'].min()} to {employees['Age'].max()}")
print(f"Salary Range: ₹{employees['Salary'].min():,.0f} to ₹{employees['Salary'].max():,.0f}")
# Flag impossible values
if employees["Age"].min() 0 or employees["Age"].max() > 120:
    print("⚠️ Invalid age values detected!")
# count() vs len() for missing value detection
print(f"\nTotal Rows: {len(employees)}")
print(f"Salary Non-Null: {employees['Salary'].count()}")
print(f"Missing Salaries: {len(employees) - employees['Salary'].count()}")

📊 Expected Output:

# 📊 Business Dashboard
# Total Revenue:   ₹3,67,51,250.00
# Total Orders:    15,000
# Cheapest Order:  ₹150.00
# Biggest Order:   ₹2,45,000.00
# Revenue Range:   ₹2,44,850.00

# Age Range: 18 to 65       ✅ Valid!
# Salary Range: ₹15,000 to ₹8,50,000
# Total Rows: 10000
# Salary Non-Null: 9720
# Missing Salaries: 280

✅ Best Practices:

• count() sirf non-null values count karta hai — len(df) total rows deta hai including NaN. Difference = missing values count. Yeh quick missing value detection technique hai.
• min()/max() string columns par bhi kaam karte hain — alphabetically first/last value return karte hain. Dates par earliest/latest date milti hai.
• sum() boolean columns par lagane se True values count hota hai: df['Is_Active'].sum() = active records count.

💬 Crack the Interview:

🔍 Kya Hai: groupby() Pandas ka sabse powerful function hai jo data ko categories mein split karke har group par separately aggregation apply karta hai. Yeh SQL ke GROUP BY ka equivalent hai. Split → Apply → Combine methodology follow karta hai.

🎯 Kyu Use Hota Hai: Real analysis hamesha category-wise hota hai — department-wise average salary, city-wise total revenue, month-wise order count, product-wise rating. Overall averages misleading hoti hain — groupby() granular insights deta hai jahan actual patterns chhupe hote hain.

💡 Kab Use Hota Hai: Department-wise analysis, region-wise sales, time-based trends (monthly/quarterly), customer segment comparison, product category performance, aur basically jab bhi "X ke basis par Y kya hai" type question answer karna ho.

💻 Real-World Code Examples:

Example 1: Department-wise complete salary analysis — count, mean, median, max sab ek saath.

# Simple groupby + single aggregation
dept_salary = employees.groupby("Department")["Salary"].mean().sort_values(ascending=False)
print(dept_salary)
# Multiple columns groupby
dept_city = employees.groupby(["Department", "City"])["Salary"].mean().round(2)
print(dept_city.head(10))

Example 2: E-commerce mein category-wise top selling products find karna.

# Category-wise sales performance
category_stats = ecommerce.groupby("Category").agg(
    Total_Revenue=("Revenue", "sum"),
    Total_Orders=("OrderID", "count"),
    Avg_Order_Value=("Revenue", "mean")
).sort_values("Total_Revenue", ascending=False).round(2)
print(category_stats)

📊 Expected Output:

# Department-wise Salary:
# IT           82500.00
# Finance      75200.50
# Marketing    62400.00
# HR           55800.75

# Category-wise Sales:
# Category      Total_Revenue  Total_Orders  Avg_Order_Value
# Electronics   1,25,00,000    3200          3906.25
# Fashion       89,50,000      4500          1988.89
# Home          52,00,000      2800          1857.14
# Books         18,50,000      4500          411.11

✅ Best Practices:

• groupby() ke baad .reset_index() lagayein agar result ko regular DataFrame jaisa use karna hai — bina reset ke multi-level index ban jaata hai.
• Multiple aggregations ke liye named aggregation syntax use karein (Example 2 jaisa) — readable output milta hai meaningful column names ke saath.
• groupby().transform() use karein jab group-level result ko original DataFrame size mein broadcast karna ho — jaise group mean se difference calculate karna.

💬 Crack the Interview:

🔍 Kya Hai: agg() (aggregate) multiple aggregation functions ko ek single call mein apply karta hai — same column par different functions ya different columns par different functions. Yeh groupby() ke saath milke complete multi-metric summary tables banata hai.

🎯 Kyu Use Hota Hai: Real reporting mein ek metric kaafi nahi hota — department ki sirf average salary se kaam nahi chalega, count, min, max, median sab chahiye ek saath. agg() se ek call mein multiple perspectives mil jaate hain jo complete picture deta hai.

💡 Kab Use Hota Hai: Dashboard data preparation, management reports, multi-KPI analysis tables, comprehensive group summaries, aur jab bhi ek hi data par multiple statistical measures simultaneously chahiye.

💻 Real-World Code Examples:

Example 1: Department-wise comprehensive salary report — multiple metrics ek saath.

# Same column par multiple aggregations
salary_report = employees.groupby("Department")["Salary"].agg(
    ["count", "mean", "median", "std", "min", "max"]
).round(2)
salary_report["range"] = salary_report["max"] - salary_report["min"]
print(salary_report)

Example 2: Different columns par different aggregation functions apply karna (Named Aggregation).

# Named aggregation — different functions on different columns
dept_summary = employees.groupby("Department").agg(
    Employee_Count=("EmployeeID", "count"),
    Avg_Salary=("Salary", "mean"),
    Avg_Age=("Age", "mean"),
    Max_Salary=("Salary", "max"),
    Avg_Rating=("Rating", "mean")
).round(2).sort_values("Avg_Salary", ascending=False)
print(dept_summary)

📊 Expected Output:

# Salary Report:
# Department  count   mean      median    std       min     max      range
# IT          3200    82500.00  78000.00  22100.00  32000   250000   218000
# Finance     2000    75200.50  72000.00  18500.25  35000   185000   150000
# HR          2400    55800.75  54000.00  12400.00  28000   120000   92000

# Named Aggregation:
# Department  Employee_Count  Avg_Salary  Avg_Age  Max_Salary  Avg_Rating
# IT          3200            82500.00    32.50    250000      4.20
# Finance     2000            75200.50    38.40    185000      3.85
# HR          2400            55800.75    34.20    120000      3.65

✅ Best Practices:

• Named Aggregation syntax (Example 2) zyada readable hai — output columns ko directly meaningful names milte hain bina post-renaming ke.
• Custom aggregation functions bhi pass kar sakte hain: .agg(range_func=('col', lambda x: x.max()-x.min()))
• agg() ke baad .reset_index() lagayein agar flat DataFrame chahiye — dashboard tools aur visualization libraries flat structure prefer karte hain.

💬 Crack the Interview:

🔍 Kya Hai: pivot_table() Excel ki pivot table ka Pandas version hai. Yeh data ko rows aur columns ke intersection par summarize karta hai — jaise Department (rows) × City (columns) ka average salary. Multidimensional analysis ka sabse powerful tool hai.

🎯 Kyu Use Hota Hai: groupby() linear summaries deta hai lekin cross-tabulation perspective nahi. pivot_table() se 2-dimensional matrix banti hai — rows mein ek category, columns mein doosri, aur cells mein aggregated values. Management dashboards aur business reports isi format mein hote hain.

💡 Kab Use Hota Hai: Department × City salary matrix, Month × Category revenue matrix, Region × Product sales matrix — jab bhi 2 categorical dimensions par ek numeric value summarize karni ho tab pivot_table() perfect choice hai.

💻 Real-World Code Examples:

Example 1: Department × City ki average salary ka cross-tabulation matrix banana.

salary_pivot = pd.pivot_table(
    employees,
    values="Salary",
    index="Department",
    columns="City",
    aggfunc="mean",
    margins=True,
    margins_name="Overall"
).round(0)
print(salary_pivot)

Example 2: E-commerce mein Month × Category revenue heatmap data banana with multiple aggfuncs.

ecommerce["Month"] = pd.to_datetime(ecommerce["OrderDate"]).dt.month_name()
revenue_pivot = pd.pivot_table(
    ecommerce,
    values="Revenue",
    index="Month",
    columns="Category",
    aggfunc=["sum", "count"],
    fill_value=0
)
print(revenue_pivot)

📊 Expected Output:

# Salary Pivot (Department × City):
# City        Mumbai   Delhi    Bangalore  Overall
# Department
# IT          85000    82000    92000      82500
# Finance     78000    72000    76000      75200
# HR          58000    52000    57000      55800
# Overall     72000    68000    74000      68450

# Revenue Pivot (Month × Category):
#            sum                          count
# Category   Electronics  Fashion  Home   Electronics  Fashion  Home
# January    520000       320000   180000  250         420      180
# December   980000       750000   420000  350         680      310

✅ Best Practices:

• margins=True lagayein — row aur column totals/averages automatically add ho jaate hain jo grand total aur subtotals ka kaam karte hain.
• fill_value=0 lagayein NaN cells ko 0 se replace karne ke liye — jab kisi combination ka data exist na kare (jaise January mein koi specific category sell nahi hui).
• Multiple aggfuncs list mein pass kar sakte hain: aggfunc=['sum','mean','count'] — MultiIndex columns bante hain jo comprehensive view dete hain.

💬 Crack the Interview:

🔍 Kya Hai: cumsum() running total calculate karta hai — har row par ab tak ka cumulative sum. cummax() ab tak ka maximum, cummin() ab tak ka minimum track karta hai. Yeh time-series aur sequential data analysis ke fundamental tools hain.

🎯 Kyu Use Hota Hai: Business mein running totals critical hain — YTD (Year-to-Date) revenue, MTD sales target progress, running maximum stock price (all-time high), cumulative customer acquisition count. Yeh functions time ke saath growth aur trends track karte hain.

💡 Kab Use Hota Hai: YTD/MTD revenue tracking, cumulative customer growth charts, running maximum/minimum in stock prices, progressive target achievement tracking, aur Pareto analysis (80/20 rule) mein cumulative percentage calculate karne ke liye.

💻 Real-World Code Examples:

Example 1: Monthly revenue data mein YTD (Year-to-Date) cumulative revenue aur target achievement track karna.

# Monthly revenue sorted by date
monthly = ecommerce.groupby(pd.to_datetime(ecommerce["OrderDate"]).dt.to_period("M"))["Revenue"].sum().reset_index()
monthly.columns = ["Month", "Revenue"]
monthly["YTD_Revenue"]  = monthly["Revenue"].cumsum()
monthly["Running_Max"]  = monthly["Revenue"].cummax()
monthly["Best_Month?"]  = monthly["Revenue"] == monthly["Running_Max"]
print(monthly)

Example 2: Pareto Analysis — top products finding using cumulative percentage.

# Product-wise revenue sorted descending
product_rev = ecommerce.groupby("Product")["Revenue"].sum().sort_values(ascending=False)
product_rev_df = product_rev.reset_index()
product_rev_df["Cumulative_Revenue"] = product_rev_df["Revenue"].cumsum()
product_rev_df["Cumulative_%"] = (product_rev_df["Cumulative_Revenue"] / product_rev_df["Revenue"].sum() * 100).round(1)
top_products = product_rev_df[product_rev_df["Cumulative_%"] 80]
print(f"Top {len(top_products)} products generate 80% revenue!")

📊 Expected Output:

# YTD Revenue Tracking:
# Month    Revenue   YTD_Revenue  Running_Max  Best_Month?
# Jan      450000    450000       450000       True
# Feb      380000    830000       450000       False
# Mar      520000    1350000      520000       True  # New record!
# ...
# Dec      890000    6750000      890000       True  # All-time best!

# Pareto Analysis:
# Top 15 products generate 80% revenue!  (Out of 200 total products)

✅ Best Practices:

• Cumulative functions apply karne se pehle data ko correctly sort karein (date-wise ya relevant order mein) — unsorted data par cumsum() meaningless results dega.
• Group-wise cumulative sum ke liye: df.groupby('Category')['Revenue'].cumsum() — har group ka separate running total calculate hota hai.
• cumprod() bhi available hai — compound growth rate calculate karne ke liye: (1 + df['Returns']).cumprod() investment growth track karta hai.

💬 Crack the Interview:

Apne statistical requirement ke basis par sahi function chunye:

Next Post Preview: Masterclass Part 10

Next masterclass mein hum cover karenge: Relationships & Correlation Functions — corr(), cov(), crosstab(), scatter analysis aur 9 powerful tools jo variables ke beech hidden relationships discover karte hain.

Happy Coding & Stay Analytically Pure! 🚀