Python मॉड्यूल और पैकेज: import, pip, venv और लाइब्रेरी सरल भाषा में

Python में मॉड्यूल एक साधारण फ़ाइल है जिसमें कोड होता है, और import वह तरीका है जिससे उसके फ़ंक्शन और क्लास लिए जाते हैं। मॉड्यूल मिलकर पैकेज बनाते हैं, पैकेज मिलकर लाइब्रेरी, और बाहरी लाइब्रेरी अलग-अलग प्रोजेक्ट में आपस में न टकराएँ, इसलिए उन्हें वर्चुअल एनवायरनमेंट venv में लगाया जाता है। पूरी कड़ी को क्रम से समझते हैं: import के दौरान क्या होता है, पैकेज कैसे बनता है, pip और venv कैसे काम करते हैं, और Python 3.15 में आए lazy import क्या हैं।

मॉड्यूल, पैकेज और लाइब्रेरी में फ़र्क

बातचीत में «लाइब्रेरी», «पैकेज» और «मॉड्यूल» अक्सर एक-दूसरे की जगह बोले जाते हैं — यह ठीक है। तकनीकी रूप से import हमेशा किसी मॉड्यूल या पैकेज को लोड करता है, और pip PyPI से डिस्ट्रीब्यूशन लगाता है, जिसके भीतर पैकेज होते हैं।

Python में import कैसे काम करता है

import के कई रूप हैं, और सभी असली कोड में दिखते हैं:

import math                    # पूरा मॉड्यूल, math.sqrt के रूप में
from math import sqrt, pi      # चुने हुए नाम
import datetime as dt          # उपनाम
from collections import Counter as C

print(math.sqrt(16), sqrt(9), pi)
print(dt.date.today())

बड़ी लाइब्रेरी के लिए उपनाम आम हैं: import numpy as np, import pandas as pd। from module import * न लिखें: वह नामों का ढेर लगाता है और छिपा देता है कि नाम कहाँ से आया।

import असल में क्या करता है

1. पहले sys.modules कैश में देखता है। मॉड्यूल पहले से लोड हो तो वही लौटा देता है।
2. न मिले तो sys.path की सूची में फ़ाइल ढूँढता है: चलाई गई स्क्रिप्ट का फ़ोल्डर, स्टैंडर्ड लाइब्रेरी, और एनवायरनमेंट का site-packages।
3. मिली फ़ाइल को ऊपर से नीचे पूरा चलाता है।
4. मॉड्यूल ऑब्जेक्ट को कैश में रखता है और नाम से जोड़ता है।

इससे दो व्यावहारिक नतीजे निकलते हैं। वही मॉड्यूल दोबारा import करने पर लगभग कोई लागत नहीं आती — कोड दूसरी बार नहीं चलता। और मॉड्यूल का ऊपरी स्तर का सारा कोड, जिसमें print और भारी गणनाएँ शामिल हैं, import के समय चल जाता है।

import sys
for p in sys.path:
    print(p)
print("math" in sys.modules)

if __name__ == "__main__"

चूँकि import फ़ाइल चलाता है, यह पहचानना ज़रूरी है कि «मुझे स्क्रिप्ट की तरह चलाया गया» या «मुझे इम्पोर्ट किया गया»। इसके लिए वेरिएबल __name__ है: फ़ाइल चलाने पर उसका मान "__main__" होता है, इम्पोर्ट पर मॉड्यूल का नाम।

# categories.py
def guess(title: str) -> str:
    return "खाना" if "कैफ़े" in title.lower() else "अन्य"

if __name__ == "__main__":
    print(guess("कैफ़े पास में"))   # सिर्फ़ python categories.py से चलने पर

पैकेज के लिए विकल्प है: उसके भीतर फ़ाइल __main__.py रखें और python -m expenses से चलाएँ।

Python के स्टैंडर्ड मॉड्यूल

Python «बैटरियों के साथ» आता है: सैकड़ों बिल्ट-इन मॉड्यूल बिना किसी इंस्टॉलेशन के तैयार हैं। सबसे ज़्यादा इस्तेमाल होने वाले:

स्टैंडर्ड लाइब्रेरी के सारे मॉड्यूलों की सूची sys.stdlib_module_names में है (Python 3.10+)। किसी मॉड्यूल में क्या है, यह dir(math) और help(math) से देखा जा सकता है।

अपना पैकेज: प्रोजेक्ट की संरचना

जब मॉड्यूल बहुत हो जाएँ, तो उन्हें पैकेज में रखा जाता है। आम तरीका है src-layout:

expenses-project/
├── pyproject.toml
└── src/
    └── expenses/
        ├── __init__.py
        ├── cli.py
        ├── parsing.py
        ├── categories.py
        └── report.py

पैकेज के भीतर मॉड्यूल एक-दूसरे को पैकेज के नाम से (from expenses.categories import guess) या सापेक्ष रूप से (from .categories import guess) इम्पोर्ट करते हैं। सापेक्ष इम्पोर्ट सिर्फ़ पैकेज के भीतर चलता है, न कि उस फ़ाइल में जो सीधे स्क्रिप्ट की तरह चलाई गई हो।

pip: लाइब्रेरी कैसे लगाएँ

बाहरी लाइब्रेरी PyPI पर रहती हैं, और उन्हें लगाता है pip, जो Python के साथ आता है। सबसे भरोसेमंद तरीका है pip को इंटरप्रेटर के ज़रिए चलाना — तब लाइब्रेरी ठीक उसी Python में जाती है, जिससे आप कोड चलाते हैं।

python -m pip install requests          # इंस्टॉल
python -m pip install "pandas>=2.3"     # वर्ज़न की सीमा के साथ
python -m pip install --upgrade requests
python -m pip uninstall requests        # हटाना
python -m pip list                      # इंस्टॉल पैकेजों की सूची
python -m pip show requests             # वर्ज़न और निर्भरताएँ
python -m pip freeze > requirements.txt
python -m pip install -r requirements.txt

Windows पर अक्सर python की जगह लॉन्चर py लिखा जाता है। pip न मिले तो उसे मॉड्यूल ही लगा देता है: python -m ensurepip --upgrade।

लोकप्रिय Python लाइब्रेरी

PyPI पर सैकड़ों हज़ार पैकेज हैं, पर ज़्यादातर प्रोजेक्ट में यही छोटी सूची दिखती है। अनजान चीज़ें खोजने से पहले इसी से शुरू करें।

ध्यान दें: इंस्टॉल का नाम और इम्पोर्ट का नाम हमेशा एक जैसे नहीं होते। pip install pillow लिखा जाता है, पर लिखा जाता है from PIL import Image; opencv-python लगता है, और इम्पोर्ट होता है cv2। इंस्टॉल के बाद भी import गिरे, तो पैकेज के दस्तावेज़ में देखें कि वह किस नाम से इम्पोर्ट होता है।

Linux पर लाइब्रेरी इंस्टॉल करना

नए Debian और Ubuntu पर सिस्टम Python में pip install externally-managed-environment एरर के साथ रुक जाता है (PEP 668)। यह सुरक्षा है: सिस्टम का Python OS के पैकेज मैनेजर का है, और pip को उसे नहीं तोड़ना चाहिए। सही हल --break-system-packages नहीं, बल्कि वर्चुअल एनवायरनमेंट है।

venv: वर्चुअल एनवायरनमेंट

वर्चुअल एनवायरनमेंट एक अलग फ़ोल्डर है, जिसमें अपना इंटरप्रेटर (उसका संदर्भ) और अपना site-packages होता है। उसमें लगी लाइब्रेरी सिर्फ़ उसी प्रोजेक्ट को दिखती हैं। इस तरह एक प्रोजेक्ट में Django 4 और दूसरे में Django 5 साथ चल सकते हैं, बिना टकराव के।

मॉड्यूल venv Python में बिल्ट-इन है, अलग से लगाने की ज़रूरत नहीं (Debian/Ubuntu पर कभी-कभी सिस्टम पैकेज python3-venv चाहिए होता है)।

# .venv फ़ोल्डर में एनवायरनमेंट बनाना
python -m venv .venv

# सक्रिय करना: Linux और macOS
source .venv/bin/activate
# सक्रिय करना: Windows PowerShell
.venv\Scripts\Activate.ps1

# अब pip पैकेज .venv के भीतर लगाता है
python -m pip install requests
python -c "import sys; print(sys.prefix)"

# एनवायरनमेंट से बाहर आना
deactivate

सक्रिय होने पर टर्मिनल की लाइन की शुरुआत में (.venv) दिखता है। एनवायरनमेंट का फ़ोल्डर git में नहीं डाला जाता (.venv/ को .gitignore में डालें), और उसे मशीनों के बीच नहीं ले जाया जाता — उसकी जगह निर्भरताओं की सूची रखी जाती है और एनवायरनमेंट दोबारा बनाया जाता है। अगर PowerShell सक्रियण स्क्रिप्ट चलाने से रोके, तो उपयोगकर्ता के लिए इसे अनुमति दें: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned।

uv और pyproject.toml

आधुनिक प्रोजेक्ट निर्भरताएँ pyproject.toml में लिखते हैं। कोर्स में इस्तेमाल होने वाला मैनेजर uv एनवायरनमेंट बनाने और इंस्टॉल करने को एक साथ करता है: uv add pandas पैकेज डाउनलोड करता है, उसे pyproject.toml में लिखता है और सटीक वर्ज़न uv.lock में दर्ज करता है। साथी प्रोजेक्ट क्लोन करके uv sync चलाता है और हूबहू वही एनवायरनमेंट पाता है।

[project]
name = "expenses"
version = "0.1.0"
requires-python = ">=3.15"
dependencies = [
    "pandas>=2.3",
]

[project.scripts]
expenses = "expenses.cli:main"

Python 3.15 में lazy import (PEP 810)

इस विषय में 3.15 की मुख्य नई चीज़ है कीवर्ड lazy। भारी लाइब्रेरी लोड होने में समय लेती हैं: कोर्स के माप में python:3.15-slim इमेज पर साधारण import pandas लगभग 415 ms ले गया, जबकि lazy import pandas लगभग 13 ms। जो CLI टूल सिर्फ़ --help दिखाने के लिए चलाया जाए, उसमें यह फ़र्क बहुत बड़ा है।

lazy import pandas as pd
lazy from expenses.report import build_report

def main() -> None:
    ...
    df = pd.read_csv(path)   # pandas का असली लोड — यहाँ

मॉड्यूल की जगह नाम पर एक प्रॉक्सी ऑब्जेक्ट रखा जाता है (types.LazyImportType), और असली import नाम पहली बार इस्तेमाल होने पर होता है। अगर वह नौबत न आए, तो समय बिल्कुल नहीं लगता।

lazy import की सीमाएँ

• सिर्फ़ मॉड्यूल के ऊपरी स्तर पर अनुमत है: फ़ंक्शन, क्लास या try/except के भीतर लिखा तो SyntaxError।
• lazy from x import * मना है।
• ModuleNotFoundError शुरुआत में नहीं, पहली बार इस्तेमाल पर आएगा।
• मॉड्यूल के साइड-इफ़ेक्ट (जैसे प्लगइन का रजिस्ट्रेशन) समय में आगे खिसक जाते हैं।

सारे इम्पोर्ट एक साथ लेज़ी करने के लिए फ़्लैग -X lazy_imports=all या वेरिएबल PYTHON_LAZY_IMPORTS=all है, और अपवाद sys.set_lazy_imports_filter() से तय होते हैं। जो कोड पुराने वर्ज़न पर भी चलना चाहिए, उसके लिए मॉड्यूल वेरिएबल __lazy_modules__ = ["pandas"] है: 3.15 सूचीबद्ध इम्पोर्ट को लेज़ी बनाएगा, और पुराने वर्ज़न साधारण import ही चलाएँगे। स्टार्टअप में समय कहाँ जाता है, यह python -X importtime -c "import pandas" दिखाता है। फ़ायदा सबसे ज़्यादा उन प्रोग्रामों को होता है जो बार-बार छोटे समय के लिए चलते हैं; लंबे समय तक चलने वाले सर्वर को लेज़ीनेस से लगभग कुछ नहीं मिलता।

आम गलतियाँ

• ModuleNotFoundError: No module named 'requests' — लाइब्रेरी किसी और Python में लगी है, या एनवायरनमेंट सक्रिय नहीं। वही इंटरप्रेटर चुनकर python -m pip show requests से जाँचें।
• अपनी फ़ाइल का नाम json.py, random.py या csv.py रखा — स्क्रिप्ट का फ़ोल्डर sys.path में सबसे आगे होता है, और वह स्टैंडर्ड मॉड्यूल को ढक लेता है। Python 3.13+ एरर में «consider renaming» का सुझाव देता है। फ़ाइल का नाम बदलें और __pycache__ हटाएँ।
• सर्कुलर इम्पोर्ट: a.py b.py को इम्पोर्ट करता है, और b.py a.py को। साझा हिस्सा तीसरे मॉड्यूल में रखें, या फ़ंक्शन के भीतर इम्पोर्ट करें।
• pip को Python के भीतर चलाना (>>> pip install) — SyntaxError मिलेगा। pip की कमांड टर्मिनल में चलती हैं।

निष्कर्ष

मॉड्यूल एक फ़ाइल है, पैकेज मॉड्यूलों का फ़ोल्डर, और लाइब्रेरी उनका तैयार सेट। import मॉड्यूल को कैश और sys.path में ढूँढता है और एक बार चलाता है। बाहरी लाइब्रेरी pip या uv से केवल वर्चुअल एनवायरनमेंट venv में लगाएँ — तब प्रोजेक्ट आपस में नहीं टकराते, और एनवायरनमेंट आसानी से दोबारा बनाया जा सकता है। कोर्स में यह विषय व्यवहार में सिखाया जाता है: ख़र्च ट्रैकर एक पैकेज बनता है, निर्भरताओं के साथ, और lazy import से तेज़ शुरुआत पाता है।