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

URL: https://skillaria.top/hi/guides/python/moduli-python

Python में मॉड्यूल एक .py फ़ाइल है, पैकेज मॉड्यूलों का फ़ोल्डर है, और लाइब्रेरी पैकेजों का तैयार सेट है, जिसे import से जोड़ा जाता है। बाहरी लाइब्रेरी pip (या uv) से वर्चुअल एनवायरनमेंट venv में लगती हैं — अलग-अलग प्रोजेक्ट की लाइब्रेरी आपस में टकराती नहीं।

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

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

| शब्द | क्या है | उदाहरण |
| --- | --- | --- |

| मॉड्यूल | एक `.py` फ़ाइल; मॉड्यूल का नाम फ़ाइल का नाम बिना एक्सटेंशन के | `categories.py` → `import categories` |

| पैकेज | मॉड्यूलों और `__init__.py` फ़ाइल वाला फ़ोल्डर | `expenses/report.py` → `from expenses.report import build` |

| लाइब्रेरी | किसी काम के लिए तैयार मॉड्यूल और पैकेज | `requests`, `pandas`, स्टैंडर्ड `pathlib` |

| डिस्ट्रीब्यूशन (PyPI पैकेज) | वह आर्काइव जिसे pip लगाता है | `pip install requests` |

बातचीत में «लाइब्रेरी», «पैकेज» और «मॉड्यूल» अक्सर एक-दूसरे की जगह बोले जाते हैं — यह ठीक है। तकनीकी रूप से `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 «बैटरियों के साथ» आता है: सैकड़ों बिल्ट-इन मॉड्यूल बिना किसी इंस्टॉलेशन के तैयार हैं। सबसे ज़्यादा इस्तेमाल होने वाले:

| मॉड्यूल | किसके लिए |
| --- | --- |

| `os`, `sys`, `pathlib`, `shutil` | सिस्टम, पथ, फ़ाइलें |

| `json`, `csv`, `pickle` | डेटा फ़ॉर्मैट |

| `datetime`, `time`, `calendar` | तारीख़ और समय |

| `math`, `random`, `statistics`, `fractions` | संख्याएँ |

| `re`, `string` | टेक्स्ट के साथ काम |

| `collections`, `itertools`, `functools` | डेटा संरचनाएँ और इटरेटर |

| `logging`, `argparse`, `subprocess` | लॉग, कमांड-लाइन आर्गुमेंट, प्रोग्राम चलाना |

| `asyncio`, `threading` | असिंक्रोनस और थ्रेड |

स्टैंडर्ड लाइब्रेरी के सारे मॉड्यूलों की सूची `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 पर सैकड़ों हज़ार पैकेज हैं, पर ज़्यादातर प्रोजेक्ट में यही छोटी सूची दिखती है। अनजान चीज़ें खोजने से पहले इसी से शुरू करें।

| काम | लाइब्रेरी |
| --- | --- |

| HTTP अनुरोध और API | `requests`, `httpx` |

| डेटा विश्लेषण और टेबल | `pandas`, `numpy` |

| ग्राफ़ | `matplotlib` |

| वेब सेवाएँ | `fastapi`, `django`, `flask` |

| टेस्ट | `pytest` |

| चित्र | `pillow` (इम्पोर्ट होता है `PIL` नाम से) |

ध्यान दें: इंस्टॉल का नाम और इम्पोर्ट का नाम हमेशा एक जैसे नहीं होते। `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 से तेज़ शुरुआत पाता है।

## FAQ

**हर प्रोजेक्ट के लिए venv बनाना ज़रूरी है?**

हाँ, यह अच्छी आदत है: हर प्रोजेक्ट की लाइब्रेरी के वर्ज़न अलग हो सकते हैं, और अलग एनवायरनमेंट टकराव रोकता है और सिस्टम Python को गंदा नहीं होने देता।

**pip और uv में क्या फ़र्क है?**

pip सिर्फ़ पैकेज लगाता है, जबकि uv एनवायरनमेंट भी बनाता है, निर्भरताएँ pyproject.toml में लिखता है और सटीक वर्ज़न lock-फ़ाइल में रखता है; साथ ही वह काफ़ी तेज़ है।

**इंस्टॉल की गई Python लाइब्रेरी की सूची कैसे देखें?**

सही एनवायरनमेंट में python -m pip list चलाएँ; pip freeze वही सूची requirements.txt के फ़ॉर्मैट में देता है।

**इंस्टॉल किए गए मॉड्यूल कहाँ रहते हैं?**

वर्तमान एनवायरनमेंट के site-packages फ़ोल्डर में। किसी मॉड्यूल का पथ उसके __file__ एट्रिब्यूट से दिखता है, जैसे import requests; print(requests.__file__)।

**क्या venv फ़ोल्डर को दूसरी मशीन पर ले जा सकते हैं?**

नहीं, एनवायरनमेंट मशीन के पथों और इंटरप्रेटर से जुड़ा है। नई मशीन पर निर्भरताओं की सूची ले जाएँ और एनवायरनमेंट दोबारा बनाएँ।


---
Source: Skillaria.Top (https://skillaria.top)