virtual environments-ஐ ஏன், எவ்வாறு பயன்படுத்துகிறீர்கள்?

Question

Accepted Answer

ஒரு **virtual environment** என்பது தனது சொந்த நிறுவப்பட்ட packages கொண்ட ஒரு தனிமைப்படுத்தப்பட்ட Python environment ஆகும், இது system Python-இலிருந்தும் மற்ற projects-இலிருந்தும் தனியானது. இது **dependency conflicts**-ஐ தீர்க்கிறது — வெவ்வேறு projects அதே package-இன் வெவ்வேறு (ஏன் பொருந்தாத) versions-ஐ பயன்படுத்தலாம்.

## இது தீர்க்கும் பிரச்சினை

```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.
```

தனிமைப்படுத்தல் இல்லாமல், packages-ஐ globally நிறுவுவது projects-க்கு இடையே version clashes-க்கு வழிவகுக்கிறது மற்றும் குறிப்பிட்ட versions-ஐ சார்ந்திருக்கும் system tools-ஐ உடைக்கலாம்.

## ஒன்றை உருவாக்குதல் மற்றும் பயன்படுத்துதல் (built-in 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
```

Activate செய்த பிறகு, `python` மற்றும் `pip` environment-இன் தனிமைப்படுத்தப்பட்ட நகல்களைக் குறிக்கின்றன — packages அங்கு மட்டுமே நிறுவப்படுகின்றன, system-wide அல்ல.

## Dependencies-ஐ பிடித்தல் மற்றும் மீண்டும் உருவாக்குதல்

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

ஒரு `requirements.txt` environment-ஐ **மீண்டும் உருவாக்கக்கூடியதாக** ஆக்குகிறது — யாரும் சரியாக அதே dependencies-ஐ மீண்டும் உருவாக்கலாம், "எனது இயந்திரத்தில் வேலை செய்கிறது" பிரச்சினைகளைத் தடுக்கிறது.

## நவீன tooling

```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)
```

புதிய tools (poetry, uv) lockfiles மற்றும் சிறந்த dependency resolution-ஐ சேர்க்கின்றன, ஆனால் முக்கியக் கருத்து — ஒவ்வொரு project-க்கும் தனிமைப்படுத்தப்பட்ட environments — அதுவே.

## environment-ஐ எப்போதும் version control-இலிருந்து விலக்கவும்

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

## இது ஏன் முக்கியம்

Virtual environments எந்த Python project-க்கும் இன்றியமையாத, நிலையான நடைமுறை — அவை projects-க்கு இடையேயும், projects மற்றும் system Python-க்கு இடையேயும் dependency conflicts-ஐ தடுக்கின்றன, மேலும் (`requirements.txt`/lockfiles உடன்) machines, teammates, CI, மற்றும் production முழுவதும் environments-ஐ மீண்டும் உருவாக்கக்கூடியதாக ஆக்குகின்றன.

அவற்றைத் தவிர்ப்பது version clashes, உடைந்த system tools, மற்றும் மீண்டும் உருவாக்க முடியாத setups-க்கு வழிவகுக்கிறது.

Dependencies-ஐ எவ்வாறு உருவாக்குவது, activate செய்வது, மற்றும் பிடிப்பது — மற்றும் நவீன tooling நிலப்பரப்பு (poetry, uv) — புரிந்துகொள்வது தொழில்முறை Python development-க்கு அடிப்படையானது மற்றும் எந்த உண்மையான project-இலும் ஒரு அடிப்படை எதிர்பார்ப்பு.