Python Tutorial - Learn Programming

Virtual Environments ဆိုတာ?

ဘရိုရဲ့ ကွန်ပျူတာကို အိမ်ကြီးတစ်လုံး လို့ သဘောထားလိုက်။ အဲ့ဒီအိမ်မှာ Python ကို install လုပ်ထားတာက အိမ်ရဲ့ အဓိက လျှပ်စစ် main switch ကြီးလိုပဲ။

ဘရိုက Project တွေ စလုပ်ပြီ။ Project A (ဥပမာ: Website တစ်ခု) က အခန်း (A)။ Project B (ဥပမာ: Game တစ်ခု) က အခန်း (B)။

ကွိုင် (Conflict) က ဘယ်မှာစလဲ?

ကွိုင် က ဒီမှာစတာ။

Project A (အခန်း A) အတွက် ဘရိုက requests ဆိုတဲ့ package version 1.0 ကို တပ် (install) လိုက်တယ်။ အဆင်ပြေနေတယ်။

ခဏနေတော့... Project B (အခန်း B) မှာလည်း တပ်ချင်တယ်။ အဲ့ Project က requests version 2.0 အသစ် မှ အလုပ်လုပ်မယ်။ ဘရိုက main switch ကြီးမှာ requests v2.0 ကို တပ် လိုက်ရော။

Boom! Project A (အခန်း A) ကို ပြန် run ကြည့်တဲ့အခါ... ကွိုင် တက်ပြီ။ Error တွေ တဘုန်းဘုန်းတက်လာမယ်။ ဘာလို့လဲ? သူက v1.0 နဲ့မှ အလုပ်လုပ်တာ၊ v2.0 နဲ့ အဆင်မပြေဘူး။

Version Conflict Problem: တစ်ခါတစ်လေ project တစ်ခုက package ရဲ့ version အဟောင်း လိုချင်တယ်၊ နောက် project တစ်ခုက version အသစ် လိုချင်တယ်။ Global မှာ install လုပ်ထားရင် နှစ်ခုစလုံး တစ်ပြိုင်နက် သုံးလို့ မရဘူး။

Virtual Environment ဆိုတာ အဲ့ဒီ ကွိုင် ကို ဖြေရှင်းတာ

Virtual Environment (venv) ဆိုတာ အခန်းတစ်ခန်းစီကို သီးသန့် မီးလိုင်း (Sub-switch) ခွဲပေးလိုက်တာ။

အခန်း A (Project A) အတွက် venv A ဆိုတဲ့ သီးသန့် ပုံးတစ်ပုံး ဖန်တီးလိုက်တယ်။
အခန်း B (Project B) အတွက် venv B ဆိုတဲ့ သီးသန့် ပုံးတစ်ပုံး ဖန်တီးလိုက်တယ်။

အဲ့ဒီအခါ...

venv A ပုံးထဲမှာ requests v1.0 ကို ထည့်ထား။
venv B ပုံးထဲမှာ requests v2.0 ကို ထည့်ထား။

သူတို့ ပုံး တွေက သီးသန့်စီ ဖြစ်သွားတော့ တစ်ယောက်နဲ့တစ်ယောက် မထိတော့ဘူး။ အိမ်ကြီး (ကွန်ပျူတာ) လည်း မရှုပ်တော့ဘူး။ Project တစ်ခု လုပ်ချင်ရင် အဲ့ project ရဲ့ ပုံး (venv) ကို ဖွင့် (activate) လုပ်၊ ပြီးမှ အလုပ်လုပ်။

ဒါကို Isolating (သီးသန့်ခွဲထုတ်) လုပ်တယ်လို့ ခေါ်တယ်။

Tools တွေ

ကဲ... သီးသန့်ပုံး တွေ ဆောက်ဖို့ tool တွေ လာပြီ။

1. venv (Python မှာ အသင့် ပါ)

ဒါက Python 3.3 ကတည်းက အသင့် (built-in) ပါလာတာ။ တခြား ဘာမှ ထပ် install လုပ်စရာမလိုဘူး။

ဘယ်လိုသုံးလဲ?

Step 1: ပုံး ဆောက်မယ်

ဘရို Project folder ထဲကို Terminal (CMD) ကနေ သွား။

                Terminal/Command Prompt
            
# Virtual environment တစ်ခု ဆောက်မယ်
$ python -m venv my_box

# Developer အများစုက 'venv' လို့ပဲ နာမည်ပေးလေ့ရှိတယ်
$ python -m venv venv

ဒါဆို my_box (မဟုတ်ရင် venv) ဆိုတဲ့ folder အသစ်လေးတစ်ခု ထွက်လာလိမ့်မယ်။ အဲ့ဒါ ပုံး ပဲ။

Step 2: ပုံး ကို ဖွင့် မယ် (Activate လုပ်မယ်)

ဒါ နည်းနည်းအရေးကြီး! ဒီအတိုင်း install လုပ်ရင် အပြင် (Global) မှာ ဝင်သွားမှာ။ ပုံးထဲ ဝင် ရမယ်။

                Windows
            
# Windows မှာ activate လုပ်မယ်
$ my_box\Scripts\activate

# ဒါမှမဟုတ် venv သုံးထားရင်
$ venv\Scripts\activate

                Mac/Linux
            
# Mac/Linux မှာ activate လုပ်မယ်
$ source my_box/bin/activate

# ဒါမှမဟုတ် venv သုံးထားရင်
$ source venv/bin/activate

Check Point: Activate ဖြစ်သွားရင် ဘရို Terminal ရဲ့ ရှေ့ဆုံးမှာ (my_box) ဆိုပြီး ကွင်းလေးနဲ့ ပေါ်လာလိမ့်မယ်။ ဒါဆို ဘရို ပုံး ထဲ ရောက်သွားပြီ။

Step 3: Install Packages

                Terminal (Virtual Environment Active)
            
# အခု (my_box) ထဲမှာ package install လုပ်မယ်
(my_box) $ pip install requests

# တခြား packages တွေလည်း ထည့်လို့ရပြီ
(my_box) $ pip install flask
(my_box) $ pip install numpy

အဲ့ requests က venv A ပုံးထဲကိုပဲ ဝင်သွားတာ။ အပြင်က အိမ်ကြီး (Global) နဲ့ မဆိုင်တော့ဘူး။

Step 4: package တွေသိမ်းမယ်

ဘရိုက ဒီ project ကို သူငယ်ချင်းကို ပေးချင်တယ်။ Project ကဘာ package တွေ သုံးထားမှန်း မသိဘူး။

                Terminal (Virtual Environment Active)
            
# Install လုပ်ထားတဲ့ packages စာရင်းတွေကို export လုပ်မယ်
(my_box) $ pip freeze > requirements.txt

# requirements.txt file ထဲမှာ package နာမည်နဲ့ version တွေ ရေးသွားပေးလိမ့်မယ်

အဆင်ပြေ: သူငယ်ချင်းက အဲ့ file ကို ရရင် pip install -r requirements.txt နဲ့ တစ်ခါတည်း အကုန် install လုပ်လို့ရတယ်။

Step 5: ပုံး ကို ပိတ် မယ် (Deactivate)

                Terminal
            
# Virtual environment ကနေ ထွက်မယ်
(my_box) $ deactivate

# (my_box) ဆိုတာ ပျောက်သွားပြီး ပုံး ထဲက ပြန်ထွက်လာလိမ့်မယ်
$

2. pipenv (နည်းနည်း Smart ဖြစ်တဲ့ ပုံး)

venv + pip ကို ပေါင်းထားတာ။ သူက requirements.txt ကို ကိုယ့်ဘာသာ manual မှတ်စရာမလိုဘူး။ သူ အလိုလို (automatic) မှတ်ပေးတယ်။

သူက Pipfile နဲ့ Pipfile.lock ဆိုတာကို သုံးတယ်။

Pipfile = ဘာ package တွေ လိုချင်လဲ ဆိုတဲ့ စာရင်း။
Pipfile.lock = ဘာ package တွေ အတိအကျ သုံးထားလဲ ဆိုတဲ့ သော့ (ဒါရှိရင် တခြားကွန်ပျူတာမှာ run လည်း ကွိုင် မတက်တော့ဘူး)။

Install လုပ်မယ်

                Terminal
            
# pipenv ကို install လုပ်မယ်
$ pip install pipenv

သုံးနည်း

                Terminal
            
# Package install လုပ်မယ် (venv အလိုလို ဆောက်ပေးမယ်)
$ pipenv install requests

# Multiple packages install လုပ်မယ်
$ pipenv install flask numpy pandas

pipenv install requests လို့ ရိုက်လိုက်တာနဲ့...

venv (ပုံး) ကို အလိုလို ဆောက်ပေးတယ်။
requests ကို install လုပ်ပေးတယ်။
Pipfile ထဲမှာ စာရင်း မှတ်ပေးတယ်။

Run တဲ့အခါ

                Terminal
            
# Virtual environment ထဲ ဝင်မယ်
$ pipenv shell

# မဟုတ်လည်း တိုက်ရိုက် run မယ်
$ pipenv run python app.py

ဒါက: venv ထက် ပို အဆင့်မြင့် တယ်။ requirements.txt ကို ခဏခဏ freeze လုပ်ဖို့ မေ့တတ်တဲ့ ဘော်ဒါတွေအတွက် မိုက်တာပေါ့။

3. poetry (Pro version)

ဒါက Pro Level။ pipenv လိုပါပဲ။ ဒါပေမယ့် သူက package တွေကို သုံး တဲ့အဆင့်တင် မဟုတ်တော့ဘူး။ ကိုယ်တိုင် package တွေ ရေးမယ်၊ ဖြန့်မယ် (Publish to PyPI) ဆိုရင် poetry က တော်တော်အသုံးတည့်တာ။

သူက pyproject.toml file ကို သုံးတယ်။ ဒါက လက်ရှိ Python လောကမှာ အသစ်ဆုံး standard။
သူ့ရဲ့ dependency ဖြေရှင်းနည်း (ဘယ် package က ဘယ် version နဲ့မှ တည့် မလဲ ဆိုတာ) က pipenv ထက် ပို ကြမ်း တယ်၊ ပို တိကျ တယ်။

Install လုပ်မယ်

                Terminal
            
# poetry ကို install လုပ်မယ်
$ pip install poetry

သုံးပုံကတော့

                Terminal
            
# New project စမယ်
$ poetry new my-project

# ရှိပြီးသား project မှာ poetry initialize လုပ်မယ်
$ poetry init

# Package add လုပ်မယ်
$ poetry add requests

# Development dependencies add လုပ်မယ်
$ poetry add --dev pytest

poetry add requests လို့ ရိုက်ရင် pipenv လိုပဲ အကုန် အလိုလို လုပ်ပေးသွားမယ်။

Run တဲ့အခါ

                Terminal
            
# Virtual environment ထဲ ဝင်မယ်
$ poetry shell

# မဟုတ်ရင် တိုက်ရိုက် run မယ်
$ poetry run python app.py

အနှစ်ချုပ်

ဘရိုက စ သင်နေတုန်းလား?

venv ကိုရွေး။

ဘာလို့လဲဆိုတော့ ဒါက အခြေခံကျတယ်။ Python မှာ အသင့် ပါပြီးသား။ activate လုပ်တာ၊ deactivate လုပ်တာ၊ requirements.txt ကို freeze လုပ်တာ... ဒီ flow ကို သဘောပေါက် သွားဖို့ အရေးကြီးတယ်။

Project နည်းနည်း ကြီးလာပြီး ပြီးတော့ Team နဲ့ လုပ်မှာဆို

pipenv ဒါမှမဟုတ် poetry ကို သုံး။

pipenv က နားလည်ရ လွယ်တယ်။
poetry က ပိုပြီး modern ဖြစ်တယ် powerful ဖြစ်တယ်။

အဓိက ကတော့: Project တစ်ခုကို ပုံး တစ်ပုံး သီးသန့်ဆောက်သုံး ဆိုတဲ့ အကျင့်ကို ရအောင်လုပ်ဖို့ပဲ။ ဒါဆို ဘရို code တွေ packages ပြဿနာ နဲ့ ဘယ်တော့မှ ကွိုင် မတက်တော့ဘူး။

Practical Example: Project Setup

Example Project Structure

                Project Structure
            
my_web_project/
├── venv/              # Virtual environment folder
├── app.py             # Main application file
├── requirements.txt   # Package dependencies
└── README.md          # Project documentation

Complete Workflow Example

                Terminal - Complete Setup
            
# 1. Project folder ဆောက်မယ်
$ mkdir my_web_project
$ cd my_web_project

# 2. Virtual environment ဆောက်မယ်
$ python -m venv venv

# 3. Activate လုပ်မယ်
$ venv\Scripts\activate    # Windows
$ source venv/bin/activate  # Mac/Linux

# 4. Packages install လုပ်မယ်
(venv) $ pip install flask
(venv) $ pip install requests
(venv) $ pip install python-dotenv

# 5. Requirements file ဆောက်မယ်
(venv) $ pip freeze > requirements.txt

# 6. Code ရေးမယ်
(venv) $ echo "print('Hello from virtual env!')" > app.py

# 7. Run မယ်
(venv) $ python app.py

# 8. အလုပ်ပြီးရင် deactivate လုပ်မယ်
(venv) $ deactivate

Quick Command Reference

venv Commands

                venv_commands.txt
            
# Create virtual environment
python -m venv venv

# Activate (Windows)
venv\Scripts\activate

# Activate (Mac/Linux)
source venv/bin/activate

# Install package
pip install package_name

# Save dependencies
pip freeze > requirements.txt

# Install from requirements
pip install -r requirements.txt

# Deactivate
deactivate

pipenv Commands

                pipenv_commands.txt
            
# Install pipenv
pip install pipenv

# Install package
pipenv install package_name

# Install dev dependency
pipenv install --dev package_name

# Install from Pipfile
pipenv install

# Activate shell
pipenv shell

# Run command
pipenv run python app.py

# Exit shell
exit

poetry Commands

                poetry_commands.txt
            
# Install poetry
pip install poetry

# Create new project
poetry new project_name

# Initialize in existing project
poetry init

# Add package
poetry add package_name

# Add dev dependency
poetry add --dev package_name

# Install dependencies
poetry install

# Activate shell
poetry shell

# Run command
poetry run python app.py

အကြံပေးချင်တာက

အမြဲ virtual environment သုံးပြီး project ရေးသင့်တယ် - Global installation ကို ရှောင်
Project တစ်ခုစီအတွက် သီးခြား environment ရှိသင့် - Conflict မဖြစ်အောင်
requirements.txt မေ့မထားနဲ့ - Team collaboration အတွက် အရေးကြီးတယ်
.gitignore မှာ venv folder ထည့်ပါ - Git မှာ venv folder commit မလုပ်နဲ့
Python version ရေး - README မှာ Python version ရေးထားပါ

Sample .gitignore

                .gitignore
            
# Virtual Environment
venv/
env/
ENV/

# Python
__pycache__/
*.pyc
*.pyo

# IDE
.vscode/
.idea/

# Environment variables
.env