Ishlash va yuklama testlari

def test_tez_ishlaydi():
    boshlanish = time.perf_counter()
    hisobla(katta_malumot)
    assert time.perf_counter() - boshlanish < 0.1     # yomon

import sqlite3

SXEMA = """
CREATE TABLE mijoz (id INTEGER PRIMARY KEY, ism TEXT NOT NULL);
CREATE TABLE buyurtma (
    id       INTEGER PRIMARY KEY,
    mijoz_id INTEGER NOT NULL REFERENCES mijoz(id),
    summa    INTEGER NOT NULL
);
"""


def baza_yarat(ulanish, mijozlar_soni=50):
    ulanish.executescript(SXEMA)
    for i in range(1, mijozlar_soni + 1):
        ulanish.execute("INSERT INTO mijoz VALUES (?, ?)", (i, f"Mijoz {i}"))
        ulanish.execute(
            "INSERT INTO buyurtma (mijoz_id, summa) VALUES (?, ?)",
            (i, i * 1000),
        )


def royxat_sekin(ulanish):
    """Har buyurtma uchun mijozni alohida so'raydi - N+1 muammosi."""
    buyurtmalar = ulanish.execute("SELECT id, mijoz_id, summa FROM buyurtma").fetchall()
    natija = []
    for buyurtma_id, mijoz_id, summa in buyurtmalar:
        qator = ulanish.execute(
            "SELECT ism FROM mijoz WHERE id = ?", (mijoz_id,)
        ).fetchone()
        natija.append({"id": buyurtma_id, "mijoz": qator[0], "summa": summa})
    return natija


def royxat_tez(ulanish):
    """Bitta so'rov bilan hammasini oladi."""
    qatorlar = ulanish.execute(
        "SELECT b.id, m.ism, b.summa "
        "FROM buyurtma b JOIN mijoz m ON m.id = b.mijoz_id"
    ).fetchall()
    return [{"id": i, "mijoz": ism, "summa": s} for i, ism, s in qatorlar]

import sqlite3

import pytest

from magazin import baza_yarat


class SorovHisoblagich:
    """Ulanishdan o'tgan SQL so'rovlarini sanaydi."""

    def __init__(self, ulanish):
        self.sorovlar = []
        ulanish.set_trace_callback(self.sorovlar.append)

    @property
    def soni(self):
        return len(self.sorovlar)


@pytest.fixture
def ulanish():
    aloqa = sqlite3.connect(":memory:")
    baza_yarat(aloqa)
    yield aloqa
    aloqa.close()


@pytest.fixture
def hisoblagich(ulanish):
    return SorovHisoblagich(ulanish)

from magazin import royxat_sekin, royxat_tez


def test_ikkala_usul_bir_xil_natija(ulanish):
    assert royxat_sekin(ulanish) == royxat_tez(ulanish)


def test_sekin_usul_har_qator_uchun_sorov_yuboradi(ulanish, hisoblagich):
    royxat_sekin(ulanish)

    assert hisoblagich.soni == 51


def test_tez_usul_bitta_sorov_yuboradi(ulanish, hisoblagich):
    royxat_tez(ulanish)

    assert hisoblagich.soni == 1

pytest -q -p no:randomly test_sorovlar.py

def bormi(elementlar, izlanayotgan):
    """Bir xil kod, lekin tezligi ma'lumot turiga bog'liq.

    Ro'yxat berilsa - O(n): har element ko'rib chiqiladi.
    To'plam berilsa - O(1): xesh bo'yicha to'g'ridan-to'g'ri topiladi.
    """
    return izlanayotgan in elementlar

import time

from qidiruv import bormi


def olcha(malumot, marta=200):
    boshlanish = time.perf_counter()
    for _ in range(marta):
        bormi(malumot, -1)             # hech qachon topilmaydi - eng yomon holat
    return time.perf_counter() - boshlanish


royxat = list(range(200_000))
toplam = set(royxat)

royxat_vaqti = olcha(royxat)
toplam_vaqti = olcha(toplam)

print(f"ro'yxatda qidirish: ~{royxat_vaqti:.4f} soniya")
print(f"to'plamda qidirish: ~{toplam_vaqti:.6f} soniya")
print(f"farq: ~{royxat_vaqti / toplam_vaqti:.0f} baravar")

python3 olcham.py

import time

from qidiruv import bormi


def olcha(hajm, marta=100):
    malumot = list(range(hajm))
    boshlanish = time.perf_counter()
    for _ in range(marta):
        bormi(malumot, -1)
    return time.perf_counter() - boshlanish


def test_royxatda_qidirish_chiziqli_osadi():
    kichik = olcha(50_000)
    katta = olcha(100_000)

    nisbat = katta / kichik

    # ikki barobar ko'p element - taxminan ikki barobar ko'p vaqt.
    # chegaralar keng: o'lchov shovqini kvadratik o'sishdan kichik.
    assert 1.2 < nisbat < 4.0

pytest -q -p no:randomly test_osish.py

pip install flask

import sys

from flask import Flask

app = Flask(__name__)


@app.get("/salom")
def salom():
    return {"xabar": "assalomu alaykum"}


if __name__ == "__main__":
    app.run(port=int(sys.argv[1]), threaded=True)

import socket
import subprocess
import sys
import time
import urllib.request
from concurrent.futures import ThreadPoolExecutor

import pytest

SOROVLAR = 200
OQIMLAR = 8


def bosh_port():
    with socket.socket() as s:
        s.bind(("127.0.0.1", 0))
        return s.getsockname()[1]


@pytest.fixture(scope="module")
def manzil():
    port = bosh_port()
    jarayon = subprocess.Popen(
        [sys.executable, "veb.py", str(port)],
        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
    )
    tugash = time.monotonic() + 15
    while time.monotonic() < tugash:
        try:
            with socket.create_connection(("127.0.0.1", port), timeout=0.2):
                break
        except OSError:
            time.sleep(0.05)
    try:
        yield f"http://127.0.0.1:{port}"
    finally:
        jarayon.terminate()
        jarayon.wait(timeout=5)


def test_barcha_sorovlar_muvaffaqiyatli(manzil):
    def sorov(_):
        with urllib.request.urlopen(manzil + "/salom", timeout=10) as javob:
            return javob.status

    boshlanish = time.perf_counter()
    with ThreadPoolExecutor(max_workers=OQIMLAR) as bajaruvchi:
        kodlar = list(bajaruvchi.map(sorov, range(SOROVLAR)))
    davomiylik = time.perf_counter() - boshlanish

    print(f"\n{SOROVLAR} so'rov, {OQIMLAR} oqim: ~{davomiylik:.2f} soniya")
    print(f"soniyasiga: ~{SOROVLAR / davomiylik:.0f} so'rov")

    assert kodlar == [200] * SOROVLAR

pytest -q -s -p no:randomly test_yuklama.py

python3 -m cProfile -s cumtime olcham.py