ਤੁਸੀਂ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਅਤੇ ਕਿਵੇਂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

ਇੱਕ **ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ** ਆਪਣੇ ਇੰਸਟਾਲ ਕੀਤੇ ਪੈਕੇਜਾਂ ਦੇ ਨਾਲ ਇੱਕ ਅਲੱਗ ਥਲੱਗ Python ਵਾਤਾਵਰਣ ਹੈ, ਸਿਸਟਮ Python ਅਤੇ ਹੋਰ ਪ੍ਰੋਜੈਕਟਾਂ ਤੋਂ ਵੱਖ। ਇਹ **ਨਿਰਭਰਤਾ ਸੰਘਰਸ਼** ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ — ਵੱਖ-ਵੱਖ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਇੱਕੋ ਪੈਕੇਜ ਦੇ ਵੱਖ-ਵੱਖ (ਇੱਥੋ ਤੱਕ ਕਿ ਅਸੰਭਵ) ਸੰਸਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

## ਸਮੱਸਿਆ ਜਿਸ ਨੂੰ ਇਹ ਹੱਲ ਕਰਦਾ ਹੈ

```text
Project A needs Django 3.2
Project B needs Django 4.2
→ Installing globally, they CONFLICT — you can't have both versions system-wide.
Virtual environments give each project its OWN isolated set of packages.
```

ਅਲਜ਼ਾਲਤੀ ਤੋਂ ਬਿਨਾ, ਪੈਕੇਜਾਂ ਨੂੰ ਗਲੋਬਲ ਤੌਰ 'ਤੇ ਇੰਸਟਾਲ ਕਰਨਾ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿਚਕਾਰ ਸੰਸਕਰਣ ਟਾਕਰੇ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਅਤੇ ਸਿਸਟਮ ਟੂਲਜ਼ ਨੂੰ ਭੰਗ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਖਾਸ ਸੰਸਕਰਣਾਂ 'ਤੇ ਨਿਰਭਰ ਹਨ।

## ਇੱਕ ਬਣਾਉਣਾ ਅਤੇ ਵਰਤੋਂ ਕਰਨਾ (ਬਿਲਟ-ਇਨ venv)

```bash
# 1. create a virtual environment (a folder named .venv)
python -m venv .venv

# 2. ACTIVATE it (shell-specific)
source .venv/bin/activate      # macOS/Linux
.venv\Scripts\activate         # Windows

# 3. now pip installs go INTO this env, isolated from the system
pip install django requests

# 4. when done
deactivate
```

ਇੱਕ ਵਾਰ ਕਿਰਿਆਸ਼ੀਲ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ, `python` ਅਤੇ `pip` ਵਾਤਾਵਰਣ ਦੀਆਂ ਅਲੱਗ ਕਾਪੀਆਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ — ਪੈਕੇਜ ਸਿਰਫ ਉੱਥੇ ਇੰਸਟਾਲ ਹੁੰਦੇ ਹਨ, ਸਿਸਟਮ-ਵਿਆਪੀ ਨਹੀਂ।

## ਨਿਰਭਰਤਾ ਨੂੰ ਕੈਪਚਰ ਅਤੇ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨਾ

```bash
pip freeze > requirements.txt       # record exact installed versions
pip install -r requirements.txt     # recreate the env elsewhere (teammate, CI, prod)
```

ਇੱਕ `requirements.txt` ਵਾਤਾਵਰਣ ਨੂੰ **ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨ ਯੋਗ** ਬਣਾਉਂਦਾ ਹੈ — ਕੋਈ ਵੀ ਬਿਲਕੁਲ ਇੱਕੋ ਨਿਰਭਰਤਾ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾ ਸਕਦਾ ਹੈ, "ਮੇਰੀ ਮਸ਼ੀਨ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ" ਮੁੱਦਿਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।

## ਆਧੁਨਿਕ ਟੂਲਜ਼

```text
venv + pip      → built-in, standard, widely used
poetry          → dependency management + lockfile + packaging (popular)
pipenv          → combines pip + venv with a lockfile
uv / pdm        → newer, faster tools
conda           → common in data science (manages Python versions + non-Python deps too)
```

ਨਵੇਰ ਟੂਲਜ਼ (poetry, uv) ਲਾਕਫਾਈਲਾਂ ਅਤੇ ਬਿਹਤਰ ਨਿਰਭਰਤਾ ਹੱਲ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ, ਪਰ ਮੂਲ ਧਾਰਣਾ — ਪ੍ਰੋਜੈਕਟ-ਪ੍ਰਤੀ ਅਲੱਗ ਵਾਤਾਵਰਣ — ਉਹੀ ਹੈ।

## ਹਮੇਸ਼ਾ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਤੋਂ env ਨੂੰ ਬਾਹਰ ਕੱਢੋ

```text
# .gitignore
.venv/        ← don't commit the environment; commit requirements.txt/lockfile instead
```

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਕਿਸੇ ਵੀ Python ਪ੍ਰੋਜੈਕਟ ਲਈ ਜ਼ਰੂਰੀ, ਮਿਆਰੀ ਅਭਿਆਸ ਹਨ — ਉਹ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿਚਕਾਰ ਅਤੇ ਪ੍ਰੋਜੈਕਟਾਂ ਅਤੇ ਸਿਸਟਮ Python ਵਿਚਕਾਰ ਨਿਰਭਰਤਾ ਸੰਘਰਸ਼ ਨੂੰ ਰੋਕਦੇ ਹਨ, ਅਤੇ (`requirements.txt`/ਲਾਕਫਾਈਲਾਂ ਦੇ ਨਾਲ) ਮਸ਼ੀਨਾਂ, ਟੀਮ ਮੇਟਸ, CI, ਅਤੇ ਉਤਪਾਦਨ ਵਿੱਚ ਵਾਤਾਵਰਣ ਨੂੰ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ।

ਉਹਨਾਂ ਨੂੰ ਛੱਡਣਾ ਸੰਸਕਰਣ ਟਾਕਰਿਆਂ, ਟੁੱਟੀਆਂ ਸਿਸਟਮ ਟੂਲਜ਼, ਅਤੇ ਅਦਰਿਸ਼ਯ ਸੈੱਟਅਪ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ।

ਸਮਝਣਾ ਕਿ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਕਿਰਿਆਸ਼ੀਲ ਕਰਨਾ ਹੈ, ਅਤੇ ਨਿਰਭਰਤਾ ਨੂੰ ਕੈਪਚਰ ਕਰਨਾ ਹੈ — ਅਤੇ ਆਧੁਨਿਕ ਟੂਲਜ਼ ਭੂ-ਦ੍ਰਿਸ਼ (poetry, uv) — ਪেশੇਵਰ Python ਵਿਕਾਸ ਨੂੰ ਬੁਨਿਆਦੀ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਵਾਸਤਵਿਕ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਬੁਨਿਆਦੀ ਉਮੀਦ ਹੈ।