Python

python --version
python -VV                         # versi lengkap + compiler build
python -c "import sys; print(sys.executable)"
python -c "import sys; print(sys.path)"
which python                        # macOS/Linux
where python                        # Windows PowerShell/cmd

python -m venv .venv
source .venv/bin/activate           # macOS/Linux
.venv\Scripts\activate            # Windows PowerShell/cmd
python -m pip install --upgrade pip
deactivate

uv init
uv python install 3.12
uv venv --python 3.12
uv add requests pydantic
uv add --dev pytest ruff mypy
uv run python main.py
uv run pytest

python -m pip install requests
python -m pip install "fastapi[standard]"
python -m pip install -r requirements.txt
python -m pip freeze > requirements.txt
python -m pip list --outdated
python -m pip uninstall requests

[project]
name = "my-service"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = [
  "fastapi>=0.115",
  "pydantic>=2",
]

[project.optional-dependencies]
dev = ["pytest", "ruff", "mypy"]

pipx install poetry              # install CLI global terisolasi
pipx run black .                   # jalankan sekali pakai
uvx ruff check .                   # uv equivalent untuk tool sekali jalan
python -m pip install --user pipx

from pathlib import Path


def main() -> int:
    root = Path.cwd()
    print(f"working in {root}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("path")
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--limit", type=int, default=100)
args = parser.parse_args()

print(args.path, args.dry_run, args.limit)

import subprocess


result = subprocess.run(
    ["git", "status", "--short"],
    check=True,
    capture_output=True,
    text=True,
)
print(result.stdout)

from pathlib import Path


path = Path("logs/app.log")
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("hello\n", encoding="utf-8")
content = path.read_text(encoding="utf-8")

for item in Path(".").glob("**/*.py"):
    print(item)

import json
from pathlib import Path


data = {"service": "api", "replicas": 2}
Path("config.json").write_text(json.dumps(data, indent=2), encoding="utf-8")

loaded = json.loads(Path("config.json").read_text(encoding="utf-8"))
print(loaded["service"])

import os


database_url = os.environ["DATABASE_URL"]          # wajib ada
debug = os.getenv("DEBUG", "false").lower() == "true"
timeout = int(os.getenv("TIMEOUT_SECONDS", "30"))

import yaml


with open("compose.yml", "r", encoding="utf-8") as f:
    config = yaml.safe_load(f)

print(config["services"].keys())

import requests


response = requests.get(
    "https://api.example.com/users",
    headers={"Authorization": f"Bearer {token}"},
    timeout=10,
)
response.raise_for_status()
data = response.json()

from pydantic import BaseModel, Field


class Job(BaseModel):
    name: str
    retries: int = Field(default=3, ge=0, le=10)


job = Job.model_validate({"name": "sync", "retries": 2})
print(job.model_dump())

from fastapi import FastAPI
from pydantic import BaseModel


app = FastAPI()


class PredictRequest(BaseModel):
    text: str


@app.post("/predict")
def predict(req: PredictRequest) -> dict[str, str]:
    return {"label": "todo", "text": req.text}

# fastapi dev main.py
# uvicorn main:app --reload

import asyncio


async def fetch_one(i: int) -> str:
    await asyncio.sleep(0.1)
    return f"item-{i}"


async def main() -> None:
    results = await asyncio.gather(*(fetch_one(i) for i in range(10)))
    print(results)


asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor


def work(url: str) -> str:
    return url.upper()


with ThreadPoolExecutor(max_workers=8) as pool:
    for result in pool.map(work, ["a", "b", "c"]):
        print(result)

from concurrent.futures import ProcessPoolExecutor


def cpu_work(n: int) -> int:
    return sum(i * i for i in range(n))


with ProcessPoolExecutor() as pool:
    print(list(pool.map(cpu_work, [100_000, 200_000, 300_000])))

pytest
pytest -q
pytest tests/test_api.py
pytest -k "login and not slow"
pytest -x                         # stop pada failure pertama
pytest --maxfail=3

def add(a: int, b: int) -> int:
    return a + b


def test_add() -> None:
    assert add(2, 3) == 5

import logging


logging.basicConfig(level=logging.INFO)
logging.info("starting job")

breakpoint()                      # masuk debugger bawaan

# python -m pdb script.py
# python -X dev script.py

ruff check .
ruff check . --fix
ruff format .
ruff format --check .

from collections.abc import Iterable


def total(values: Iterable[int]) -> int:
    return sum(values)


items: list[int] = [1, 2, 3]
print(total(items))

# mypy .

[tool.ruff]
line-length = 100
target-version = "py311"

[tool.ruff.lint]
select = ["E", "F", "I", "UP", "B"]

[tool.mypy]
python_version = "3.11"
strict = true

python -m pip install ipykernel jupyter
python -m ipykernel install --user --name my-project --display-name "Python (my-project)"
jupyter lab

import pandas as pd


df = pd.read_csv("data.csv")
print(df.head())
print(df.info())
print(df.describe(include="all"))

df.to_parquet("data.parquet", index=False)

import pickle
from pathlib import Path


artifact_dir = Path("artifacts")
artifact_dir.mkdir(exist_ok=True)

with (artifact_dir / "model.pkl").open("wb") as f:
    pickle.dump(model, f)

with (artifact_dir / "model.pkl").open("rb") as f:
    model = pickle.load(f)

FROM python:3.12-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t my-python-app .
docker run --rm -p 8000:8000 my-python-app
docker run --rm -v "$(pwd)":/app -w /app python:3.12-slim python script.py