Shpargalka: tez ma'lumotnoma

mkdir loyiha && cd loyiha
python3 -m venv .venv
.venv/bin/python3 -m pip install -U pip
mkdir -p src/paket tests
touch src/paket/__init__.py
# pyproject.toml yozing (pastda), keyin:
.venv/bin/python3 -m pip install -e ".[dev]"

[project]
name = "paket"
version = "0.1.0"
description = "Bir qatorlik tavsif"
readme = "README.md"
requires-python = ">=3.10"
license = {text = "MIT"}
dependencies = []

[project.optional-dependencies]
dev = ["pytest>=8", "pytest-cov>=5", "mypy>=1.8", "ruff>=0.5"]

[project.scripts]
paket = "paket.cli:main"

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-q --strict-markers"

[tool.coverage.run]
source = ["paket"]

[tool.coverage.report]
show_missing = true
exclude_lines = ["pragma: no cover", "if __name__ == .__main__.:"]

loyiha/
├── pyproject.toml
├── ruff.toml
├── mypy.ini
├── README.md
├── .gitignore
├── .env.namuna
├── src/paket/
│   ├── __init__.py       # ommaviy yuz: importlar + __version__
│   ├── __main__.py       # python3 -m paket
│   ├── cli.py            # argparse
│   ├── modellar.py       # dataclass, Enum
│   ├── sozlama.py        # muhit o'zgaruvchilari
│   ├── xatolar.py        # istisno oilasi
│   └── ...               # har modul bitta ish
└── tests/
    ├── conftest.py       # umumiy fixture lar (__init__.py YO'Q)
    └── test_*.py

.venv/bin/python3 -m pytest              # testlar
.venv/bin/python3 -m pytest --lf         # faqat oxirgi yiqilganlar
.venv/bin/python3 -m pytest -k "sana"    # nom bo'yicha
.venv/bin/python3 -m pytest --cov=paket --cov-report=term-missing
python3 -m mypy                          # turlar
ruff check src tests                     # linter
ruff check --fix src tests               # avtomatik tuzatish
ruff format src tests                    # formatlash
./tekshir.sh                             # hammasi

def f(a: int, b: str = "x") -> bool: ...
xs: list[int] = []
d: dict[str, list[int]] = {}
t: tuple[int, str] = (1, "a")
ixtiyoriy: int | None = None              # 3.10+; eskisi Optional[int]
from collections.abc import Callable, Iterable, Sequence
fn: Callable[[int, str], bool]
from typing import Any, TypeVar, Protocol

from dataclasses import dataclass, field, replace

@dataclass(frozen=True, slots=True)
class Model:
    ism: str
    baho: int = 0
    teglar: list[str] = field(default_factory=list)    # [] EMAS!

    @property
    def katta(self) -> bool:
        return self.baho > 90

yangi = replace(eski, baho=95)             # frozen da o'zgartirish

class LoyihaXato(Exception): ...           # ildiz

class FaylXato(LoyihaXato):
    def __init__(self, yol: str, sabab: str) -> None:
        self.yol, self.sabab = yol, sabab  # MA'LUMOT saqlang, faqat matn emas
        super().__init__(f"{yol}: {sabab}")

raise Yangi(...) from e                    # sababni saqlash
raise Yangi(...) from None                 # sababni yashirish

import pytest

@pytest.mark.parametrize("kirish, kutilgan", [("85", 85), ("0", 0)])
def test_holat(kirish, kutilgan):
    assert f(kirish) == kutilgan

def test_xato():
    with pytest.raises(ValueError, match="son emas"):
        f("abc")

@pytest.fixture
def malumot():
    return [1, 2, 3]

def test_fayl(tmp_path):                   # har testga yangi papka
    (tmp_path / "a.txt").write_text("x", encoding="utf-8")

def test_muhit(monkeypatch):               # vaqtincha o'zgartirish
    monkeypatch.setenv("KALIT", "qiymat")

def test_chiqish(capsys):                  # stdout/stderr ni ushlash
    print("salom")
    assert "salom" in capsys.readouterr().out

def test_jurnal(caplog):                   # jurnalni ushlash
    with caplog.at_level(logging.WARNING):
        ...
    assert "ogohlantirish" in caplog.text

import logging
log = logging.getLogger(__name__)          # HAR modulda

log.debug("tafsilot: %s", x)               # f-string emas, %s
log.info("ish tugadi: %d qator", n)
log.warning("%d qator rad etildi", k)
log.error("bajarilmadi: %s", e)
log.exception("kutilmagan xato")           # faqat except ichida, iz bilan

# FAQAT dastur sozlaydi, kutubxona emas:
logging.basicConfig(level=logging.INFO, stream=sys.stderr,
                    format="%(asctime)s %(levelname)-8s %(name)s: %(message)s")

from pathlib import Path

p = Path("malumot") / "2026" / "f.csv"
p.parent.mkdir(parents=True, exist_ok=True)
matn = p.read_text(encoding="utf-8")       # encoding HAR DOIM
p.write_text(matn, encoding="utf-8")
p.with_suffix(".json")
list(p.parent.glob("*.csv"))               # rglob — ichkilari bilan

import json
json.dumps(d, ensure_ascii=False, indent=2)     # o'zbekcha harflar uchun
json.dumps(d, default=str)                      # date, Decimal uchun

import csv
with p.open("w", encoding="utf-8", newline="") as f:    # newline="" MUHIM
    w = csv.DictWriter(f, fieldnames=[...])
    w.writeheader(); w.writerows(qatorlar)

import sqlite3
con.execute("SELECT * FROM t WHERE ism = ?", (ism,))    # ? — injection dan himoya

import os

def son(nom, sukut):
    xom = os.environ.get(nom)
    return sukut if not xom else int(xom)   # int() xato bersa — ushlang

def mantiqiy(nom, sukut):
    xom = os.environ.get(nom, "").lower()
    if not xom: return sukut
    if xom in {"1","true","ha","on"}: return True
    if xom in {"0","false","yo'q","off"}: return False
    raise ValueError(f"{nom}: mantiqiy qiymat kutilgan")

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=8) as p:        # I/O uchun
    natijalar = list(p.map(f, elementlar))

with ProcessPoolExecutor(max_workers=4) as p:       # CPU uchun
    natijalar = list(p.map(f, elementlar))          # f import qilinadigan modulda bo'lsin!

with ThreadPoolExecutor() as p:
    kelajaklar = {p.submit(f, x): x for x in elementlar}
    for k in as_completed(kelajaklar):
        natija = k.result()

import requests

j = requests.get(url, timeout=5)           # timeout MAJBURIY
j.raise_for_status()
malumot = j.json()

s = requests.Session()                     # ko'p so'rovda tezroq

import time, timeit, cProfile, pstats, tracemalloc
from functools import lru_cache

t0 = time.perf_counter()                   # time.time() EMAS
timeit.timeit(lambda: f(), number=100)

cProfile.run("f()", sort="tottime")        # tottime — nishon, cumtime — yo'nalish

@lru_cache(maxsize=1024)
def qimmat(x): ...

tracemalloc.start(); f(); cho_qqi = tracemalloc.get_traced_memory()[1]