Data Collection in Data Science

What Is Data Collection? 📥Data Collection क्या है? 📥什么是数据收集？📥

Data collection is the planned process of gathering raw information so it can be stored, cleaned and analysed. It is the first stage of every data science project — and often the most important. However powerful your model, your results can only be as good as the data you collected.

Data collection, कच्ची जानकारी को योजना के साथ जुटाने की प्रक्रिया है, ताकि उसे रखा, साफ़ किया और analyse किया जा सके। यह हर data science project का पहला चरण है — और अक्सर सबसे ज़रूरी। आपका model कितना भी ताक़तवर हो, नतीजे उतने ही अच्छे होंगे जितना अच्छा data आपने जुटाया।

数据收集是有计划地获取原始信息，以便存储、清洗和分析的过程。它是每个数据科学项目的第一步 —— 往往也是最重要的一步。模型再强大，结果也只能和你收集的数据一样好。

Primary vs Secondary Data 🧭Primary बनाम Secondary Data 🧭一手数据 vs 二手数据 🧭

Before choosing a tool, decide whether you will collect new data yourself (primary) or reuse data someone else collected (secondary). Most projects mix both.

Tool चुनने से पहले तय करें कि आप नया data ख़ुद जुटाएँगे (primary) या किसी और का जुटाया data इस्तेमाल करेंगे (secondary)। ज़्यादातर projects दोनों मिलाते हैं।

选工具之前，先决定是自己收集新数据（一手）还是复用别人收集的数据（二手）。大多数项目两者兼用。

Source 1 — Databases 🗄️Source 1 — Databases 🗄️来源 1 — 数据库 🗄️

Databases are the most common source inside companies. Sales, users, payments and logs usually live in relational tables queried with SQL (Structured Query Language). There are two main families:

Companies के अंदर databases सबसे आम source हैं। Sales, users, payments और logs आम तौर पर relational tables में रहते हैं जिन्हें SQL (Structured Query Language) से query किया जाता है। दो मुख्य परिवार हैं:

数据库是公司内部最常见的数据来源。销售、用户、支付和日志通常存放在关系型表中，用 SQL（结构化查询语言）查询。主要有两大类：

Source 2 — APIs 🔌Source 2 — APIs 🔌来源 2 — API 🔌

An API (Application Programming Interface) lets your code ask another service for data over the internet. The service replies — usually in JSON, sometimes XML — and your code parses and stores the reply.

API (Application Programming Interface) आपके code को internet पर किसी दूसरी service से data माँगने देता है। Service जवाब देती है — आम तौर पर JSON में, कभी-कभी XML में — और आपका code उसे parse करके रखता है।

API（应用程序编程接口）让你的代码通过互联网向另一个服务请求数据。服务返回响应 —— 通常是 JSON，有时是 XML —— 你的代码解析并保存它。

Source 3 — Flat Files (CSV, Excel, JSON, Parquet) 📄Source 3 — Flat Files (CSV, Excel, JSON, Parquet) 📄来源 3 — 平面文件（CSV、Excel、JSON、Parquet）📄

Files are the simplest and most universal way to share data. Clients, government portals and researchers often send data as file dumps.

Files, data share करने का सबसे सरल और सबसे आम तरीका हैं। Clients, सरकारी portals और researchers अक्सर data files के रूप में भेजते हैं।

文件是共享数据最简单、最通用的方式。客户、政府门户和研究人员常常以文件形式提供数据。

Source 4 — Web Scraping 🕸️Source 4 — Web Scraping 🕸️来源 4 — 网页抓取 🕸️

When a website shows data but offers no API, you can write code that downloads the page's HTML and pulls out the parts you need. This is web scraping.

जब website data दिखाती है पर कोई API नहीं देती, तो आप ऐसा code लिख सकते हैं जो page का HTML download करे और ज़रूरी हिस्से निकाले। यही web scraping है।

当网站展示了数据却没有提供 API 时，你可以写代码下载页面的 HTML 并提取所需部分。这就是网页抓取。

Source 5 — Kaggle & Open Dataset Platforms 📚Source 5 — Kaggle और Open Dataset Platforms 📚来源 5 — Kaggle 与开放数据平台 📚

For learning, prototypes and competitions, curated platforms offer ready-to-use datasets. Always read each dataset's description and licence before use.

सीखने, prototypes और competitions के लिए curated platforms तैयार datasets देते हैं। इस्तेमाल से पहले हर dataset का विवरण और licence ज़रूर पढ़ें।

用于学习、原型和竞赛时，精选平台提供现成的数据集。使用前务必阅读每个数据集的说明和许可。

Who Is in Your Data? — Sampling Bias 🎯आपके Data में कौन है? — Sampling Bias 🎯你的数据里有谁？— 抽样偏差 🎯

The Story: The Biggest Poll That Got It Wrongकहानी: सबसे बड़ा poll जो ग़लत निकला故事：规模最大却预测失败的民调

In 1936 the American magazine The Literary Digest mailed about 10 million ballots before the US presidential election and got 2.38 million back. It predicted that Alf Landon would beat Franklin Roosevelt with 57% of the vote. Roosevelt won with 60.8%. George Gallup, using about 50,000 people chosen with care, predicted a Roosevelt win.

1936 में अमेरिकी पत्रिका The Literary Digest ने राष्ट्रपति चुनाव से पहले लगभग 1 करोड़ ballots भेजे और 23.8 लाख वापस मिले। उसने अनुमान लगाया कि Alf Landon 57% वोट से Franklin Roosevelt को हराएँगे। Roosevelt 60.8% से जीते। George Gallup ने सोच-समझकर चुने लगभग 50,000 लोगों से Roosevelt की जीत का सही अनुमान लगाया।

1936 年美国总统大选前，《文学文摘》杂志寄出约 1,000 万张选票，收回 238 万张。它预测兰登将以 57% 的得票率击败罗斯福。结果罗斯福以 60.8% 获胜。乔治·盖洛普用精心挑选的约 5 万人，正确预测了罗斯福获胜。

What went wrong? The Digest's list came largely from its readers and from car and telephone owners — groups richer than average during the Great Depression. And people who disliked Roosevelt were more likely to send the ballot back (non-response bias). Size did not fix bias.

ग़लती कहाँ हुई? Digest की सूची ज़्यादातर उसके पाठकों और car व telephone मालिकों से आई थी — जो महामंदी के दौर में औसत से ज़्यादा अमीर थे। और Roosevelt को नापसंद करने वालों के ballot लौटाने की संभावना ज़्यादा थी (non-response bias)। आकार ने bias को ठीक नहीं किया।

问题出在哪里？《文学文摘》的名单主要来自它的读者以及汽车和电话拥有者 —— 在大萧条时期，这些人比一般人富裕。而且不喜欢罗斯福的人更愿意寄回选票（无应答偏差）。样本再大也治不了偏差。

Structured vs Semi-Structured vs Unstructured 🧩Structured बनाम Semi-Structured बनाम Unstructured 🧩结构化 vs 半结构化 vs 非结构化 🧩

Data also differs in shape. Structured data fits a table. Unstructured data — images, audio, free text — has no fixed fields. Semi-structured data sits in between: it has labels (keys or tags) but no fixed table layout.

Data अपने आकार में भी अलग होता है। Structured data table में बैठता है। Unstructured data — images, audio, खुला text — के कोई तय fields नहीं होते। Semi-structured data बीच में है: इसमें labels (keys या tags) होते हैं पर तय table layout नहीं।

数据的形态也各不相同。结构化数据能装进表格。非结构化数据 —— 图像、音频、自由文本 —— 没有固定字段。半结构化数据介于两者之间：有标签（键或标记），但没有固定的表格布局。

Structured Data — A Closer LookStructured Data — क़रीब से结构化数据 — 细看

Every row has the same fields and types, so you can run SELECT AVG(purchase_amount) FROM customers WHERE age > 30 at once. Notice that the amount is stored as a plain number (4500), not as text like "₹4,500" — currency symbols and commas belong in the display, not in the stored value.

हर row के fields और types एक जैसे हैं, इसलिए आप तुरंत SELECT AVG(purchase_amount) FROM customers WHERE age > 30 चला सकते हैं। ध्यान दें कि राशि एक सादी संख्या (4500) के रूप में रखी है, "₹4,500" जैसे text के रूप में नहीं — मुद्रा चिह्न और commas दिखाने के लिए हैं, रखी गई value के लिए नहीं।

每行字段和类型都相同，所以可以直接运行 SELECT AVG(purchase_amount) FROM customers WHERE age > 30。注意金额存为纯数字（4500），而不是“₹4,500”这样的文本 —— 货币符号和逗号属于显示格式，不该存进数据值。

Unstructured Data — A Closer LookUnstructured Data — क़रीब से非结构化数据 — 细看

Side by Side — The Three Shapes of Dataसाथ-साथ — Data के तीन आकार并排对比 — 数据的三种形态

Python ImplementationPython ImplementationPython 实现

SQL to pandas, with safe parametersसुरक्षित parameters के साथ SQL से pandas用安全参数从 SQL 读入 pandas

# 1) Query a SQL database straight into pandas (an in-memory SQLite database)
import sqlite3
import pandas as pd

conn = sqlite3.connect(":memory:")
conn.executescript("""
CREATE TABLE sales (customer_id INTEGER, revenue REAL, year INTEGER);
INSERT INTO sales VALUES (1001, 4500, 2024), (1002, 12200, 2024),
                         (1003, 8750, 2024), (1004, 3100, 2023);
""")
query = "SELECT customer_id, revenue FROM sales WHERE year = ?"
df = pd.read_sql(query, conn, params=(2024,))     # use ? placeholders, never string-join user input
print(df)
print("average revenue 2024:", round(df.revenue.mean(), 2))

Parse JSON and back off on HTTP 429JSON parse करें और HTTP 429 पर backoff करें解析 JSON 并在 HTTP 429 时退避

# 2) Parse a JSON API response and retry politely on HTTP 429
import json, time, random
import pandas as pd
random.seed(0)

# A response body as an API might return it (nested JSON)
body = '''{"results": [
  {"city": "Delhi",  "weather": {"temp_c": 31.5, "humidity": 48}},
  {"city": "Mumbai", "weather": {"temp_c": 29.0, "humidity": 77}},
  {"city": "Shimla", "weather": {"temp_c": 14.2, "humidity": 60}}]}'''
data = json.loads(body)
print(pd.json_normalize(data["results"]))

# Exponential backoff with a fake server that is busy for the first 3 calls
def fake_get(attempt):
    return 429 if attempt < 3 else 200

for attempt in range(6):
    status = fake_get(attempt)
    if status == 200:
        print(f"attempt {attempt + 1}: 200 OK")
        break
    wait = 2 ** attempt + random.random() * 0.1   # 1, 2, 4, ... seconds plus a little jitter
    print(f"attempt {attempt + 1}: {status} Too Many Requests -> wait {wait:.1f}s")
    time.sleep(0)                                  # in real code: time.sleep(wait)

Scrape a list into a tableएक list को scrape करके table बनाएँ把列表抓取成表格

# 3) Scrape a table from HTML with BeautifulSoup (HTML given as a string here)
from bs4 import BeautifulSoup
import pandas as pd

html = """
<ul class="books">
  <li class="book"><h3>Data Basics</h3><span class="price">₹350</span><span class="stock">In stock</span></li>
  <li class="book"><h3>Clean Code Notes</h3><span class="price">₹499</span><span class="stock">Sold out</span></li>
  <li class="book"><h3>Charts for All</h3><span class="price">₹275</span><span class="stock">In stock</span></li>
</ul>"""
soup = BeautifulSoup(html, "html.parser")
rows = []
for li in soup.select("li.book"):
    rows.append({
        "title": li.select_one("h3").get_text(strip=True),
        "price": int(li.select_one(".price").get_text().replace("₹", "")),
        "in_stock": li.select_one(".stock").get_text() == "In stock",
    })
print(pd.DataFrame(rows))

CSV vs Parquet: size and speed (your timings will differ)CSV बनाम Parquet: आकार और गति (आपकी timings अलग होंगी)CSV vs Parquet：大小与速度（你的计时会不同）

# 4) CSV vs Parquet: size on disk and time to read ONE column
import os, time
import numpy as np, pandas as pd

rng = np.random.default_rng(0)
n = 1_000_000
df = pd.DataFrame({
    "user_id": np.arange(n),
    "city": rng.choice(["Delhi", "Mumbai", "Pune", "Chennai"], n),
    "amount": rng.gamma(2, 500, n).round(2),
    "clicks": rng.poisson(3, n),
})
df.to_csv("sales.csv", index=False)
df.to_parquet("sales.parquet", index=False)
print(f"CSV size:     {os.path.getsize('sales.csv') / 1e6:6.1f} MB")
print(f"Parquet size: {os.path.getsize('sales.parquet') / 1e6:6.1f} MB")

t = time.perf_counter(); a = pd.read_csv("sales.csv", usecols=["amount"]); t_csv = time.perf_counter() - t
t = time.perf_counter(); b = pd.read_parquet("sales.parquet", columns=["amount"]); t_pq = time.perf_counter() - t
print(f"read 'amount' from CSV:     {t_csv:.3f} s")
print(f"read 'amount' from Parquet: {t_pq:.3f} s  ({t_csv / t_pq:.0f}x faster here)")
os.remove("sales.csv"); os.remove("sales.parquet")

A huge biased sample vs a small random oneबड़ा biased sample बनाम छोटा random sample庞大的有偏样本 vs 小的随机样本

# 5) Sampling bias: a big biased sample loses to a small random one
import numpy as np
rng = np.random.default_rng(42)
N = 1_000_000
urban = rng.random(N) < 0.35                       # 35% live in cities
support = np.where(urban, rng.random(N) < 0.30,    # 30% support in cities
                          rng.random(N) < 0.60)    # 60% support in villages
print(f"true support:                         {support.mean():.3f}")

idx = rng.choice(N, 1_000, replace=False)          # simple random sample
print(f"random sample, n = 1,000:             {support[idx].mean():.3f}")

city_only = np.flatnonzero(urban)
big = rng.choice(city_only, 100_000, replace=False)  # huge, but cities only
print(f"city-only sample, n = 100,000:        {support[big].mean():.3f}")

Golden Rules of Data CollectionData Collection के सुनहरे नियम数据收集的黄金法则