Date & Time Functions in Pandas: Complete Guide

Real-world data mein dates aur timestamps sabse common aur tricky columns hote hain. Sikhiye Basic se Advanced tak 18 powerful Date & Time formulas jo aapke time-series analysis aur feature engineering ko professional level par le jayenge.

📑 Is Masterclass Guide Mein Aap Kya Sikhenge:

Basic se Advanced tak 18 Date & Time formulas jo real-world data analysis mein use hote hain:

• Basic Level: pd.to_datetime(), dt.date, dt.year/month/day, dt.hour/minute/second, dt.day_name(), dt.month_name()
• Intermediate Level: dt.quarter, dt.week, dt.dayofyear, dt.days_in_month, pd.DateOffset(), dt.is_month_end/start
• Advanced Level: pd.Timedelta, pd.date_range(), dt.tz_localize/convert(), errors='coerce', resample(), dt.normalize()

🔍 Kya Hai: pd.to_datetime() Pandas ka sabse fundamental date function hai jo string format mein stored date values (jaise "2024-01-15", "15/01/2024") ko proper Python DateTime object mein convert karta hai jis par aap date calculations kar sakte hain.

🎯 Kyu Use Hota Hai: CSV files se load hone ke baad date columns by default string (object) dtype mein hote hain. String dates par aap arithmetic operations, filtering, ya time-based grouping nahi kar sakte. pd.to_datetime() unhe proper DateTime dtype mein convert karke yeh sab possible bana deta hai.

💡 Kab Use Hota Hai: Dataset load karne ke turant baad, jab bhi date column ka dtype object/string ho. Feature engineering se pehle aur time-series analysis start karne se pehle yeh step mandatory hai.

💻 Real-World Code Examples:

Example 1: E-commerce orders dataset mein "OrderDate" column ko string se DateTime mein convert karna.

import pandas as pd
ecommerce = pd.read_csv("orders.csv")
ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
# Verify conversion
print(ecommerce["OrderDate"].dtype)  # datetime64[ns]

Example 2: Custom format wali date string convert karna jaise "15-Jan-2024" format.

employees["JoiningDate"] = pd.to_datetime(
    employees["JoiningDate"],
    format="%d-%b-%Y"
)
print(employees["JoiningDate"].head())

📊 Expected Output:

# Before: "2024-01-15"  dtype: object
# After:  2024-01-15    dtype: datetime64[ns]
# Custom: "15-Jan-2024" -> 2024-01-15 00:00:00

✅ Best Practices — Data Insights Rulebook:

• Hamesha dataset load karne ke baad pehla step date columns convert karna hona chahiye, baad mein nahi.
• Jab date format known ho tab format= parameter explicitly specify karein, isse conversion 10x faster hoti hai.
• Mixed ya invalid dates handle karne ke liye errors='coerce' use karein jo invalid values ko NaT mein convert kar deta hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.date aur dt.time DateTime accessor properties hain jo timestamp column se sirf date part (YYYY-MM-DD) ya sirf time part (HH:MM:SS) ko alag extract karke naya column banate hain.

🎯 Kyu Use Hota Hai: Real-world systems mein timestamps complete hote hain jaise "2024-01-15 14:30:00". Lekin analysis mein kabhi sirf date chahiye hoti hai (daily sales report ke liye) aur kabhi sirf time (peak hours analysis ke liye). Dono ko alag karna data granularity control deta hai.

💡 Kab Use Hota Hai: Log files processing mein, transaction timestamp analysis mein, aur jab date aur time par alag alag groupby operations karne ho tab in dono ko separate columns mein rakhna best practice hai.

💻 Real-World Code Examples:

Example 1: Bank transaction timestamps se date aur time alag alag columns mein extract karna.

bank["TransactionDate"] = pd.to_datetime(bank["Timestamp"])
bank["Only_Date"] = bank["TransactionDate"].dt.date
bank["Only_Time"] = bank["TransactionDate"].dt.time
print(bank[["Timestamp", "Only_Date", "Only_Time"]].head())

Example 2: E-commerce orders mein delivery timestamp se sirf delivery date extract karke daily order count nikalna.

ecommerce["DeliveryDate"] = pd.to_datetime(ecommerce["DeliveryTimestamp"]).dt.date
daily_orders = ecommerce.groupby("DeliveryDate")["OrderID"].count()
print(daily_orders)

📊 Expected Output:

# Timestamp: "2024-01-15 14:30:00"
# Only_Date:  2024-01-15   (date object)
# Only_Time:  14:30:00     (time object)

# Daily Orders Output:
# DeliveryDate   OrderID
# 2024-01-15     245
# 2024-01-16     312

✅ Best Practices — Data Insights Rulebook:

• dt.date Python date object return karta hai jo datetime64 nahi hota. Agar aage datetime operations karne hain toh result ko wapas pd.to_datetime() se convert karein.
• Peak hours analysis ke liye dt.time ki jagah dt.hour use karna zyada convenient hota hai kyunki yeh integer return karta hai.
• Original timestamp column kabhi delete mat karein, extracted columns alag rakhein.

💬 Crack the Interview:

🔍 Kya Hai: dt.year, dt.month, aur dt.day DateTime accessor properties hain jo datetime column se integer format mein year, month number, aur day number separately extract karte hain. Yeh sabse commonly used date component extractors hain.

🎯 Kyu Use Hota Hai: Time-based analysis mein aksar yearly trends, monthly sales patterns, ya specific day performance dekhni hoti hai. In components ko alag columns mein rakhne se groupby, filtering, aur pivot table operations bahut easy ho jaate hain.

💡 Kab Use Hota Hai: Monthly sales reports banana, yearly performance comparison, specific date filtering, aur time-based feature engineering mein yeh teen properties sabse zyada use hoti hain.

💻 Real-World Code Examples:

Example 1: Employees joining date se year, month, day alag columns mein extract karna aur yearly hiring trend dekhna.

employees["JoiningDate"] = pd.to_datetime(employees["JoiningDate"])
employees["Join_Year"]  = employees["JoiningDate"].dt.year
employees["Join_Month"] = employees["JoiningDate"].dt.month
employees["Join_Day"]   = employees["JoiningDate"].dt.day
yearly_hiring = employees.groupby("Join_Year")["EmployeeID"].count()
print(yearly_hiring)

Example 2: E-commerce dataset mein monthly sales revenue aggregate karna.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Order_Month"] = ecommerce["OrderDate"].dt.month
ecommerce["Order_Year"]  = ecommerce["OrderDate"].dt.year
monthly_revenue = ecommerce.groupby(["Order_Year", "Order_Month"])["Revenue"].sum()
print(monthly_revenue)

📊 Expected Output:

# Yearly Hiring:
# Join_Year   EmployeeID
# 2021        45
# 2022        78
# 2023        92

# Monthly Revenue:
# Order_Year  Order_Month  Revenue
# 2024        1            450000
# 2024        2            520000

✅ Best Practices — Data Insights Rulebook:

• ML models mein date column directly mat daalo. Uski jagah year, month, day ke alag integer columns banao kyunki models numerical features samajhte hain.
• Month number (1-12) ki jagah month name chahiye toh dt.month_name() use karein jo human-readable output deta hai.
• Cyclical features (month, day) ke liye sin/cos encoding consider karein ML models mein taaki 12→1 wrap-around relationship preserve ho.

💬 Crack the Interview:

🔍 Kya Hai: dt.hour, dt.minute, aur dt.second timestamp columns se time ke individual integer components extract karte hain. Hour 0-23 range mein, minute 0-59 mein, aur second 0-59 mein return hota hai.

🎯 Kyu Use Hota Hai: Customer behavior aur operational systems mein time-of-day patterns bahut important hote hain. Peak hours identify karna, shift-wise performance analysis, ya specific minute-level anomaly detection ke liye yeh properties essential hain.

💡 Kab Use Hota Hai: Call center peak hours analysis, restaurant rush hours identification, server log anomaly detection, aur ride-sharing demand pattern analysis mein yeh properties directly use hoti hain.

💻 Real-World Code Examples:

Example 1: Bank transactions mein hourly activity pattern dhundhna — kis ghante mein sabse zyada transactions hote hain.

bank["Timestamp"] = pd.to_datetime(bank["Timestamp"])
bank["Trans_Hour"]   = bank["Timestamp"].dt.hour
bank["Trans_Minute"] = bank["Timestamp"].dt.minute
hourly_activity = bank.groupby("Trans_Hour")["TransactionID"].count()
print(hourly_activity.sort_values(ascending=False).head(5))

Example 2: E-commerce platform par evening hours (6PM-10PM) ke orders filter karke prime time sales analyze karna.

ecommerce["Order_Hour"] = pd.to_datetime(ecommerce["OrderTimestamp"]).dt.hour
prime_time_orders = ecommerce[(ecommerce["Order_Hour"] >= 18) & 
                               (ecommerce["Order_Hour"] 22)]
print(f"Prime Time Orders: {len(prime_time_orders)}")

📊 Expected Output:

# Hourly Activity (Top 5 Peak Hours):
# Trans_Hour   TransactionID
# 11           892    # Late morning peak
# 14           845    # Post lunch peak
# 10           801

# Prime Time Orders: 4521  # 6PM-10PM orders count

✅ Best Practices — Data Insights Rulebook:

• Hour extract karne se pehle timezone verify karein. UTC timestamps ko local time mein convert kiye bina peak hours analysis galat results dega.
• Business shift analysis ke liye hour ranges define karein: Morning (6-12), Afternoon (12-18), Evening (18-24), Night (0-6).
• Second-level granularity sirf tab use karein jab genuinely zaroorat ho warna unnecessary complexity badh jaati hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.day_name() datetime column se weekday ka full name string format mein return karta hai jaise "Monday", "Tuesday", "Wednesday" etc. Yeh dt.dayofweek (jo 0-6 integer deta hai) ka human-readable version hai.

🎯 Kyu Use Hota Hai: Weekly patterns identify karna business analytics ka core part hai. Weekday vs weekend performance comparison, specific day promotions effectiveness, aur staffing optimization ke liye day names extract karna essential hai.

💡 Kab Use Hota Hai: Retail sales weekly pattern analysis, restaurant footfall day-wise comparison, social media engagement weekly trends, aur employee attendance weekday analysis mein directly use hota hai.

💻 Real-World Code Examples:

Example 1: E-commerce platform par har weekday ki average sales nikalna — best aur worst performing days identify karna.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Day_Name"] = ecommerce["OrderDate"].dt.day_name()
daily_avg_sales = ecommerce.groupby("Day_Name")["Revenue"].mean().sort_values(ascending=False)
print(daily_avg_sales)

Example 2: Weekend vs Weekday transactions count compare karna bank data mein.

bank["Day_Name"] = pd.to_datetime(bank["Timestamp"]).dt.day_name()
bank["Is_Weekend"] = bank["Day_Name"].isin(["Saturday", "Sunday"])
weekend_vs_weekday = bank.groupby("Is_Weekend")["TransactionAmount"].sum()
print(weekend_vs_weekday)

📊 Expected Output:

# Daily Average Sales:
# Day_Name   Revenue
# Sunday     85420.5   # Highest
# Saturday   78350.2
# Friday     65200.8
# Monday     45100.3   # Lowest

# Weekend vs Weekday:
# Is_Weekend   TransactionAmount
# False        8542000   # Weekday total
# True         3210000   # Weekend total

✅ Best Practices — Data Insights Rulebook:

• ML models mein dt.day_name() string values directly mat daalo. Pehle dt.dayofweek (integer 0-6) use karein ya one-hot encoding apply karein.
• Sorting ke liye day names alphabetically sort hote hain jo galat order deta hai. Correct weekly order ke liye dt.dayofweek se sort karein.
• Locale-specific day names ke liye dt.day_name(locale='hi_IN') jaise locale parameter pass kar sakte hain.

💬 Crack the Interview:

🔍 Kya Hai: dt.month_name() datetime column se month ka full English name string format mein return karta hai jaise "January", "February", "March" etc. Yeh dt.month (integer 1-12) ka readable version hai jo reports aur visualizations mein use hota hai.

🎯 Kyu Use Hota Hai: Monthly business reports, seasonal analysis dashboards, aur stakeholder presentations mein "Month 1" ki jagah "January" dikhna professional aur readable lagta hai. Seasonal patterns identify karne ke liye month names se grouping karna standard practice hai.

💡 Kab Use Hota Hai: Annual reports generation, seasonal product demand analysis, monthly employee performance reviews, aur financial quarterly summaries mein month names ka use visualization clarity badhaata hai.

💻 Real-World Code Examples:

Example 1: E-commerce dataset mein monthly revenue report banana with proper month names.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Month_Name"] = ecommerce["OrderDate"].dt.month_name()
ecommerce["Month_Num"]  = ecommerce["OrderDate"].dt.month
monthly_report = ecommerce.groupby(["Month_Num", "Month_Name"])["Revenue"].sum().reset_index()
monthly_report = monthly_report.sort_values("Month_Num")
print(monthly_report[["Month_Name", "Revenue"]])

Example 2: Bank dataset mein festive season months (October, November, December) ki transactions highlight karna.

bank["Month_Name"] = pd.to_datetime(bank["Timestamp"]).dt.month_name()
festive_months = ["October", "November", "December"]
festive_transactions = bank[bank["Month_Name"].isin(festive_months)]
print(f"Festive Season Transactions: {len(festive_transactions)}")

📊 Expected Output:

# Monthly Revenue Report:
# Month_Name   Revenue
# January      450000
# February     380000
# March        520000
# ...

# Festive Season Transactions: 8421

✅ Best Practices — Data Insights Rulebook:

• Month names se groupby karte waqt alphabetical sorting hogi (April, August...) jo galat hai. Hamesha Month_Num column se sort karein correct chronological order ke liye.
• Visualization libraries (matplotlib, seaborn) mein month names use karo lekin ML models mein sirf integer month numbers use karo.
• Dono columns saath rakhein: Month_Name (display ke liye) aur Month_Num (computation ke liye) — Example 1 mein exactly yahi approach hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.quarter datetime column se us date ka fiscal quarter integer (1, 2, 3, ya 4) return karta hai. Q1 = January-March, Q2 = April-June, Q3 = July-September, Q4 = October-December.

🎯 Kyu Use Hota Hai: Corporate finance aur business analytics mein quarterly reporting standard practice hai. Annual targets ko quarters mein break karke performance track karna, quarterly bonus calculations, aur board presentations ke liye quarter-wise aggregation essential hai.

💡 Kab Use Hota Hai: Quarterly earnings reports, Q-o-Q (Quarter over Quarter) growth analysis, sales team quarterly targets tracking, aur financial auditing mein quarter-wise data segmentation ke liye.

💻 Real-World Code Examples:

Example 1: Company revenue data mein quarterly performance summary banana.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Quarter"] = ecommerce["OrderDate"].dt.quarter
ecommerce["Year"]    = ecommerce["OrderDate"].dt.year
quarterly_revenue = ecommerce.groupby(["Year", "Quarter"])["Revenue"].sum()
print(quarterly_revenue)

Example 2: Q4 (festive season) performance compare karna baaki quarters se.

q4_data = ecommerce[ecommerce["Quarter"] == 4]
other_q  = ecommerce[ecommerce["Quarter"] != 4]
print(f"Q4 Avg Revenue: {q4_data['Revenue'].mean():.2f}")
print(f"Other Quarters Avg: {other_q['Revenue'].mean():.2f}")

📊 Expected Output:

# Quarterly Revenue:
# Year  Quarter  Revenue
# 2024  1        1250000
# 2024  2        1480000
# 2024  3        1350000
# 2024  4        2100000  # Q4 highest (festive)

# Q4 Avg Revenue: 85420.50
# Other Quarters Avg: 52340.20

✅ Best Practices — Data Insights Rulebook:

• Pandas ka dt.quarter calendar year quarters use karta hai (Jan-Mar = Q1). Agar aapki company ka fiscal year April se start hota hai toh custom quarter mapping manually karni padegi.
• Quarter labels "Q1", "Q2" format mein banana ho toh: df['Q_Label'] = 'Q' + df['Date'].dt.quarter.astype(str)
• Year aur Quarter dono saath groupby karein warna multiple years ka data mix ho jaata hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.isocalendar() ek DataFrame return karta hai jisme teen columns hote hain: ISO year, ISO week number (1-53), aur ISO weekday (1=Monday, 7=Sunday). Yeh international standard week numbering system hai jo globally business reporting mein use hota hai.

🎯 Kyu Use Hota Hai: Weekly inventory management, sprint planning (agile teams), weekly KPI dashboards, aur retail weekly sales reports mein week numbers ka use standard hai. ISO week system ensure karta hai ki globally sab same week number reference karein.

💡 Kab Use Hota Hai: Supply chain weekly demand forecasting, retail weekly sales comparison (Week 45 vs Week 46), agile development sprint tracking, aur weekly employee productivity reports mein.

💻 Real-World Code Examples:

Example 1: E-commerce orders mein ISO week number extract karke weekly sales trend analyze karna.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
iso_cal = ecommerce["OrderDate"].dt.isocalendar()
ecommerce["ISO_Week"] = iso_cal["week"]
ecommerce["ISO_Year"] = iso_cal["year"]
weekly_sales = ecommerce.groupby(["ISO_Year", "ISO_Week"])["Revenue"].sum()
print(weekly_sales.tail(5))

Example 2: Current week ka data filter karna real-time weekly dashboard ke liye.

current_week = pd.Timestamp.now().isocalendar()[1]
current_year = pd.Timestamp.now().year
this_week_data = ecommerce[
    (ecommerce["ISO_Week"] == current_week) & 
    (ecommerce["ISO_Year"] == current_year)
]
print(f"This Week Orders: {len(this_week_data)}")

📊 Expected Output:

# Weekly Sales (Last 5 weeks):
# ISO_Year  ISO_Week  Revenue
# 2024      47        425000
# 2024      48        398000
# 2024      49        512000
# 2024      50        487000
# 2024      51        620000  # Pre-Christmas spike

# This Week Orders: 1245

✅ Best Practices — Data Insights Rulebook:

• Purane dt.week property ko deprecated kar diya gaya hai. Hamesha dt.isocalendar().week use karein jo correct aur future-proof hai.
• Year boundary weeks (Week 52/53 vs Week 1) pe dhyan do. ISO year aur calendar year different ho sakte hain December/January mein, isliye ISO_Year column zaroori hai.
• Week numbers sirf ISO_Year ke saath groupby karein, warna Week 1 of 2023 aur Week 1 of 2024 mix ho jaate hain.

💬 Crack the Interview:

🔍 Kya Hai: dt.dayofyear datetime column se yeh integer (1-365 ya leap year mein 1-366) return karta hai ki woh date saal ka konsa din hai. January 1 = 1, December 31 = 365 hota hai.

🎯 Kyu Use Hota Hai: Time-series models aur seasonal forecasting mein day-of-year ek powerful continuous feature hai. Yeh cyclical annual patterns (jaise monsoon season, holiday rush, agricultural cycles) capture karne mein help karta hai. Month/day combination se zyada precise hota hai.

💡 Kab Use Hota Hai: Weather data analysis, agricultural yield prediction, annual sales cycle modeling, epidemic spread tracking, aur any domain jahan annual seasonality important ho wahan dt.dayofyear feature engineering mein use hota hai.

💻 Real-World Code Examples:

Example 1: E-commerce sales data mein day of year extract karke annual sales cycle pattern visualize karna.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Day_of_Year"] = ecommerce["OrderDate"].dt.dayofyear
annual_pattern = ecommerce.groupby("Day_of_Year")["Revenue"].mean()
print(f"Diwali Period (Day 280-310) Avg Revenue: {annual_pattern[280:310].mean():.2f}")

Example 2: ML feature mein cyclical encoding apply karna day of year par.

import numpy as np
ecommerce["Day_sin"] = np.sin(2 * np.pi * ecommerce["Day_of_Year"] / 365)
ecommerce["Day_cos"] = np.cos(2 * np.pi * ecommerce["Day_of_Year"] / 365)
print(ecommerce[["Day_of_Year", "Day_sin", "Day_cos"]].head())

📊 Expected Output:

# Diwali Period Avg Revenue: 125430.50

# Cyclical Encoding:
# Day_of_Year  Day_sin   Day_cos
# 1            0.0172    0.9999
# 90           0.9990    0.0436
# 180          0.0345   -0.9994
# 365          -0.0172   0.9999  # Close to Day 1 again!

✅ Best Practices — Data Insights Rulebook:

• Leap years (366 days) handle karne ke liye sin/cos encoding mein 365 ki jagah dynamically actual year days use karein: days_in_year = 366 if calendar.isleap(year) else 365.
• Day of year akele mat use karein ML mein — saath mein year feature bhi dein taaki model inter-year trends bhi seekh sake.
• Cyclical encoding (sin/cos) hamesha raw day number se better hai ML models ke liye kyunki yeh year wrap-around correctly represent karta hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.days_in_month datetime column se us specific date ke month mein total kitne days hain yeh integer return karta hai. January = 31, February = 28 (ya 29 leap year mein), April = 30 etc.

🎯 Kyu Use Hota Hai: Per-day rates calculate karne ke liye (monthly salary ko daily rate mein convert karna), prorated billing (partial month charges), aur month-normalized metrics ke liye actual days in month ka pata hona zaroori hai kyunki months ki lengths different hoti hain.

💡 Kab Use Hota Hai: Payroll prorating (employee ne month ke beech join kiya), utility bill per-day calculation, SaaS subscription prorated charges, aur monthly target vs actual comparison mein normalization ke liye.

💻 Real-World Code Examples:

Example 1: Employee ne month ke beech join kiya — prorated salary calculate karna joining date ke basis par.

employees["JoiningDate"] = pd.to_datetime(employees["JoiningDate"])
employees["Days_In_Month"]  = employees["JoiningDate"].dt.days_in_month
employees["Days_Worked"]    = employees["Days_In_Month"] - employees["JoiningDate"].dt.day + 1
employees["Prorated_Salary"] = (employees["Salary"] / employees["Days_In_Month"]) * employees["Days_Worked"]
employees["Prorated_Salary"] = employees["Prorated_Salary"].round(2)
print(employees[["Name", "JoiningDate", "Days_Worked", "Prorated_Salary"]])

Example 2: Monthly sales ko per-day normalized metric mein convert karna fair comparison ke liye.

ecommerce["Days_In_Month"]    = ecommerce["OrderDate"].dt.days_in_month
ecommerce["Daily_Sales_Rate"] = (ecommerce["Revenue"] / ecommerce["Days_In_Month"]).round(2)
print(ecommerce[["OrderDate", "Revenue", "Daily_Sales_Rate"]].head())

📊 Expected Output:

# Prorated Salary Example:
# Name      JoiningDate  Days_Worked  Prorated_Salary
# Rahul     2024-01-15   17           27741.94  # 17/31 of 50600

# Daily Sales Rate:
# OrderDate   Revenue   Daily_Sales_Rate
# 2024-01-05  450000    14516.13  # 450000/31
# 2024-02-10  380000    13103.45  # 380000/29 (leap year)

✅ Best Practices — Data Insights Rulebook:

• Leap year automatically handle ho jaata hai — February 2024 mein dt.days_in_month = 29 return karega. Manually check karne ki zaroorat nahi.
• Prorated calculations mein weekends aur holidays consider karna ho toh np.busday_count() se actual working days count karein days_in_month ki jagah.
• Per-day normalization se February (28 days) aur January (31 days) ke monthly totals fair compare ho jaate hain.

💬 Crack the Interview:

🔍 Kya Hai: pd.DateOffset() ek flexible date arithmetic tool hai jo dates mein specific time periods (days, weeks, months, years, hours) add ya subtract karne deta hai. Yeh calendar-aware hai matlab month boundaries, leap years automatically handle karta hai.

🎯 Kyu Use Hota Hai: Business operations mein future dates calculate karna common task hai — EMI due dates, subscription renewal dates, contract expiry dates, payment deadlines. Simple days add karne se month boundaries galat handle hoti hain lekin DateOffset calendar-correctly kaam karta hai.

💡 Kab Use Hota Hai: Loan EMI schedule generation, subscription expiry date calculation, contract renewal date computation, delivery SLA deadline tracking, aur trial period end date calculation mein.

💻 Real-World Code Examples:

Example 1: Bank loan disbursement date se 6 months baad ki EMI due date calculate karna.

bank["DisbursementDate"] = pd.to_datetime(bank["DisbursementDate"])
bank["First_EMI_Date"]  = bank["DisbursementDate"] + pd.DateOffset(months=1)
bank["Loan_Expiry"]     = bank["DisbursementDate"] + pd.DateOffset(years=5)
print(bank[["DisbursementDate", "First_EMI_Date", "Loan_Expiry"]].head())

Example 2: E-commerce orders mein 30-day return window deadline calculate karna.

ecommerce["OrderDate"]      = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Return_Deadline"] = ecommerce["OrderDate"] + pd.DateOffset(days=30)
today = pd.Timestamp.now()
ecommerce["Return_Eligible"] = ecommerce["Return_Deadline"] >= today
print(ecommerce[["OrderDate", "Return_Deadline", "Return_Eligible"]].head())

📊 Expected Output:

# Loan Schedule:
# DisbursementDate  First_EMI_Date  Loan_Expiry
# 2024-01-15        2024-02-15      2029-01-15

# Return Window:
# OrderDate   Return_Deadline  Return_Eligible
# 2024-11-01  2024-12-01       True
# 2024-09-15  2024-10-15       False  # Expired

✅ Best Practices — Data Insights Rulebook:

• Simple days add karne ke liye pd.Timedelta(days=30) use karein — yeh faster hai. DateOffset tab use karein jab months ya years add karne ho kyunki woh calendar-aware hai.
• Business days offset ke liye pd.offsets.BusinessDay(n) use karein jo weekends automatically skip karta hai.
• Large datasets par DateOffset slow ho sakta hai — apply() ki jagah vectorized operations prefer karein.

💬 Crack the Interview:

🔍 Kya Hai: dt.is_month_end aur dt.is_month_start Boolean properties hain jo check karti hain ki koi date apne month ki last day hai ya pehli day. True ya False return karta hai. Iske saath dt.is_year_start, dt.is_year_end, dt.is_quarter_start, dt.is_quarter_end bhi available hain.

🎯 Kyu Use Hota Hai: Financial systems mein month-end closing transactions special hote hain (salary disbursement, rent payments, closing entries). Month-start dates par new subscriptions, billing cycles start hote hain. In specific dates ko flag karna reporting aur automation mein kaafi useful hota hai.

💡 Kab Use Hota Hai: Payroll disbursement date verification, monthly closing entries identification, subscription billing cycle start detection, aur quarter-end financial reporting flags mein.

💻 Real-World Code Examples:

Example 1: Bank transactions mein month-end high-value salary transactions identify karna.

bank["TransDate"] = pd.to_datetime(bank["TransDate"])
bank["Is_Month_End"]   = bank["TransDate"].dt.is_month_end
bank["Is_Month_Start"] = bank["TransDate"].dt.is_month_start
month_end_trans = bank[bank["Is_Month_End"] == True]
print(f"Month-End Transactions: {len(month_end_trans)}")
print(month_end_trans["TransactionAmount"].describe())

Example 2: Quarter-end dates par special reporting flag banana financial dataset mein.

ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["Is_Quarter_End"]   = ecommerce["OrderDate"].dt.is_quarter_end
ecommerce["Is_Quarter_Start"] = ecommerce["OrderDate"].dt.is_quarter_start
quarter_end_orders = ecommerce[ecommerce["Is_Quarter_End"]]
print(f"Quarter-End Orders: {len(quarter_end_orders)}")

📊 Expected Output:

# Month-End Transactions: 312
# TransactionAmount Stats:
# mean    45230.50   # Higher avg on month-end (salary credits)
# max    850000.00

# Quarter-End Orders: 89  # March 31, June 30, Sep 30, Dec 31

✅ Best Practices — Data Insights Rulebook:

• is_month_end actual calendar month end check karta hai (Jan=31, Feb=28/29, etc.) — manually day numbers check karne ki zaroorat nahi, yeh automatically correct hai.
• ML features mein is_month_end ko integer (0/1) mein convert karein: df['month_end_flag'] = df['Date'].dt.is_month_end.astype(int)
• Financial anomaly detection mein month-end transactions ko separately analyze karein kyunki inke patterns regular days se fundamentally different hote hain.

💬 Crack the Interview:

🔍 Kya Hai: Jab do datetime columns ka difference nikala jata hai toh result Timedelta dtype mein aata hai. dt.days property is Timedelta ko integer days mein convert karti hai. pd.Timedelta() se specific time durations manually bhi create kar sakte hain.

🎯 Kyu Use Hota Hai: Employee tenure calculate karna, customer lifetime value period, order delivery time analysis, loan outstanding days, trial period remaining days — ye sabhi date difference calculations par depend karte hain. Yeh real-world data analysis ka sabse common date operation hai.

💡 Kab Use Hota Hai: HR analytics mein employee tenure, logistics mein delivery time SLA, banking mein loan overdue days, subscription mein days since signup, aur customer churn analysis mein days since last purchase calculate karne ke liye.

💻 Real-World Code Examples:

Example 1: Employees dataset mein joining date se aaj tak tenure (days aur years) calculate karna.

employees["JoiningDate"] = pd.to_datetime(employees["JoiningDate"])
today = pd.Timestamp.now()
employees["Tenure_Days"]  = (today - employees["JoiningDate"]).dt.days
employees["Tenure_Years"] = (employees["Tenure_Days"] / 365.25).round(1)
print(employees[["Name", "JoiningDate", "Tenure_Days", "Tenure_Years"]].head())

Example 2: E-commerce orders mein order date se delivery date tak actual delivery time calculate karna SLA compliance check ke liye.

ecommerce["OrderDate"]    = pd.to_datetime(ecommerce["OrderDate"])
ecommerce["DeliveryDate"] = pd.to_datetime(ecommerce["DeliveryDate"])
ecommerce["Delivery_Days"]  = (ecommerce["DeliveryDate"] - ecommerce["OrderDate"]).dt.days
ecommerce["SLA_Breached"]   = ecommerce["Delivery_Days"] > 7
print(f"SLA Breached Orders: {ecommerce['SLA_Breached'].sum()}")

📊 Expected Output:

# Employee Tenure:
# Name    JoiningDate  Tenure_Days  Tenure_Years
# Rahul   2020-03-15   1756         4.8
# Priya   2022-07-01   910          2.5

# SLA Compliance:
# SLA Breached Orders: 234  # Orders delivered after 7 days

✅ Best Practices — Data Insights Rulebook:

• Date difference ka result Timedelta hota hai — directly integer operations ke liye .dt.days lagana zaruri hai warna arithmetic errors aayenge.
• Years calculate karne ke liye 365.25 (leap year account karne ke liye) se divide karein, 365 nahi.
• Negative Timedelta values possible hain agar end date start date se pehle hai — always validate karein ki difference positive ho ya abs() lagayein.

💬 Crack the Interview:

🔍 Kya Hai: pd.date_range() ek specified start date se end date tak (ya n periods tak) evenly spaced datetime values ka sequence generate karta hai. Frequency parameter se daily, weekly, monthly, hourly — koi bhi interval set kar sakte hain.

🎯 Kyu Use Hota Hai: Real datasets mein missing dates hoti hain — agar kisi din koi transaction nahi hua toh woh date hi absent hogi. Continuous time-series analysis ke liye complete date sequence zaroori hai. date_range() se complete index banake missing dates fill kar sakte hain.

💡 Kab Use Hota Hai: Time-series forecasting mein complete date index banana, missing dates identify karna, test data generate karna, calendar-based reporting templates banana, aur scheduled report automation mein.

💻 Real-World Code Examples:

Example 1: 2024 ka complete daily date range banana aur sales data se missing dates identify karna.

# Complete 2024 date range generate karna
full_year = pd.date_range(start="2024-01-01", end="2024-12-31", freq="D")
full_df = pd.DataFrame({"Date": full_year})
# Sales data se merge karke missing dates dhundhna
ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
merged = full_df.merge(ecommerce.groupby("OrderDate")["Revenue"].sum().reset_index(),
                       left_on="Date", right_on="OrderDate", how="left")
missing_dates = merged[merged["Revenue"].isna()]
print(f"Missing Sales Dates: {len(missing_dates)}")

Example 2: Monthly business report template banana — har mahine ki 1 tarikh ka index.

monthly_index = pd.date_range(start="2024-01-01", periods=12, freq="MS")
# MS = Month Start frequency
report_template = pd.DataFrame({
    "Month": monthly_index,
    "Target_Revenue": [500000] * 12
})
print(report_template)

📊 Expected Output:

# Missing Sales Dates: 23  # 23 days with no orders in 2024

# Monthly Report Template:
# Month       Target_Revenue
# 2024-01-01  500000
# 2024-02-01  500000
# ...
# 2024-12-01  500000

✅ Best Practices — Data Insights Rulebook:

• Common frequency codes: 'D'=Daily, 'W'=Weekly, 'MS'=Month Start, 'ME'=Month End, 'QS'=Quarter Start, 'H'=Hourly, 'T'=Minutely. Inhe yaad rakhein.
• Business days only range ke liye freq='B' use karein jo weekends automatically skip karta hai.
• date_range() se generated index ko DataFrame ka index set karna time-series resampling operations ko bahut fast banata hai.

💬 Crack the Interview:

🔍 Kya Hai: dt.tz_localize() timezone-naive datetime column ko specific timezone assign karta hai (jaise 'Asia/Kolkata'). dt.tz_convert() ek timezone se doosre timezone mein convert karta hai. Dono milke global applications mein correct time handling ensure karte hain.

🎯 Kyu Use Hota Hai: Global applications (US, India, Europe servers) mein timestamps UTC mein store hote hain. Reports aur analysis ke liye local timezone mein convert karna zaroori hota hai. Galat timezone se peak hours analysis ya event timing sab galat ho jaata hai.

💡 Kab Use Hota Hai: International e-commerce platforms, global banking systems, multi-country HR databases, aur any application jahan multiple timezones ke users ho wahan timezone handling mandatory hai.

💻 Real-World Code Examples:

Example 1: UTC timestamps ko India Standard Time (IST) mein convert karna analysis ke liye.

bank["Timestamp"] = pd.to_datetime(bank["Timestamp"])
# Step 1: Assign UTC timezone (tz_localize)
bank["Timestamp_UTC"] = bank["Timestamp"].dt.tz_localize("UTC")
# Step 2: Convert to IST (tz_convert)
bank["Timestamp_IST"] = bank["Timestamp_UTC"].dt.tz_convert("Asia/Kolkata")
print(bank[["Timestamp_UTC", "Timestamp_IST"]].head())

Example 2: Multi-region e-commerce data mein different timezone timestamps ko unified UTC mein normalize karna.

# US orders are in EST timezone
ecommerce["OrderTime_EST"] = pd.to_datetime(ecommerce["OrderTime"]).dt.tz_localize("US/Eastern")
# Convert all to UTC for unified analysis
ecommerce["OrderTime_UTC"] = ecommerce["OrderTime_EST"].dt.tz_convert("UTC")
print(ecommerce[["OrderTime_EST", "OrderTime_UTC"]].head())

📊 Expected Output:

# Timezone Conversion (UTC to IST = +5:30):
# Timestamp_UTC              Timestamp_IST
# 2024-01-15 08:00:00+00:00  2024-01-15 13:30:00+05:30

# EST to UTC (EST = UTC-5):
# OrderTime_EST              OrderTime_UTC
# 2024-01-15 10:00:00-05:00  2024-01-15 15:00:00+00:00

✅ Best Practices — Data Insights Rulebook:

• Database mein hamesha UTC mein store karein, display ke time local timezone mein convert karein. Yeh global standard practice hai.
• tz_localize() sirf tab use karein jab timestamp timezone-naive ho. Already timezone-aware timestamps par tz_localize() error dega — pehle tz_localize(None) se strip karein.
• pytz library ki jagah Python 3.9+ ka built-in zoneinfo module ya dateutil use karein for better DST (Daylight Saving Time) handling.

💬 Crack the Interview:

🔍 Kya Hai: pd.to_datetime() mein errors='coerce' parameter add karne se invalid date strings (jaise "abc", "32-13-2024", "N/A") parse karne par error throw karne ki jagah unhe automatically NaT (Not a Time — datetime ka NaN equivalent) mein convert kar deta hai.

🎯 Kyu Use Hota Hai: Real-world datasets mein date columns frequently corrupted, inconsistent, ya missing values contain karte hain. Default behavior (errors='raise') se ek bhi invalid date par poori conversion fail ho jaati hai. errors='coerce' graceful degradation provide karta hai.

💡 Kab Use Hota Hai: User-entered date fields (forms se aaya data), legacy database migrations, third-party API data ingestion, aur any untrusted data source se date parsing karte waqt errors='coerce' standard practice hai.

💻 Real-World Code Examples:

Example 1: Customer registration data mein mixed valid/invalid dates handle karna aur invalid records count karna.

# Sample data with invalid dates
ecommerce["RegDate"] = pd.to_datetime(
    ecommerce["RegistrationDate"],
    errors="coerce"
)
# Count invalid/missing dates
invalid_count = ecommerce["RegDate"].isna().sum()
print(f"Invalid/Missing Dates: {invalid_count}")
# Filter only valid date records
valid_records = ecommerce[ecommerce["RegDate"].notna()]
print(f"Valid Records: {len(valid_records)}")

Example 2: Three error modes compare karke appropriate one choose karna.

# errors='raise'  -> Invalid date par immediately error throw karta hai (default)
# errors='coerce' -> Invalid dates ko NaT mein convert karta hai (production use)
# errors='ignore' -> Invalid dates ko as-is string rakhta hai (rarely used)

sample_dates = ["2024-01-15", "invalid_date", "2024-13-45", "2024-06-20"]
result = pd.to_datetime(sample_dates, errors="coerce")
print(result)

📊 Expected Output:

# Invalid/Missing Dates: 45
# Valid Records: 9955

# errors='coerce' result:
# DatetimeIndex(['2024-01-15', 'NaT', 'NaT', '2024-06-20'], dtype='datetime64[ns]')
# Invalid dates silently converted to NaT!

✅ Best Practices — Data Insights Rulebook:

• errors='coerce' ke baad hamesha NaT count check karein aur decide karein — drop karein, fill karein, ya flag karein. Silently NaT ignore mat karein.
• Production pipelines mein errors='coerce' use karein taaki ek invalid row poori pipeline fail na kare. Development mein errors='raise' se bugs dhundhein.
• NaT values ko filter karne ke liye df[df['date_col'].notna()] use karein — != NaT comparison kaam nahi karta.

💬 Crack the Interview:

🔍 Kya Hai: resample() time-series data ka groupby equivalent hai. Yeh datetime-indexed DataFrame ko specified time frequency mein bucket karke aggregate operations (sum, mean, count, etc.) apply karta hai. Daily data ko weekly ya monthly mein downsample kar sakte hain.

🎯 Kyu Use Hota Hai: Transaction-level data bahut granular hota hai — lakho rows daily. Business decisions ke liye weekly trends, monthly revenue, ya quarterly performance chahiye hoti hai. resample() yeh frequency conversion ek line mein kar deta hai.

💡 Kab Use Hota Hai: Financial time-series analysis, stock price OHLC calculation, website traffic hourly to daily aggregation, IoT sensor data compression, aur any scenario jahan granular data ko higher-level summaries mein convert karna ho.

💻 Real-World Code Examples:

Example 1: Daily transaction data ko monthly total revenue mein resample karna.

# Set datetime as index (resample ke liye zaruri)
ecommerce["OrderDate"] = pd.to_datetime(ecommerce["OrderDate"])
ecommerce_ts = ecommerce.set_index("OrderDate")
# Monthly revenue sum
monthly_revenue = ecommerce_ts["Revenue"].resample("ME").sum()
# Weekly average order value
weekly_avg = ecommerce_ts["Revenue"].resample("W").mean()
print(monthly_revenue)
print(weekly_avg.head())

Example 2: Bank transaction data se hourly transaction count aur sum nikalna fraud detection ke liye.

bank["Timestamp"] = pd.to_datetime(bank["Timestamp"])
bank_ts = bank.set_index("Timestamp")
hourly_stats = bank_ts["TransactionAmount"].resample("h").agg(["count", "sum", "mean"])
# Flag hours with unusually high transaction count
hourly_stats["Suspicious"] = hourly_stats["count"] > hourly_stats["count"].mean() * 3
print(hourly_stats[hourly_stats["Suspicious"]])

📊 Expected Output:

# Monthly Revenue:
# OrderDate
# 2024-01-31    1250000
# 2024-02-29    980000
# 2024-03-31    1450000

# Suspicious Hours (3x above average):
# Timestamp           count    sum        mean
# 2024-01-15 02:00    892      4500000    5045.41  # Possible fraud!

✅ Best Practices — Data Insights Rulebook:

• resample() ke liye DataFrame mein datetime column index hona zaroori hai — pehle set_index() karo. Warna TypeError aayega.
• Downsampling (daily to monthly) mein sum/mean use karein context ke basis par. Upsampling (daily to hourly) mein fillna() ya interpolate() se missing values fill karein.
• Multiple aggregations ke liye .agg(['sum', 'mean', 'count']) use karein ek hi resample call mein.

💬 Crack the Interview:

🔍 Kya Hai: dt.normalize() timestamp column ke time component ko midnight (00:00:00) par set kar deta hai jabki date part unchanged rehta hai. Result datetime64 dtype mein hota hai (dt.date ki tarah Python date object nahi), isliye aage datetime operations continue kar sakte hain.

🎯 Kyu Use Hota Hai: Jab do datetime columns ko date-level par compare karna ho ya merge karna ho, toh time difference (14:30 vs 15:45) comparison ko fail kar deta hai. normalize() dono columns ke time parts ko 00:00:00 karke date-only comparison enable karta hai.

💡 Kab Use Hota Hai: Date-level join operations, same-day event matching, daily aggregation keys banana, aur jab timestamp data ko date granularity par standardize karna ho tab normalize() sabse clean solution hai.

💻 Real-World Code Examples:

Example 1: Order timestamp aur delivery timestamp ko normalize karke same-day delivery orders identify karna.

ecommerce["OrderDate"]    = pd.to_datetime(ecommerce["OrderTimestamp"])
ecommerce["DeliveryDate"] = pd.to_datetime(ecommerce["DeliveryTimestamp"])
# Normalize both to midnight for date-only comparison
ecommerce["Order_Day"]    = ecommerce["OrderDate"].dt.normalize()
ecommerce["Delivery_Day"] = ecommerce["DeliveryDate"].dt.normalize()
same_day = ecommerce[ecommerce["Order_Day"] == ecommerce["Delivery_Day"]]
print(f"Same-Day Deliveries: {len(same_day)}")

Example 2: Bank transactions ko normalize karke date-level groupby aur daily summary banana.

bank["Timestamp"] = pd.to_datetime(bank["Timestamp"])
bank["Date_Only"] = bank["Timestamp"].dt.normalize()
daily_summary = bank.groupby("Date_Only").agg(
    Total_Transactions=("TransactionID", "count"),
    Total_Amount=("TransactionAmount", "sum"),
    Avg_Amount=("TransactionAmount", "mean")
).reset_index()
print(daily_summary.head())

📊 Expected Output:

# Same-Day Deliveries: 1245  # Express delivery orders

# Daily Bank Summary:
# Date_Only   Total_Transactions  Total_Amount  Avg_Amount
# 2024-01-15  892                 4500000       5045.41
# 2024-01-16  756                 3800000       5026.46

✅ Best Practices — Data Insights Rulebook:

• dt.normalize() datetime64 return karta hai jo dt.date (Python date object) se alag hai — aage datetime operations ke liye normalize() prefer karein, display ke liye dt.date use karein.
• Timezone-aware timestamps par normalize() correctly kaam karta hai — time midnight par set hoga local timezone ke hisaab se.
• Date-based merge operations se pehle dono DataFrames ke date columns normalize karein — isse time mismatch ki wajah se failed joins avoid hote hain.

💬 Crack the Interview:

Apne date/time requirement ke basis par sahi function chunye:

Next Post Preview: Masterclass Part 6

Next masterclass mein hum cover karenge: Advanced Logic Functions — np.where(), np.select(), cut(), qcut() aur complex conditional operations ko real datasets par apply karna.

Happy Coding & Stay Analytically Pure! 🚀