Day 8 — Pandas Data Cleaning (Missing data & Duplicates)

यह पूरा static, Blogger-friendly chapter है — हर section में theory + explaination + Python (pandas) code snippets + expected output tables दिए गए हैं, ताकि आप इसको सीधे अपने ब्लॉग में paste कर के पढ़ा/प्रशिक्षित कर सकें।

नोट: यह Static HTML है — मैंने interactive (Pyodide) script हटा दी है ताकि Blogger जैसे प्लेटफ़ॉर्म पर बिना external scripts के भी यह सही से दिखे।

सैद्धान्तिक परिचय — Pandas Data Cleaning क्या है?

पाइथन में pandas एक शक्तिशाली लाइब्रेरी है जिसका प्रयोग table-like data (DataFrame) के साथ किया जाता है।Data Cleaning का मतलब है: raw/real-world datasets में आने वाली गलतियों और inconsistencies को ठीक करना ताकि analysis, visualization और machine learning models पर भरोसा किया जा सके।

Missing values (NaN, None, blanks): detect करने के लिए isnull(), हटाने के लिए dropna(), भरने के लिए fillna().
Duplicates: duplicate rows या duplicate identifiers — detect करने के लिए duplicated(), हटाने के लिए drop_duplicates().
Consistency: data types सही करना (astype()), strings clean करना (str.strip(), lower/upper), और invalid values को replace करना।

एक स्पष्ट उदाहरण: यदि sales data में कुछ rows की price missing है, तो total revenue गलत निकलेगा; या यदि एक customer की रिकॉर्ड duplicate है तो analysis में overcount होगा।

क्यों सीखना चाहिए? (Importance)

Real-world data कभी भी perfect नहीं होता — cleaning जरूरी है।
Dirty data से गलत insights और गलत business decisions हो सकते हैं।
Machine learning models clean data पर ही सही सीखते हैं — missing/duplicate data accuracy घटाते हैं।
प्रैक्टिकल data scientist बनने के लिए यह सबसे पहली skill है।
Data cleaning से reporting, visualization और storage बेहतर होते हैं।

कहाँ और कैसे इस्तेमाल करेंगे?

Data cleaning हर जगह काम आता है — e-commerce, banking, healthcare, survey data, education आदि। सामान्य workflow:

Data load: pd.read_csv(), pd.read_excel()
Inspect: shape, head(), info(), describe(), missing counts (isnull().sum())
Handle missing: drop या fill (mean/median/0/forward-fill/ custom)
Handle duplicates: identify using duplicated() और drop_duplicates()
Data type conversions, trimming strings, replace invalid values
Final check और save

अब आपके हर प्रश्न के विस्तृत जवाब — हर एक के 5 उदाहरण (Step-by-step + code + expected output)

Q1: "Pandas Data Cleaning क्या है?" — 5 Examples

नीचे हर example छोटे dataframes के साथ दिखाया गया है — code पढ़िए और उसके नीचे expected output table मौजूद है ताकि beginner भी समझ सके कि क्या होता है।

Example 1 — Missing values detection (identify करना)

import pandas as pd

df = pd.DataFrame({ 'Name': ['Amit', 'Ravi', 'Sita', None], 'Age': [25, None, 30, 28] })

missing counts

print(df) print(' Missing counts:') print(df.isnull().sum())

Expected output (table):

Name	Age
Amit	25.0
Ravi
Sita	30.0
	28.0

Missing counts: Name: 1, Age: 1 — यह बताता है किन columns में NaN है।

Example 2 — Fill missing with mean

# same df as above

fill missing age with mean age

mean_age = df['Age'].mean() df['Age'] = df['Age'].fillna(mean_age) print(df)

Expected: Age column के missing को average से replace कर देंगे; Name का missing अभी भी रहेगा अगर हम उसे drop/replace नहीं करते।

Example 3 — Drop missing rows

# drop any row with at least one NaN

clean = df.dropna() print(clean)

Expected: वो सारी rows हटेंगी जिनमें कोई NaN है — केवल fully complete rows बचेंगी।

Example 4 — Detect duplicates

df2 = pd.DataFrame({'id':[1,1,2,3],'val':[10,10,20,30]})

print(df2) print('duplicated mask:') print(df2.duplicated())

Expected: duplicated() boolean series देगा — True वहां जहां same row पहले आ चुका है।

Example 5 — Remove duplicates

df2_unique = df2.drop_duplicates()

print(df2_unique)

Expected: duplicate row remove हो जाएगी और unique rows बचेंगी।

Q2: Pandas Data Cleaning का Use क्या है? — 5 Examples

Use-cases छोटे real-world contexts में — हर एक के साथ code + expected result:

Example 1 — Sales dataset: missing price -> fill with mean price

df_sales = pd.DataFrame({'product':['A','B','C','D'],'price':[100, None, 150, None]})

fill missing

df_sales['price'] = df_sales['price'].fillna(df_sales['price'].mean()) print(df_sales)

Expected: B और D की price average से replace हो जाएगी — जिससे total revenue calculate करना meaningful होगा।

Example 2 — Hospital: duplicate patient records हटाना

df_pat = pd.DataFrame({'patient_id':[101,102,101,103],'name':['R','S','R','T'],'age':[30,25,30,40]})

remove duplicates based on patient_id

df_pat_unique = df_pat.drop_duplicates(subset=['patient_id']) print(df_pat_unique)

Expected: patient_id 101 duplicate entry remove होगी — accurate patient count मिलेगा।

Example 3 — School: missing marks -> fill with 0 (absent)

df_marks = pd.DataFrame({'student':['A','B','C'],'marks':[80, None, 90]})

df_marks['marks'] = df_marks['marks'].fillna(0) print(df_marks)

Expected: B का marks 0 set होगा, जिससे class average calculate करना straightforward होगा।

Example 4 — Banking: missing transaction amounts -> drop those rows

df_tx = pd.DataFrame({'tx_id':[1,2,3,4],'amount':[200,None,500,None]})

df_tx_clean = df_tx.dropna(subset=['amount']) print(df_tx_clean)

Expected: केवल valid transactions रहेंगी; null amounts ignore हो जाएँगी।

Example 5 — E-commerce: duplicate orders remove by order_id

df_orders = pd.DataFrame({'order_id':[1001,1002,1001,1003],'customer':['X','Y','X','Z'],'value':[500,300,500,400]})

df_orders = df_orders.drop_duplicates(subset=['order_id']) print(df_orders)

Expected: duplicate order 1001 remove — correct order count और total revenue मिलेगी।

Q3: इसे क्यों सीखना चाहिए? (5 Examples — consequences of NOT cleaning)

यहाँ हम दिखाएँगे की अगर data clean न किया जाए तो क्या गलत होगा (simple, clear examples)।

Example 1 — Missing values change statistics (mean wrong)

df = pd.DataFrame({'val':[10, None, 30]})

print('mean (skips NaN):', df['val'].mean())

अगर हम NaN को 0 मानकर add करें तो result बदलेगा

print('sum skipping NaN:', df['val'].sum())

Explanation: Statistics calculation default behavior NaN के साथ अलग होती है — अगर logically NaN को 0 मानना है तो fillna(0) करें, वरना leave करें।

Example 2 — Duplicates cause overcount

dfdup = pd.DataFrame({'item':['A','A','B'],'qty':[1,1,2]})

print('rows before:', len(dfdup)) print(dfdup) dfdup2 = dfdup.drop_duplicates() print('rows after:', len(dfdup2))

Explanation: Duplicate rows होने से aggregates (जैसे total items) गलत होंगे।

Example 3 — Arithmetic with NaN propagates NaN

dfA = pd.DataFrame({'a':[1, None, 3]})

print((dfA['a'] + 2).tolist())

Explanation: NaN arithmetic में रहे तो final results में NaN आ सकते हैं — preprocessing में fill या drop करना चाहिए।

Example 4 — Healthcare: duplicate patient distorts counts

df_pat = pd.DataFrame({'pid':[1,2,1,3]})

print('unique patients:', df_pat['pid'].nunique()) print('rows before:', len(df_pat)) print(df_pat.drop_duplicates())

Explanation: Duplicate patient rows से patient count और per-patient stats गलत होंगे।

Example 5 — Survey completeness percent

df_s = pd.DataFrame({'q1':[1,None,0], 'q2':[None,1,1]})

print('overall completeness (%) =', df_s.notnull().mean().mean()*100)

Explanation: अगर completeness कम है तो survey results reliable नहीं होंगे — cleaning और imputation कैसे करेंगे यह design decision है।

Q4: इसे कहाँ और कैसे use करेंगे? (5 Practical examples)

Small, real preprocessing patterns जो आप data pipelines में बार-बार देखेंगे:

Example 1 — E-commerce: dedupe customer table for recommender

df = pd.DataFrame({'cust_id':[1,2,1,3],'visits':[5,2,5,1]})

dedupe keeping first

df_u = df.drop_duplicates(subset=['cust_id']) print(df_u)

Use: Recommendation models per-user stats बनाते समय duplicate rows problem होगा — dedupe करके fix करें।

Example 2 — Banking: remove null transaction amounts before fraud model

df = pd.DataFrame({'tx':[1,2,3],'amt':[100,None,200]})

df_clean = df.dropna(subset=['amt']) print(df_clean)

Use: ML model को numeric amount चाहिए — null rows मॉडल में confuse करेंगी।

Example 3 — Healthcare: impute missing age with median

df = pd.DataFrame({'pid':[1,2,3],'age':[25,None,45]})

df['age'] = df['age'].fillna(df['age'].median()) print(df)

Use: Median imputation outliers से कम प्रभावित होता है।

Example 4 — Education: forward-fill attendance for continuous days

df = pd.DataFrame({'day':[1,2,3,4],'present':[1,None,None,1]})

df['present'] = df['present'].fillna(method='ffill') print(df)

Use: Continuous time-series में forward/backward fill practical होता है।

Example 5 — Govt survey: drop respondents with too many blanks

df = pd.DataFrame({'r':[1,2,3],'a':[1,None,None],'b':[None,2,None],'c':[3,4,None]})

keep rows with fewer than 2 blanks

df_clean = df[df.isnull().sum(axis=1) < 2] print(df_clean)

Use: Low-quality respondents remove करके overall dataset quality improve करें।

Q5: इसे क्यों use करना चाहिए? (5 Examples — benefits)

Benefits को छोटे उदाहरणों में दिखा रहे हैं:

Example 1 — Stable statistics after cleaning

df = pd.DataFrame({'v':[10,None,30,40]})

df2 = df.copy() df2['v'] = df2['v'].fillna(df2['v'].mean()) print('mean before:', df['v'].mean()) print('mean after:', df2['v'].mean()) print(df2)

Benefit: Imputation से statistics consistent होंगे — reporting reliable बनेगा।

Example 2 — Remove duplicates saves rows and storage

df = pd.DataFrame({'id':[1,1,2,3]})

print('before rows:', len(df)) df_u = df.drop_duplicates() print('after rows:', len(df_u))

Benefit: Deduplication से storage गिरेगा और analysis सही होगा।

Example 3 — Arithmetic works after fill

df = pd.DataFrame({'a':[1,None,3]})

res = (df['a'].fillna(0) + 2).tolist() print(res)

Benefit: Calculations predictable होंगी; NaN से unexpected errors नहीं आएँगे।

Example 4 — Visualization ready (no gaps)

df = pd.DataFrame({'x':[1,2,3],'y':[10,None,30]})

df['y'] = df['y'].fillna(method='ffill') print(df)

Benefit: Visual plots में gaps नहीं दिखेंगे — trends साफ दिखेंगे।

Example 5 — Business totals correct

df = pd.DataFrame({'sale':[100,None,200]})

print('sum default (NaN ignored):', df['sale'].sum()) df['sale'] = df['sale'].fillna(0) print('sum after fillna(0):', df['sale'].sum())

Benefit: Total sales calc करने के लिए NaN को 0 मानना जरूरी हो सकता है — cleaning से business metrics सही मिलेंगे।

📘 Day 8: Pandas Data Cleaning (Missing Data & Duplicates) - python in ml and data scientist