Pandas, NumPy, और Matplotlib के साथ डेटा एनालिसिस

Python में हर गंभीर फाइनेंशियल कंप्यूटेशन आखिर में NumPy से होकर चलता है। Python लिस्ट फ्लेक्सिबल हैं, पर धीमी हैं—हर एलिमेंट टाइप-चेकिंग ओवरहेड के साथ एक पूरा Python ऑब्जेक्ट है। NumPy एरे कच्चे नंबरों को निरंतर मेमोरी ब्लॉक में स्टोर करते हैं, जिससे ऐसे ऑपरेशन संभव होते हैं जो सादे Python लूप से 100x तेज़ चलते हैं।

व्यवहार में फर्क यहां है:

import numpy as np

# 1 मिलियन रैंडम डेली रिटर्न का एक एरे बनाएं
returns = np.random.normal(0.0005, 0.02, 1_000_000)

# वेक्टराइज़्ड ऑपरेशन — कोई लूप की ज़रूरत नहीं
cumulative = np.cumprod(1 + returns)  # $1 की ग्रोथ
sharpe = returns.mean() / returns.std() * np.sqrt(252)
max_drawdown = np.min(cumulative / np.maximum.accumulate(cumulative) - 1)

print(f"Sharpe Ratio: {sharpe:.3f}")
print(f"Max Drawdown: {max_drawdown:.2%}")

फाइनेंस के लिए मुख्य NumPy कॉन्सेप्ट:

• वेक्टराइज़्ड ऑपरेशन — एलिमेंट-दर-एलिमेंट लूप करने के बजाय पूरे एरे पर एक साथ गणित लगाना।
• ब्रॉडकास्टिंग — अंकगणित के लिए अलग-अलग शेप वाले एरे को ऑटोमैटिक रूप से एलाइन करना (जैसे, हर एलिमेंट से एक स्केलर मीन घटाना)।
• लीनियर अलजेब्रा — np.linalg मैट्रिक्स मल्टीप्लिकेशन, आइगनवैल्यू डीकम्पोज़िशन, और सॉल्वर देता है जो पोर्टफोलियो ऑप्टिमाइज़ेशन में इस्तेमाल होते हैं।
• रैंडम सैंपलिंग — मोंटे कार्लो सिमुलेशन, बूटस्ट्रैप सैंपलिंग, और स्टोकैस्टिक मॉडलिंग सभी np.random पर निर्भर हैं।

यदि NumPy इंजन है, तो pandas डैशबोर्ड है। यह NumPy एरे को लेबल्ड, इंडेक्स्ड संरचनाओं में लपेटता है जो फाइनेंशियल डेटा को संभालना सहज और अभिव्यक्तिपूर्ण बनाते हैं।

दो मुख्य संरचनाएं हैं:

• Series — एक इंडेक्स के साथ डेटा का एक अकेला कॉलम (सोचें: क्लोज़िंग प्राइस की एक टाइम सीरीज़)।
• DataFrame — कॉलम की एक टेबल, हर एक Series, एक साझा इंडेक्स के साथ (सोचें: OHLCV कैंडलस्टिक डेटा)।

डेटा लोड करना और उसका इंस्पेक्शन करना सीधा है:

import pandas as pd

# CSV से पढ़ें
df = pd.read_csv("btc_daily.csv", parse_dates=["date"], index_col="date")

# या JSON से (API रिस्पॉन्स में सामान्य)
df = pd.read_json("https://api.example.com/candles?symbol=ETH")

# त्वरित इंस्पेक्शन
print(df.shape)          # (365, 5)
print(df.dtypes)         # कॉलम टाइप
print(df.describe())     # स्टैटिस्टिकल सारांश
print(df.tail())         # आखिरी 5 पंक्तियां

जो pandas को फाइनेंस के लिए अनिवार्य बनाता है वह है इसका DatetimeIndex। एक बार जब आपका इंडेक्स datetime-टाइप हो जाता है, आप शक्तिशाली टाइम-सीरीज़ ऑपरेशन अनलॉक करते हैं:

# डेट रेंज से स्लाइस करें
q1_data = df["2025-01":"2025-03"]

# डेली डेटा को वीकली OHLC में रीसैंपल करें
weekly = df["close"].resample("W").ohlc()

# मिसिंग डेटा को फॉरवर्ड-फिल करें (वीकेंड, हॉलिडे)
df = df.asfreq("D").ffill()

ये ऑपरेशन फाइनेंशियल डेटा की गड़बड़ हकीकतों को संभालते हैं—गैप, टाइमज़ोन के फर्क, अनियमित टाइमस्टैंप—तो आप डेटा प्लंबिंग के बजाय विश्लेषण पर फोकस कर सकते हैं।

फाइनेंशियल विश्लेषण मूल रूप से विंडोड है। आप अलग से किसी एक डेटा पॉइंट की परवाह शायद ही कभी करते हैं—कॉन्टेक्स्ट इस बात से आता है कि यह हाल के इतिहास से कैसे जुड़ता है। Pandas का .rolling() मेथड यहां आपका मुख्य टूल है।

import pandas as pd
import numpy as np

# मानें df में DatetimeIndex के साथ एक "close" कॉलम है
df["sma_20"] = df["close"].rolling(20).mean()
df["sma_50"] = df["close"].rolling(50).mean()
df["ema_12"] = df["close"].ewm(span=12).mean()

# डेली रिटर्न और रोलिंग वोलैटिलिटी
df["returns"] = df["close"].pct_change()
df["vol_30d"] = df["returns"].rolling(30).std() * np.sqrt(365)

# बोलिंगर बैंड्स
df["bb_upper"] = df["sma_20"] + 2 * df["close"].rolling(20).std()
df["bb_lower"] = df["sma_20"] - 2 * df["close"].rolling(20).std()

# दो एसेट के बीच रोलिंग करिलेशन
df["corr_btc_eth"] = df["btc_returns"].rolling(60).corr(df["eth_returns"])

हर ट्रेडर को जो मुख्य रोलिंग कैलकुलेशन जानने चाहिए:

• Simple Moving Average (SMA) — N पीरियड में समान-वेटेड औसत। पिछड़ता पर स्थिर।
• Exponential Moving Average (EMA) — .ewm() के ज़रिए हाल के डेटा को ज़्यादा वेट देता है। प्राइस बदलाव के प्रति ज़्यादा रिस्पॉन्सिव।
• Rolling Volatility — एक विंडो में रिटर्न का स्टैंडर्ड डिविएशन, एन्युअलाइज़्ड। पोज़िशन साइज़िंग और रिस्क बजट के लिए ज़रूरी।
• Rolling Correlation — मापता है कि दो एसेट समय के साथ कैसे साथ चलते हैं। पोर्टफोलियो डाइवर्सिफिकेशन के लिए अहम।

GaiaEx जैसे प्लेटफॉर्म पर, आप ट्रेडिंग API के ज़रिए ऐतिहासिक कैंडल डेटा खींच सकते हैं, इसे एक pandas DataFrame में लोड कर सकते हैं, और इन इंडिकेटर को सेकंडों में कैलकुलेट कर सकते हैं—सब कुछ जबकि आपकी एसेट आपके MPC वॉलेट में सुरक्षित रहती हैं।

जब आप कई एसेट मैनेज कर रहे होते हैं, .groupby() अनिवार्य हो जाता है। यह आपको कैटेगरी के हिसाब से डेटा बांटने, कैलकुलेशन लगाने, और नतीजों को जोड़ने देता है—split-apply-combine पैटर्न।

# कई एसेट के साथ DataFrame
trades = pd.DataFrame({
    "symbol": ["BTC", "ETH", "BTC", "SOL", "ETH", "BTC"],
    "side": ["buy", "buy", "sell", "buy", "sell", "buy"],
    "pnl": [120.5, -45.2, 89.0, 210.3, 55.8, -30.1],
    "volume": [5000, 3200, 4800, 1500, 2900, 5100],
})

# हर एसेट के हिसाब से परफॉर्मेंस
summary = trades.groupby("symbol").agg(
    total_pnl=("pnl", "sum"),
    avg_pnl=("pnl", "mean"),
    trade_count=("pnl", "count"),
    total_volume=("volume", "sum"),
    win_rate=("pnl", lambda x: (x > 0).mean()),
)

print(summary.sort_values("total_pnl", ascending=False))

पोर्टफोलियो काम के लिए एडवांस्ड एग्रीगेशन पैटर्न:

• मल्टी-लेवल groupby — सिंबल और साइड के हिसाब से ग्रुप करें, हर एसेट के लिए लॉन्ग बनाम शॉर्ट परफॉर्मेंस देखने के लिए।
• कस्टम एग्रीगेशन फंक्शन — हर एसेट ग्रुप के लिए शार्प रेशियो, सॉर्टिनो रेशियो, या मैक्स ड्रॉडाउन कैलकुलेट करें।
• पिवट टेबल — pd.pivot_table() का उपयोग करते हुए महीने के हिसाब से हर एसेट के रिटर्न को एक हीटमैप-फ्रेंडली फॉर्मेट में फिर से आकार दें।
• groupby के साथ रीसैंपलिंग — मल्टी-एसेट टाइम-सीरीज़ विश्लेषण के लिए टाइम-आधारित रीसैंपलिंग को कैटेगोरिकल ग्रुपिंग के साथ जोड़ें।

विज़ुअलाइज़ेशन के बिना डेटा बस नंबर हैं। Matplotlib आपके विश्लेषण को उन चार्ट में बदलता है जो कच्चे डेटा में अदृश्य पैटर्न को उजागर करते हैं।

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, axes = plt.subplots(3, 1, figsize=(14, 10),
                         sharex=True, gridspec_kw={"height_ratios": [3, 1, 1]})

# प्राइस + मूविंग एवरेज
axes[0].plot(df.index, df["close"], label="Close", linewidth=1.2)
axes[0].plot(df.index, df["sma_20"], label="SMA 20", linestyle="--")
axes[0].fill_between(df.index, df["bb_upper"], df["bb_lower"],
                     alpha=0.1, color="blue", label="Bollinger Bands")
axes[0].set_ylabel("Price (USD)")
axes[0].legend(loc="upper left")

# वॉल्यूम बार
colors = ["green" if c > o else "red"
          for c, o in zip(df["close"], df["open"])]
axes[1].bar(df.index, df["volume"], color=colors, alpha=0.7)
axes[1].set_ylabel("Volume")

# रोलिंग वोलैटिलिटी
axes[2].plot(df.index, df["vol_30d"], color="purple")
axes[2].set_ylabel("30d Volatility")
axes[2].axhline(y=0.8, color="red", linestyle=":", alpha=0.5)

axes[2].xaxis.set_major_formatter(mdates.DateFormatter("%b %Y"))
plt.tight_layout()
plt.savefig("analysis_dashboard.png", dpi=150)
plt.show()

यह एक प्रोफेशनल तीन-पैनल डैशबोर्ड बनाता है: ऊपर बोलिंगर बैंड्स के साथ प्राइस एक्शन, बीच में वॉल्यूम, और नीचे वोलैटिलिटी। यह लेआउट वैसा ही दिखता है जो आप प्रोफेशनल ट्रेडिंग टर्मिनल पर देखेंगे।

स्टैटिस्टिकल विज़ुअलाइज़ेशन के लिए, seaborn Matplotlib के ऊपर हाई-लेवल फंक्शन बनाता है:

import seaborn as sns

# रिटर्न डिस्ट्रीब्यूशन
sns.histplot(df["returns"].dropna(), bins=100, kde=True)

# एसेट के बीच करिलेशन हीटमैप
corr_matrix = portfolio_returns.corr()
sns.heatmap(corr_matrix, annot=True, cmap="RdYlGn", center=0)

असली ताकत तब सामने आती है जब आप इन टूल को एक दोहराने योग्य पाइपलाइन में जोड़ते हैं। यहां एक वर्कफ्लो है जो प्रोफेशनल क्वांट रोज़ इस्तेमाल करते हैं:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def analyze_asset(symbol: str, df: pd.DataFrame) -> dict:
    """एक अकेली एसेट के लिए पूरा विश्लेषण पाइपलाइन।"""
    df["returns"] = df["close"].pct_change()
    df["log_returns"] = np.log(df["close"] / df["close"].shift(1))

    return {
        "symbol": symbol,
        "total_return": (df["close"].iloc[-1] / df["close"].iloc[0]) - 1,
        "annual_vol": df["returns"].std() * np.sqrt(365),
        "sharpe": df["returns"].mean() / df["returns"].std() * np.sqrt(365),
        "max_drawdown": (df["close"] / df["close"].cummax() - 1).min(),
        "skewness": df["returns"].skew(),
        "kurtosis": df["returns"].kurtosis(),
    }

# कई एसेट का विश्लेषण करें
results = [analyze_asset(sym, data) for sym, data in assets.items()]
summary = pd.DataFrame(results).set_index("symbol")
print(summary.round(4))

यह पाइपलाइन कच्चे प्राइस डेटा लेती है और हर एसेट के लिए एक व्यापक रिस्क-रिटर्न प्रोफाइल बनाती है। यहां से, आप इन मेट्रिक्स को एक पोर्टफोलियो ऑप्टिमाइज़र में फीड कर सकते हैं, एलोकेशन सिफारिश जनरेट कर सकते हैं, या रीबैलेंसिंग सिग्नल ट्रिगर कर सकते हैं।

pandas-NumPy-Matplotlib स्टैक वह बुनियाद है जिस पर Python फाइनेंस में बाकी सब कुछ बनता है। इन तीन लाइब्रेरी में महारत हासिल करें और आपके पास किसी भी मार्केट का विश्लेषण करने, कोई भी इंडिकेटर बनाने, और किसी भी स्ट्रैटेजी को विज़ुअलाइज़ करने के स्किल होंगे—चाहे आप NYSE पर इक्विटी ट्रेड कर रहे हों, GaiaEx पर क्रिप्टो, या CME पर डेरिवेटिव्स।