Standart kutubxona: har kuni kerak bo'ladigan modullar

from datetime import date, datetime, timedelta, timezone
from zoneinfo import ZoneInfo
 
now = datetime.now(ZoneInfo("Asia/Tashkent"))      # vaqt zonasi bilan
today = date.today()
 
now.isoformat()                         # '2026-10-01T14:30:00+05:00' — saqlash va API uchun
now.strftime("%d.%m.%Y %H:%M")          # '01.10.2026 14:30' — foydalanuvchiga ko'rsatish
now.astimezone(timezone.utc)            # UTC'ga o'tkazish
 
datetime.fromisoformat("2026-10-01T09:00:00+05:00")      # ISO satrdan
datetime.strptime("01.10.2026", "%d.%m.%Y")              # ixtiyoriy formatdan
 
next_month = now + timedelta(days=30)
(date(2026, 12, 31) - date(2026, 10, 1)).days            # 91

datetime.now() - datetime.now(timezone.utc)
# TypeError: can't subtract offset-naive and offset-aware datetimes

import re
 
text = "Aloqa: +998 90 123-45-67, aziz@mail.uz va info@aidoc.uz. Sana: 2026-10-01."
 
re.findall(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)+", text)   # ['aziz@mail.uz', 'info@aidoc.uz']
re.findall(r"\b\d{4}-\d{2}-\d{2}\b", text)          # ['2026-10-01']
 
m = re.search(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})", text)
if m:
    m.group("y")          # '2026'
    m.groupdict()         # {'y': '2026', 'm': '10', 'd': '01'}
 
re.sub(r"\d", "#", "a1b22")              # 'a#b##'
re.split(r"[,;]\s*", "a, b;c")            # ['a', 'b', 'c']
re.fullmatch(r"[a-z0-9-]+", "ok-slug")   # butun satr mos kelishi kerak

re.findall(r"<.+>", "<a><b>")      # ['<a><b>'] — ochko'z (greedy): iloji boricha ko'p
re.findall(r"<.+?>", "<a><b>")     # ['<a>', '<b>'] — dangasa (lazy): iloji boricha kam

PHONE = re.compile(r"\+998\s?(\d{2})\s?(\d{3})-?(\d{2})-?(\d{2})")   # bir marta kompilyatsiya
PHONE.search(text).groups()        # ('90', '123', '45', '67')
 
re.findall(r"error", log, flags=re.IGNORECASE)
re.search(r"```json(.*?)```", reply, flags=re.DOTALL)    # . yangi qatorni ham ushlasin

import argparse
from pathlib import Path
 
 
def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Sentiment modelini o'qitish")
    p.add_argument("data", type=Path, help="train.jsonl fayli")
    p.add_argument("--epochs", type=int, default=10)
    p.add_argument("--lr", type=float, default=3e-4)
    p.add_argument("--model", choices=["small", "large"], default="small")
    p.add_argument("--dry-run", action="store_true", help="faqat tekshirish, o'qitmaslik")
    p.add_argument("--tags", nargs="*", default=[])
    return p.parse_args()
 
 
def main() -> None:
    args = parse_args()
    print(args.data, args.epochs, args.dry_run)     # --dry-run → args.dry_run
 
 
if __name__ == "__main__":
    main()

import os
import sys
 
os.environ.get("HOME")              # muhit o'zgaruvchilari (9-bob)
os.cpu_count()                      # yadrolar soni — ProcessPoolExecutor uchun
os.getpid()                         # joriy jarayon ID'si
 
sys.argv                            # buyruq qatori argumentlari (xom)
sys.executable                      # qaysi Python ishlayapti (1-bob mashqi)
sys.version_info >= (3, 12)         # versiya tekshiruvi
sys.exit(1)                         # chiqish kodi bilan tugatish (0 — muvaffaqiyat)
print("xato", file=sys.stderr)      # xatolar stderr'ga

import subprocess
 
result = subprocess.run(
    ["git", "rev-parse", "--short", "HEAD"],    # ro'yxat sifatida — shell'siz
    capture_output=True,
    text=True,
    check=True,             # chiqish kodi 0 bo'lmasa — CalledProcessError
    timeout=30,
)
commit = result.stdout.strip()   # tajriba natijalariga kod versiyasini yozish uchun

import time
 
time.time()           # Unix vaqti (1970'dan beri soniyalar) — vaqt belgisi uchun
time.perf_counter()   # eng aniq taymer — davomiylikni o'lchash uchun
time.monotonic()      # hech qachon orqaga ketmaydi — timeout va limitlar uchun
time.sleep(0.5)

import random
 
random.seed(42)                     # global holat — takrorlanuvchanlik uchun
rng = random.Random(42)             # ✅ yaxshiroq: alohida generator obyekti
rng.random()                        # 0.6394267984578837 — [0, 1)
rng.randint(1, 6)                   # 1..6 (ikkala chet kiradi)
rng.choice(["a", "b", "c"])
rng.sample(range(100), 5)           # takrorlanmasdan 5 ta
rng.shuffle(items)                  # joyida aralashtiradi
rng.choices(["a", "b"], weights=[0.9, 0.1], k=10)    # og'irlik bilan, takrorlanib
rng.gauss(0, 1)                     # normal taqsimot

import math
import statistics as st
 
math.sqrt(16), math.log(100, 10), math.exp(1), math.pi
math.isclose(a, b), math.isnan(x), math.isfinite(x)     # 2-bob
math.prod([1, 2, 3]), math.comb(5, 2), math.factorial(5)
math.ceil(4.1), math.floor(4.9)
 
data = [2, 4, 4, 4, 5, 5, 7, 9]
st.mean(data)            # 5
st.median(data)          # 4.5
st.stdev(data)           # 2.138... — tanlanma (n-1)
st.pstdev(data)          # 2.0 — bosh to'plam (n)
st.quantiles(data, n=4)  # [4.0, 4.5, 6.5] — kvartillar

import hashlib
import uuid
 
hashlib.sha256("salom".encode()).hexdigest()      # mazmun "barmoq izi"
uuid.uuid4()                                      # tasodifiy noyob ID

import sqlite3
 
con = sqlite3.connect("results.db")
con.execute("""CREATE TABLE IF NOT EXISTS runs (
    id INTEGER PRIMARY KEY, model TEXT, lr REAL, accuracy REAL, created TEXT
)""")
 
with con:                                  # tranzaksiya: muvaffaqiyatda commit, xatoda rollback
    con.execute(
        "INSERT INTO runs (model, lr, accuracy, created) VALUES (?, ?, ?, datetime('now'))",
        ("small", 3e-4, 0.912),            # ? — parametrlar: SQL injection'dan himoya
    )
 
best = con.execute("SELECT model, lr, accuracy FROM runs ORDER BY accuracy DESC LIMIT 3").fetchall()

import httpx
 
resp = httpx.get("https://api.github.com/repos/python/cpython", timeout=10)
resp.raise_for_status()             # 4xx/5xx bo'lsa — xato
data = resp.json()
data["stargazers_count"]

"""Tajribani ishga tushiradi va natijani SQLite'ga yozadi."""
 
import argparse
import json
import logging
import random
import sqlite3
import subprocess
import time
from datetime import datetime, timezone
from pathlib import Path
 
log = logging.getLogger("run")
 
 
def git_commit() -> str:
    try:
        out = subprocess.run(["git", "rev-parse", "--short", "HEAD"],
                             capture_output=True, text=True, check=True, timeout=5)
        return out.stdout.strip()
    except (OSError, subprocess.SubprocessError):
        return "unknown"
 
 
def fake_train(lr: float, epochs: int, seed: int) -> float:
    rng = random.Random(seed)
    time.sleep(0.1)
    return round(0.8 + rng.random() * 0.1 - abs(lr - 3e-4) * 50, 4)
 
 
def main() -> None:
    p = argparse.ArgumentParser()
    p.add_argument("--lr", type=float, default=3e-4)
    p.add_argument("--epochs", type=int, default=10)
    p.add_argument("--seed", type=int, default=42)
    p.add_argument("--db", type=Path, default=Path("runs.db"))
    args = p.parse_args()
    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
 
    start = time.perf_counter()
    acc = fake_train(args.lr, args.epochs, args.seed)
    elapsed = time.perf_counter() - start
 
    con = sqlite3.connect(args.db)
    with con:
        con.execute("""CREATE TABLE IF NOT EXISTS runs (
            id INTEGER PRIMARY KEY, created TEXT, commit_sha TEXT, params TEXT, accuracy REAL, seconds REAL)""")
        con.execute("INSERT INTO runs (created, commit_sha, params, accuracy, seconds) VALUES (?, ?, ?, ?, ?)",
                    (datetime.now(timezone.utc).isoformat(), git_commit(),
                     json.dumps(vars(args), default=str), acc, round(elapsed, 3)))
    log.info("accuracy=%.4f (%.2fs) → %s", acc, elapsed, args.db)
 
 
if __name__ == "__main__":
    main()