Exploratory Data Analysis (EDA) with Pandas

What Is Exploratory Data Analysis (EDA)? 🔍Exploratory Data Analysis (EDA) क्या है? 🔍什么是探索性数据分析（EDA）？🔍

EDA is the first thing you do with a new dataset, before any model or conclusion. Before you can trust data, you must understand it: its size, its types, its gaps, its odd values, and the patterns inside it.

EDA वह पहला काम है जो आप नए dataset के साथ करते हैं, किसी model या निष्कर्ष से पहले। Data पर भरोसा करने से पहले उसे समझना ज़रूरी है: उसका आकार, types, कमियाँ, अजीब मान, और अंदर छिपे patterns।

EDA 是拿到新数据集后的第一件事，先于任何模型或结论。要信任数据，先得理解它：规模、类型、缺口、异常值以及其中的规律。

EDA is a mindset more than a checklist: ask questions, look from several angles, and let the data surprise you. The statistician John Tukey made the idea popular with his 1977 book Exploratory Data Analysis, and compared it to detective work — you look for clues before you try to prove anything.

EDA checklist से ज़्यादा एक सोच है: सवाल पूछें, कई कोणों से देखें, और data को आपको चौंकाने दें। Statistician John Tukey ने अपनी 1977 की किताब Exploratory Data Analysis से यह विचार लोकप्रिय किया, और इसे जासूसी जैसा काम कहा — कुछ साबित करने से पहले आप सुराग ढूँढते हैं।

EDA 与其说是清单，不如说是一种思维方式：多提问，从多个角度看，让数据给你惊喜。统计学家约翰·图基在 1977 年的著作《探索性数据分析》中推广了这一思想，并把它比作侦探工作 —— 在证明任何东西之前，先寻找线索。

The EDA Pipeline — Step by StepEDA Pipeline — क़दम दर क़दमEDA 流程 — 一步一步

Reading the DatasetDataset पढ़ना读取数据集

Setting Upतैयारी准备工作

import pandas as pd
import numpy as np

# Optional display settings
pd.set_option("display.max_columns", 50)
pd.set_option("display.float_format", "{:.2f}".format)

Reading Different File Formatsअलग-अलग File Formats पढ़ना读取不同的文件格式

# CSV, parsing dates and loading only the columns you need
df = pd.read_csv("orders.csv", parse_dates=["order_date"], usecols=["order_date", "city", "amount"])

# Tab-separated file
df = pd.read_csv("data.tsv", sep="\t")

# A file too big for memory: summarise each chunk, keep only the small results
totals = []
for chunk in pd.read_csv("huge.csv", chunksize=100_000):
    totals.append(chunk.groupby("city")["amount"].sum())
city_totals = pd.concat(totals).groupby(level=0).sum()

# Excel sheet
df = pd.read_excel("report.xlsx", sheet_name="Q3_Sales")

# SQL with a safe parameter (never paste user input into the SQL string)
import sqlite3
with sqlite3.connect("mydb.db") as conn:
    df = pd.read_sql("SELECT * FROM customers WHERE country = ?", conn, params=("India",))

# Parquet, only two columns
df = pd.read_parquet("data.parquet", columns=["age", "income"])

Our Practice Dataset — With Real Problems Plantedहमारा Practice Dataset — असली समस्याओं के साथ我们的练习数据集 — 预埋真实问题

Every output on this page comes from one dataset: 10,000 online orders from 2024, plus 25 duplicate rows. Like real data, it has problems hidden inside: missing ages, ratings and cities; "Female" and "female" as two different labels; four impossible delivery times; and a very skewed purchase amount. Run this code once to create sales_data.csv and follow along.

इस page का हर output एक ही dataset से है: 2024 के 10,000 online orders, और 25 duplicate rows। असली data की तरह इसमें छिपी समस्याएँ हैं: ग़ायब ages, ratings और cities; "Female" और "female" दो अलग labels; चार असंभव delivery समय; और बहुत skewed purchase amount। sales_data.csv बनाने के लिए यह code एक बार चलाएँ और साथ चलें।

本页所有输出都来自同一个数据集：2024 年的 10,000 笔网购订单，外加 25 行重复。和真实数据一样，里面藏着问题：缺失的年龄、评分和城市；“Female”和“female”被当作两个标签；四个不可能的配送天数；以及严重偏态的消费金额。运行一次这段代码生成 sales_data.csv，然后跟着做。

# 0) Build the practice dataset used in this tutorial (with real-world problems planted in it)
import numpy as np, pandas as pd
rng = np.random.default_rng(7)
n = 10_000
cats = ["Electronics", "Furniture", "Clothing", "Books", "Grocery"]
base = {"Electronics": 9.2, "Furniture": 8.8, "Clothing": 8.1, "Books": 7.1, "Grocery": 6.2}
cat = rng.choice(cats, n, p=[.15, .10, .30, .20, .25])
df = pd.DataFrame({
    "customer_id": np.arange(1001, 1001 + n),
    "age": rng.normal(34, 10, n).clip(18, 70).round(),
    "gender": rng.choice(["Male", "Female", "female", "Other"], n, p=[.48, .44, .05, .03]),
    "city": rng.choice(["Delhi", "Mumbai", "Pune", "Chandigarh", "Shimla"], n),
    "product_category": cat,
    "purchase_amount": np.round(np.exp(rng.normal([base[c] for c in cat], 0.6)), 2),
    "order_date": pd.date_range("2024-01-01", periods=366).strftime("%Y-%m-%d").to_numpy()[rng.integers(0, 366, n)],
    "rating": rng.choice([1, 2, 3, 4, 5], n, p=[.05, .08, .2, .37, .3]).astype(float),
    "delivery_days": rng.integers(1, 11, n),
})
df.loc[rng.choice(n, 157, replace=False), "age"] = np.nan          # missing ages
df.loc[rng.choice(n, 280, replace=False), "rating"] = np.nan       # missing ratings
df.loc[rng.choice(n, 9, replace=False), "city"] = np.nan           # missing cities
df.loc[rng.choice(n, 4, replace=False), "delivery_days"] = 200      # impossible values
df = pd.concat([df, df.sample(25, random_state=1)], ignore_index=True)  # 25 duplicate rows
df.to_csv("sales_data.csv", index=False)
print("saved", df.shape)

Understanding the Structureढाँचे को समझना理解结构

Once the data is loaded, get oriented: how big is it, what are the columns, and are the types what you expect? .info() answers most of this in one call.

Data load होने के बाद दिशा पकड़ें: यह कितना बड़ा है, columns क्या हैं, और क्या types वैसे हैं जैसी उम्मीद थी? .info() एक call में इसका ज़्यादातर जवाब देता है।

数据读入后先摸清情况：有多大？有哪些列？类型是否符合预期？.info() 一次调用就能回答大部分问题。

# 1) Load and get oriented
import pandas as pd
df = pd.read_csv("sales_data.csv")
print(df.shape)
print(df.sample(3, random_state=42))
df.info()

Data Types in PandasPandas में Data TypesPandas 中的数据类型

Every column has a dtype. It decides how values are stored, how much memory they use, and which operations work. Fixing dtypes is one of the most useful steps in EDA.

हर column का एक dtype होता है। यह तय करता है कि मान कैसे रखे जाएँ, कितनी memory लगे, और कौन-से operations चलें। dtypes ठीक करना EDA के सबसे काम के steps में से एक है।

每列都有一个 dtype。它决定值如何存储、占多少内存、能做哪些运算。修正 dtype 是 EDA 中最有用的步骤之一。

# 2) Fix data types and measure the memory saving
import pandas as pd
df = pd.read_csv("sales_data.csv")
before = df.memory_usage(deep=True).sum()

df["order_date"] = pd.to_datetime(df["order_date"])
for col in ["gender", "city", "product_category"]:
    df[col] = df[col].astype("category")
df["delivery_days"] = df["delivery_days"].astype("int32")

after = df.memory_usage(deep=True).sum()
print(df.dtypes)
print(f"memory: {before/1e6:.2f} MB -> {after/1e6:.2f} MB ({(1 - after/before)*100:.0f}% smaller)")
print(df["gender"].value_counts())          # spot the problem!

Identifying Missing DataMissing Data पहचानना识别缺失数据

pandas marks missing values as NaN (numbers), NaT (dates) or NA (nullable types). Before computing statistics, find out how much is missing and, just as important, why.

pandas ग़ायब मानों को NaN (संख्याएँ), NaT (dates) या NA (nullable types) से दिखाता है। Statistics निकालने से पहले पता करें कि कितना ग़ायब है और, उतना ही ज़रूरी, क्यों।

pandas 用 NaN（数值）、NaT（日期）或 NA（可空类型）标记缺失值。计算统计量之前，要弄清缺了多少，同样重要的是为什么缺。

# 3) Missing values: count, percent, and how pandas treats NaN
import numpy as np, pandas as pd
df = pd.read_csv("sales_data.csv")
miss = df.isnull().sum()
pct = (df.isnull().mean() * 100).round(2)
print(pd.DataFrame({"missing": miss, "%": pct})[miss > 0])

print("pandas mean (skips NaN):", round(df["rating"].mean(), 3))
print("numpy mean (NaN spreads):", np.mean(df["rating"].to_numpy()))
print("rows actually used:", df["rating"].count(), "of", len(df))

Summary StatisticsSummary Statistics汇总统计

Summary statistics squeeze a whole column into a few numbers about its centre, spread and shape. They tell you what to expect before you draw any chart.

Summary statistics पूरे column को कुछ संख्याओं में समेट देते हैं: उसका केंद्र, फैलाव और आकार। कोई chart बनाने से पहले ये बताते हैं कि क्या उम्मीद करें।

汇总统计把一整列压缩成几个数字，描述它的中心、离散程度和形状。在画图之前，它们就告诉你该期待什么。

describe(), skew and groupby on Our Dataहमारे Data पर describe(), skew और groupby在我们的数据上运行 describe()、skew 和 groupby

# 4) Summary statistics, skew, and grouped statistics
import pandas as pd
df = pd.read_csv("sales_data.csv").drop_duplicates()
print(df[["purchase_amount", "age", "rating", "delivery_days"]].describe().round(2))
print("\nskew of purchase_amount:", round(df["purchase_amount"].skew(), 2))
print("\nmean purchase by category:")
print(df.groupby("product_category")["purchase_amount"].agg(["mean", "median", "count"])
        .sort_values("mean", ascending=False).round(0))

Grouped StatisticsGrouped Statistics分组统计

Overall numbers rarely tell the full story. The category table above shows Electronics orders average ₹11,821 while Grocery orders average ₹572 — a 20× difference hidden inside the single overall mean. .groupby() works in three steps: split the rows into groups, apply a function to each group, and combine the results.

कुल संख्याएँ शायद ही पूरी कहानी बताती हैं। ऊपर की category table में Electronics orders का औसत ₹11,821 है जबकि Grocery का ₹572 — एक कुल mean में छिपा 20 गुना अंतर। .groupby() तीन steps में काम करता है: rows को groups में बाँटें, हर group पर function लगाएँ, और नतीजे जोड़ें।

总体数字很少能说明全部。上面的类别表显示：电子产品订单平均 ₹11,821，而杂货订单平均 ₹572 —— 一个总体均值里藏着 20 倍的差距。.groupby() 分三步：把行拆分成组，对每组应用函数，再把结果合并。

# Several statistics per group
df.groupby("gender")["purchase_amount"].agg(["mean", "median", "count"])

# Two grouping columns -> a table
df.groupby(["city", "product_category"])["purchase_amount"].median().unstack()

# Correlation between numeric columns
df.corr(numeric_only=True).round(2)

Detecting OutliersOutliers पहचानना检测异常值

An outlier is a value far from the bulk of the data. It may be a real extreme (a huge order), a data-entry error (200 delivery days), or a measurement fault. EDA should find them; deciding what to do needs domain knowledge.

Outlier ऐसा मान है जो ज़्यादातर data से दूर हो। यह असली अति हो सकता है (बहुत बड़ा order), data-entry की ग़लती (200 delivery दिन), या माप की गड़बड़ी। EDA को इन्हें ढूँढना चाहिए; क्या करना है, यह तय करने के लिए domain की समझ चाहिए।

异常值是远离大部分数据的值。它可能是真实的极端值（巨额订单）、录入错误（配送 200 天）或测量故障。EDA 负责发现它们；如何处理需要领域知识。

# 5) Outliers: IQR fences, z-score and modified z-score
import numpy as np, pandas as pd
df = pd.read_csv("sales_data.csv").drop_duplicates()

def iqr_outliers(s, k=1.5):
    q1, q3 = s.quantile([.25, .75])
    lo, hi = q1 - k * (q3 - q1), q3 + k * (q3 - q1)
    return s[(s < lo) | (s > hi)], lo, hi

for col in ["delivery_days", "purchase_amount"]:
    s = df[col].dropna()
    out, lo, hi = iqr_outliers(s)
    z = (s - s.mean()) / s.std()
    mad = (s - s.median()).abs().median()
    mz = 0.6745 * (s - s.median()) / mad
    print(f"{col}: fences [{lo:.1f}, {hi:.1f}] -> IQR flags {len(out)}, "
          f"|z|>3 flags {(z.abs() > 3).sum()}, modified-z>3.5 flags {(mz.abs() > 3.5).sum()}")
print("largest delivery_days:", sorted(df['delivery_days'].unique())[-3:])

A Reusable EDA Reportदोबारा इस्तेमाल लायक़ EDA Report可复用的 EDA 报告

Paste this function into your notebook and pass any DataFrame. It works on pandas 2 and 3. Here is its real output on our dataset — every planted problem shows up.

यह function अपनी notebook में डालें और कोई भी DataFrame दें। यह pandas 2 और 3 दोनों पर चलता है। हमारे dataset पर इसका असली output यह है — हर डाली गई समस्या दिखती है।

把这个函数粘贴到你的笔记本中，传入任意 DataFrame 即可。它在 pandas 2 和 3 上都能运行。下面是它在我们数据集上的真实输出 —— 每个预埋问题都暴露了。

# 6) A compact, reusable EDA report
import pandas as pd

def run_eda(df, name="Dataset"):
    print(f"== EDA REPORT: {name} ==")
    print(f"[1] shape: {df.shape[0]:,} rows x {df.shape[1]} columns")
    miss = df.isnull().mean().mul(100).round(2)
    print("[2] missing %:", miss[miss > 0].to_dict())
    print(f"[3] duplicate rows: {df.duplicated().sum()}")
    num = df.select_dtypes("number")
    print("[4] min / max:")
    print(num.agg(["min", "max"]).T.to_string())
    skew = num.skew().round(2)
    print("[5] |skew| > 1:", skew[skew.abs() > 1].to_dict())
    for col in df.select_dtypes(exclude=["number", "datetime"]).columns:   # text + category (pandas 2 and 3)
        print(f"[6] {col}: {df[col].nunique()} unique, top = {df[col].value_counts().head(3).to_dict()}")

run_eda(pd.read_csv("sales_data.csv"), "Sales 2024")

Golden Rules of EDAEDA के सुनहरे नियमEDA 黄金法则