Python kursi18.3-dars: poetry va uv
Python kursi · Sifat va vositalar

18.3-dars: poetry va uv

19 daqiqa3/8-dars

18-QISM — SIFAT VA VOSITALAR · 3-dars


1. Kirish va motivatsiya

O'tgan ikki darsda venv (izolyatsiya) va pip (bog'liqliklar) ni alohida ishlatdik. Bu ishlaydi, lekin qadamlar ko'p: muhit yarat, faollashtir, o'rnat, pip freeze bilan qulfla, requirements.txt ni qo'lda boshqar. Zamonaviy vositalar — poetry va uv — bularning barchasini bitta vositada birlashtiradi: muhit, bog'liqlik, qulflash va nashr. Ular Node.js npm yoki Rust cargo kabi yagona, izchil ish oqimini beradi.

Bu vositalar pyproject.toml — Python loyihasining zamonaviy standart konfiguratsiya fayliga asoslanadi va qulf fayli (lock) bilan to'liq takrorlanuvchanlikni kafolatlaydi.

Real vaziyat. Bir jamoa pip + venv + requirements.txt bilan ishlardi, lekin muammolar takrorlanardi: kimdir muhitni faollashtirishni unutar, requirements.txt va haqiqiy o'rnatilgan versiyalar bir-biriga mos kelmas, bilvosita bog'liqliklar qulflanmagani uchun "menda ishlaydi" muammosi qaytardi. Ular uv ga o'tishdi: uv add requests bitta buyruq bilan muhitni yaratar (kerak bo'lsa), paketni o'rnatar, pyproject.toml ni yangilar va uv.lock ni (barcha bilvosita bog'liqliklar bilan) qulflar. Va bularning hammasi pip dan o'nlab marta tez edi. "Menda ishlaydi" muammosi yo'qoldi.

Bu darsda zamonaviy bog'liqlik vositalarini — poetry va uv ni o'rganamiz.

Bu darsda:

  • Nima uchun poetry/uv — birlashtirilgan ish oqimi
  • pyproject.toml — zamonaviy standart
  • Qulf fayli va to'liq takrorlanuvchanlik
  • poetry ish oqimi
  • uv — tezlik va zamonaviylik
  • pip + venv bilan solishtirish
  • Qaysi vositani tanlash
  • Amaliy: pyproject.toml bilan ishlash

ℹ poetry va uv — tashqi vositalar. Misollarda pyproject.toml tuzilishi tomllib 16.6-bob bilan tahlil qilinadi; vosita buyruqlari tushuntiriladi.


2. Nazariya — chuqur tushuntirish

2.1. Alohida vositalar muammosi

pip + venv + requirements.txt yondashuvining kamchiliklari:

Muammo Tafsilot
Ko'p qadam Yarat, faollashtir, o'rnat, qulfla — alohida
Qo'lda sinxronlash requirements.txt va o'rnatilgan farq qilishi mumkin
Bilvosita qulflanmagan To'liq takrorlanuvchanlik yo'q
Sekin pip katta loyihada sekin
Nashr alohida setup.py/build alohida vosita

poetry/uv bularning barchasini bitta vositada hal qiladi.

2.2. pyproject.toml — zamonaviy standart

pyproject.toml (16.6, TOML) — Python loyihasining zamonaviy konfiguratsiya fayli. U bog'liqliklar, metama'lumot va vosita sozlamalarini bitta joyda saqlaydi:

toml
[project]
name = "wisar"
version = "1.0.0"
description = "IlmHamroh ta'lim platformasi"
requires-python = ">=3.11"
dependencies = [
    "requests>=2.31,<3.0",
    "flask~=3.0",
]

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

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

pyproject.toml — requirements.txt, setup.py va vosita sozlamalarini (ruff, pytest, coverage) birlashtiradi. Bu PEP 621 standarti.

2.3. Qulf fayli (lock)

Qulf fayli — aynan qaysi versiyalar o'rnatilganini (bilvosita bog'liqliklar va xeshlar bilan) yozadi:

Fayl Vosita
poetry.lock poetry
uv.lock uv
requirements.txt (freeze) pip
# uv.lock (soddalashtirilgan)
requests==2.31.0 (xesh: sha256:...)
urllib3==2.1.0 (xesh: sha256:...)     # bilvosita
certifi==2023.11.17 (xesh: sha256:...)

Qulf fayli git'ga qo'shiladi — u loyihani har joyda aynan bir xil qiladi. pyproject.toml — niyat (>=2.31), qulf — haqiqat (==2.31.0).

2.4. poetry ish oqimi

poetry — bog'liqlik va muhitni birga boshqaradigan mashhur vosita:

bash
poetry new wisar              # yangi loyiha (pyproject.toml bilan)
poetry add requests           # bog'liqlik qo'shadi + qulflaydi
poetry add --group dev pytest # dev bog'liqlik
poetry install                # pyproject.toml + lock dan o'rnatadi
poetry run python main.py     # muhitda ishga tushiradi (faollashtirmasdan)
poetry lock                   # qulf faylini yangilaydi
poetry shell                  # muhitni faollashtiradi

poetry muhitni avtomatik yaratadi va boshqaradi — venv ni qo'lda yaratish shart emas.

2.5. uv — tezlik va zamonaviylik

uv — Rust'da yozilgan yangi vosita (2024), pip/poetry ga muqobil, juda tez (10-100x):

bash
uv init wisar                 # yangi loyiha
uv add requests               # bog'liqlik + qulflash + o'rnatish
uv add --dev pytest           # dev bog'liqlik
uv sync                       # muhitni pyproject + lock ga moslaydi
uv run python main.py         # muhitda ishga tushiradi
uv lock                       # qulf faylini yangilaydi
uv pip install ...            # pip-mos interfeys
uv afzalligi Tafsilot
Tezlik Rust, parallel yuklash (10-100x)
Yagona vosita venv + pip + poetry o'rnini bosadi
pip-mos uv pip bilan mavjud ish oqimi
Python versiyalarini ham uv python install 3.12

2.6. Vositalarni solishtirish

Xususiyat pip+venv poetry uv
Muhit boshqaruvi Qo'lda Avtomatik Avtomatik
Qulflash freeze (qisman) poetry.lock uv.lock
Tezlik O'rtacha Sekinroq Juda tez
pyproject.toml Qisman To'liq To'liq
Nashr Alohida Ichida Ichida
O'rganish Oson O'rtacha Oson
Yosh Eski, barqaror 2018 2024, tez rivojlanmoqda

2.7. Qaysi vositani tanlash

Holat Tavsiya
O'rganish, oddiy skript pip + venv (asoslarni bilish muhim)
Yangi loyiha (2025+) uv (tez, zamonaviy)
Mavjud poetry loyiha poetry (davom eting)
Katta jamoa, barqarorlik poetry yoki uv
CI/CD tezligi muhim uv

Vosita tanlash — muhim, lekin asosiy tushunchalar (izolyatsiya, versiya belgilash, qulflash) barcha vositaga umumiy. Avval pip/venv ni tushuning, keyin zamonaviy vositaga o'ting.

2.8. Migratsiya

Dan Ga Usul
requirements.txt pyproject.toml uv add -r requirements.txt yoki qo'lda
poetry uv uv pyproject.toml ni o'qiy oladi
pip uv uv pip install — bir xil interfeys

3. Tez ma'lumotnoma

bash
# poetry
poetry new loyiha; poetry add requests; poetry install; poetry run python main.py

# uv (tavsiya, 2025+)
uv init loyiha; uv add requests; uv sync; uv run python main.py
uv add --dev pytest ruff        # dev bog'liqliklar
uv lock                         # qulflash
toml
# pyproject.toml (PEP 621)
[project]
name = "loyiha"
requires-python = ">=3.11"
dependencies = ["requests>=2.31,<3.0"]

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

Qoidalar

pyproject.toml — zamonaviy standart (PEP 621)
qulf fayli (lock) git'ga — to'liq takrorlanuvchanlik
poetry/uv muhitni avtomatik boshqaradi
uv — tez, zamonaviy (yangi loyiha uchun)
asosiy tushunchalar barcha vositaga umumiy
avval pip/venv, keyin zamonaviy vosita

4. Batafsil misollar

Misollarda pyproject.toml tuzilishi tomllib 16.6-bob bilan tahlil qilinadi; vosita buyruqlari tushuntiriladi.

Misol 1 — pyproject.toml tuzilishi

python
"""pyproject.toml (PEP 621): [project], dependencies, optional-dependencies, build-system; tomllib bilan tahlil; requirements.txt bilan solishtirish."""

import tomllib

PYPROJECT = """
[project]
name = "wisar"
version = "1.0.0"
description = "IlmHamroh ta'lim platformasi"
requires-python = ">=3.11"
dependencies = [
    "requests>=2.31,<3.0",
    "flask~=3.0",
    "python-dotenv==1.0.0",
]

[project.optional-dependencies]
dev = ["pytest>=8.0", "ruff", "coverage"]
docs = ["mkdocs"]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.ruff]
line-length = 100
"""


def main() -> None:
    d = tomllib.loads(PYPROJECT)

    print("=== 1. Loyiha metama'lumoti ===")
    proyekt = d["project"]
    print(f"  nom: {proyekt['name']}")
    print(f"  versiya: {proyekt['version']}")
    print(f"  Python: {proyekt['requires-python']}")

    print("\n=== 2. Asosiy bog'liqliklar ===")
    for dep in proyekt["dependencies"]:
        print(f"  {dep}")

    print("\n=== 3. Ixtiyoriy bog'liqliklar (guruhlar) ===")
    for guruh, deplar in proyekt["optional-dependencies"].items():
        print(f"  [{guruh}]: {deplar}")

    print("\n=== 4. Build tizimi va vosita sozlamalari ===")
    print(f"  build-backend: {d['build-system']['build-backend']}")
    print(f"  ruff line-length: {d['tool']['ruff']['line-length']}")

    print("\n=== 5. requirements.txt bilan solishtirish ===")
    print("  requirements.txt: faqat bog'liqliklar ro'yxati")
    print("  pyproject.toml: bog'liqlik + metama'lumot + vosita sozlamalari (bitta joyda)")
    print(f"  jami asosiy: {len(proyekt['dependencies'])}, dev: {len(proyekt['optional-dependencies']['dev'])}")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Loyiha metama'lumoti ===
  nom: wisar
  versiya: 1.0.0
  Python: >=3.11

=== 2. Asosiy bog'liqliklar ===
  requests>=2.31,<3.0
  flask~=3.0
  python-dotenv==1.0.0

=== 3. Ixtiyoriy bog'liqliklar (guruhlar) ===
  [dev]: ['pytest>=8.0', 'ruff', 'coverage']
  [docs]: ['mkdocs']

=== 4. Build tizimi va vosita sozlamalari ===
  build-backend: hatchling.build
  ruff line-length: 100

=== 5. requirements.txt bilan solishtirish ===
  requirements.txt: faqat bog'liqliklar ro'yxati
  pyproject.toml: bog'liqlik + metama'lumot + vosita sozlamalari (bitta joyda)
  jami asosiy: 3, dev: 3

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Qulf fayli va takrorlanuvchanlik

python
"""qulf fayli aynan versiyalarni (bilvosita + xesh) yozadi; pyproject.toml niyat, lock haqiqat; qulf takrorlanuvchanlikni kafolatlaydi."""

import tomllib

# uv.lock ni soddalashtirilgan ko'rinishi (aslida TOML)
LOCK = """
[[package]]
name = "requests"
version = "2.31.0"
dependencies = ["urllib3", "certifi", "charset-normalizer", "idna"]

[[package]]
name = "urllib3"
version = "2.1.0"

[[package]]
name = "certifi"
version = "2023.11.17"

[[package]]
name = "charset-normalizer"
version = "3.3.2"

[[package]]
name = "idna"
version = "3.6"
"""

PYPROJECT = """
[project]
dependencies = ["requests>=2.31,<3.0"]
"""


def main() -> None:
    proyekt = tomllib.loads(PYPROJECT)
    lock = tomllib.loads(LOCK)

    print("=== 1. pyproject.toml — niyat (oraliq) ===")
    for dep in proyekt["project"]["dependencies"]:
        print(f"  {dep}")

    print("\n=== 2. Qulf fayli — haqiqat (aniq versiyalar) ===")
    for paket in lock["package"]:
        bilvosita = " (bevosita)" if paket["name"] == "requests" else " (bilvosita)"
        print(f"  {paket['name']:22} == {paket['version']}{bilvosita}")

    print("\n=== 3. Bilvosita bog'liqliklar ===")
    bevosita = {"requests"}
    barcha = {p["name"] for p in lock["package"]}
    bilvosita = barcha - bevosita
    print(f"  siz so'ragan: {sorted(bevosita)}")
    print(f"  avtomatik qo'shilgan (bilvosita): {sorted(bilvosita)}")
    print(f"  jami qulflangan: {len(barcha)} paket")

    print("\n=== 4. Nima uchun qulf muhim ===")
    print("  pyproject.toml: 'requests>=2.31' — vaqt o'tishi bilan boshqa versiya o'rnatilishi mumkin")
    print("  uv.lock: 'requests==2.31.0' + barcha bilvosita — HAR JOYDA aynan bir xil")
    print("  ⭐ qulf fayli git'ga qo'shiladi → 'menda ishlaydi' muammosi yo'qoladi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. pyproject.toml — niyat (oraliq) ===
  requests>=2.31,<3.0

=== 2. Qulf fayli — haqiqat (aniq versiyalar) ===
  requests               == 2.31.0 (bevosita)
  urllib3                == 2.1.0 (bilvosita)
  certifi                == 2023.11.17 (bilvosita)
  charset-normalizer     == 3.3.2 (bilvosita)
  idna                   == 3.6 (bilvosita)

=== 3. Bilvosita bog'liqliklar ===
  siz so'ragan: ['requests']
  avtomatik qo'shilgan (bilvosita): ['certifi', 'charset-normalizer', 'idna', 'urllib3']
  jami qulflangan: 5 paket

=== 4. Nima uchun qulf muhim ===
  pyproject.toml: 'requests>=2.31' — vaqt o'tishi bilan boshqa versiya o'rnatilishi mumkin
  uv.lock: 'requests==2.31.0' + barcha bilvosita — HAR JOYDA aynan bir xil
  ⭐ qulf fayli git'ga qo'shiladi → 'menda ishlaydi' muammosi yo'qoladi

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Ish oqimlarini solishtirish

python
"""pip+venv, poetry, uv ish oqimlarini yonma-yon; bir xil vazifa uchun buyruqlar; qadamlar soni va tezlik farqi."""


def main() -> None:
    print("=== 1. Yangi loyiha yaratish ===")
    oqimlar = {
        "pip+venv": ["python -m venv .venv", "source .venv/bin/activate", "pip install requests",
                     "pip freeze > requirements.txt"],
        "poetry": ["poetry new loyiha", "poetry add requests"],
        "uv": ["uv init loyiha", "uv add requests"],
    }
    for vosita, buyruqlar in oqimlar.items():
        print(f"  [{vosita}] — {len(buyruqlar)} qadam:")
        for b in buyruqlar:
            print(f"      $ {b}")

    print("\n=== 2. Bog'liqlik qo'shish ===")
    print("  pip:    pip install X && pip freeze > requirements.txt  (2 qadam, qo'lda sinxron)")
    print("  poetry: poetry add X                                    (1 qadam, avto-qulf)")
    print("  uv:     uv add X                                        (1 qadam, avto-qulf, tez)")

    print("\n=== 3. Loyihani ishga tushirish ===")
    print("  pip:    source .venv/bin/activate && python main.py")
    print("  poetry: poetry run python main.py")
    print("  uv:     uv run python main.py")

    print("\n=== 4. Boshqa kompyuterda tiklash ===")
    print("  pip:    python -m venv .venv && pip install -r requirements.txt")
    print("  poetry: poetry install")
    print("  uv:     uv sync   (eng tez)")

    print("\n=== 5. Xulosa ===")
    print("  pip+venv: ko'p qadam, qo'lda sinxron, o'rtacha tezlik — asoslarni o'rgatadi")
    print("  poetry:   birlashtirilgan, avtomatik qulf, keng qo'llaniladi")
    print("  uv:       birlashtirilgan, eng tez, zamonaviy (2025+ uchun tavsiya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Yangi loyiha yaratish ===
  [pip+venv] — 4 qadam:
      $ python -m venv .venv
      $ source .venv/bin/activate
      $ pip install requests
      $ pip freeze > requirements.txt
  [poetry] — 2 qadam:
      $ poetry new loyiha
      $ poetry add requests
  [uv] — 2 qadam:
      $ uv init loyiha
      $ uv add requests

=== 2. Bog'liqlik qo'shish ===
  pip:    pip install X && pip freeze > requirements.txt  (2 qadam, qo'lda sinxron)
  poetry: poetry add X                                    (1 qadam, avto-qulf)
  uv:     uv add X                                        (1 qadam, avto-qulf, tez)

=== 3. Loyihani ishga tushirish ===
  pip:    source .venv/bin/activate && python main.py
  poetry: poetry run python main.py
  uv:     uv run python main.py

=== 4. Boshqa kompyuterda tiklash ===
  pip:    python -m venv .venv && pip install -r requirements.txt
  poetry: poetry install
  uv:     uv sync   (eng tez)

=== 5. Xulosa ===
  pip+venv: ko'p qadam, qo'lda sinxron, o'rtacha tezlik — asoslarni o'rgatadi
  poetry:   birlashtirilgan, avtomatik qulf, keng qo'llaniladi
  uv:       birlashtirilgan, eng tez, zamonaviy (2025+ uchun tavsiya)

Nima ko'rsatdi: 2.4, 2.5, 2.6-bo'limlar.

Misol 4 — Amaliy: loyiha konfiguratsiyasini tahlil

pyproject.toml ni tahlil qiluvchi va sog'lomligini tekshiruvchi yordamchi yozamiz: metama'lumot to'liqligini, bog'liqliklar versiya belgilanganini, dev/prod ajratilganini va vosita sozlamalarini tekshiradi. Bu — zamonaviy loyiha konfiguratsiyasini to'g'ri tutishning namunasi.

python
"""pyproject.toml sog'ligini tekshirish: metama'lumot to'liqligi, versiyasiz bog'liqliklar, dev/prod ajratilishi, Python versiyasi; tavsiyalar."""

import tomllib
from packaging.requirements import Requirement

PYPROJECT = """
[project]
name = "wisar"
version = "1.0.0"
requires-python = ">=3.11"
dependencies = [
    "requests>=2.31,<3.0",
    "flask~=3.0",
    "pandas",
    "sqlalchemy>=2.0",
]

[project.optional-dependencies]
dev = ["pytest>=8.0", "ruff", "coverage"]

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
"""


def tekshir(matn: str) -> dict:
    d = tomllib.loads(matn)
    proyekt = d.get("project", {})
    hisobot = {"muammolar": [], "yaxshi": []}

    # 1. Metama'lumot to'liqligi
    for maydon in ("name", "version", "requires-python"):
        if maydon in proyekt:
            hisobot["yaxshi"].append(f"'{maydon}' bor")
        else:
            hisobot["muammolar"].append(f"'{maydon}' yo'q")

    # 2. Bog'liqliklar versiyasi
    for dep in proyekt.get("dependencies", []):
        r = Requirement(dep)
        if not str(r.specifier):
            hisobot["muammolar"].append(f"'{r.name}' versiyasiz")
        elif ">=" in str(r.specifier) and "<" not in str(r.specifier):
            hisobot["muammolar"].append(f"'{r.name}' yuqori chegarasiz ({r.specifier})")
        else:
            hisobot["yaxshi"].append(f"'{r.name}' to'g'ri belgilangan")

    # 3. dev/prod ajratilishi
    if "optional-dependencies" in proyekt and "dev" in proyekt["optional-dependencies"]:
        hisobot["yaxshi"].append("dev bog'liqliklar ajratilgan")
    else:
        hisobot["muammolar"].append("dev bog'liqliklar ajratilmagan")

    # 4. build-system
    if "build-system" in d:
        hisobot["yaxshi"].append("build-system belgilangan")

    return hisobot


def main() -> None:
    hisobot = tekshir(PYPROJECT)

    print("=== 1. ✅ Yaxshi ===")
    for y in hisobot["yaxshi"]:
        print(f"  ✅ {y}")

    print("\n=== 2. ⚠️ Muammolar ===")
    for m in hisobot["muammolar"]:
        print(f"  ⚠️ {m}")

    print("\n=== 3. Tavsiyalar ===")
    print("  1. Versiyasiz bog'liqliklarga oraliq belgilang (pandas → pandas>=2.0,<3.0)")
    print("  2. Yuqori chegara qo'shing (sqlalchemy>=2.0 → >=2.0,<3.0)")
    print("  3. uv lock / poetry lock bilan qulflang")

    print("\n=== 4. Xulosa ===")
    toza = len(hisobot["muammolar"]) == 0
    print(f"  konfiguratsiya toza: {toza}")
    print(f"  yaxshi: {len(hisobot['yaxshi'])}, muammo: {len(hisobot['muammolar'])}")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. ✅ Yaxshi ===
  ✅ 'name' bor
  ✅ 'version' bor
  ✅ 'requires-python' bor
  ✅ 'requests' to'g'ri belgilangan
  ✅ 'flask' to'g'ri belgilangan
  ✅ dev bog'liqliklar ajratilgan
  ✅ build-system belgilangan

=== 2. ⚠️ Muammolar ===
  ⚠️ 'pandas' versiyasiz
  ⚠️ 'sqlalchemy' yuqori chegarasiz (>=2.0)

=== 3. Tavsiyalar ===
  1. Versiyasiz bog'liqliklarga oraliq belgilang (pandas → pandas>=2.0,<3.0)
  2. Yuqori chegara qo'shing (sqlalchemy>=2.0 → >=2.0,<3.0)
  3. uv lock / poetry lock bilan qulflang

=== 4. Xulosa ===
  konfiguratsiya toza: False
  yaxshi: 7, muammo: 2

Nima ko'rsatdi: 2.2, 2.7-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"poetry/uv pip ni bilishni almashtiradi" Asoslar barcha vositaga umumiy
"pyproject.toml faqat build uchun" Bog'liqlik, metama'lumot, vosita sozlamalari
"Qulf fayli git'ga qo'shilmaydi" Qo'shiladi — takrorlanuvchanlik uchun
"freeze va lock fayl bir xil" Lock — xesh, bilvosita, tuzilma bilan
"uv faqat tezlik uchun" Yagona vosita — venv+pip+poetry o'rnini bosadi
"Bitta to'g'ri vosita bor" Kontekstga bog'liq (o'rganish, jamoa, tezlik)
"poetry/uv bilan venv shart emas" Ular venv ni ichida boshqaradi
"requirements.txt eskirgan" Hali keng ishlatiladi, lekin pyproject afzal

6. Keng tarqalgan xatolar va yechimlari

1. Qulf faylini git'ga qo'shmaslik

gitignore
poetry.lock                        # ❌ takrorlanuvchanlik yo'qoladi
# ✅ qulf faylini git'ga qo'shing (ilova uchun)

2. pyproject.toml ni qo'lda tahrirlab, qulflamaslik

bash
# dependencies ga qo'lda qo'shish     # ❌ lock eskiradi
uv add requests                    # ✅ pyproject + lock birga

3. Vosita buyruqlarini aralashtirish

bash
poetry add X && pip install Y      # ❌ ikki vosita bir muhitda
poetry add X && poetry add Y       # ✅ bitta vosita

4. Asoslarni o'tkazib, to'g'ridan-to'g'ri poetry

bash
# venv/pip ni bilmasdan poetry       # ⚠️ muammo bo'lsa tushunmaysiz
# ✅ avval asoslarni o'rganing

5. dev va prod bog'liqliklarni aralashtirish

toml
dependencies = ["requests", "pytest"]   # ❌ pytest prod'da kerak emas
[project.optional-dependencies]
dev = ["pytest"]                    # ✅ ajrating

6. Python versiyasini belgilamaslik

toml
[project]
name = "loyiha"                    # ❌ requires-python yo'q
requires-python = ">=3.11"         # ✅

7. uv run o'rniga qo'lda faollashtirish

bash
source .venv/bin/activate && python main.py   # ⚠️ poetry/uv da shart emas
uv run python main.py              # ✅ avtomatik

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 18.1–18.2-darslar (o'tilgan): venv, pip — poetry/uv ular o'rnini birlashtiradi
  • 16.6-dars (o'tilgan): TOML — pyproject.toml formati
  • 18.4–18.5-darslar: ruff, black — pyproject.toml da sozlanadi
  • 19-qism: paketlash — pyproject.toml va nashr
  • 28-qism: CI/CD — uv sync bilan tez o'rnatish

8. Eng yaxshi amaliyotlar

  1. pyproject.toml — zamonaviy standart (PEP 621) ishlating.

  2. Qulf faylini (poetry.lock, uv.lock) git'ga qo'shing.

  3. Bog'liqlikni vosita orqali qo'shing (uv add), qo'lda tahrirlab qulflamang.

  4. dev va prod bog'liqliklarni ajrating.

  5. requires-python bilan Python versiyasini belgilang.

  6. Yangi loyiha (2025+) uchun uv — tez va zamonaviy.

  7. Avval pip/venv asoslarini o'rganing, keyin zamonaviy vositaga o'ting.

  8. poetry run/uv run bilan muhitni avtomatik ishlating.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
import tomllib
t = '''
[project]
name = "test"
requires-python = ">=3.11"
dependencies = ["requests>=2.31", "flask"]
[project.optional-dependencies]
dev = ["pytest"]
'''
d = tomllib.loads(t)
1.  print(d["project"]["name"])
2.  print(len(d["project"]["dependencies"]))
3.  print(d["project"]["dependencies"][1])
4.  print(d["project"]["optional-dependencies"]["dev"])
5.  print("version" in d["project"])
6.  print(type(d["project"]["dependencies"]).__name__)
7.  # uv add X qaysi ikki faylni yangilaydi?
8.  # qulf fayli git'ga qo'shiladimi?
9.  # poetry muhitni qo'lda yaratish kerakmi?
10. # uv qaysi tilda yozilgan?
11. # pyproject.toml qaysi formatda?
12. # requires-python nimani belgilaydi?
Javoblar
  1. test
  2. 2
  3. flask
  4. ['pytest']
  5. False
  6. list
  7. pyproject.toml va uv.lock
  8. Ha
  9. Yo'q — avtomatik
  10. Rust
  11. TOML
  12. Loyiha uchun kerakli Python versiyasi

Vazifa 2: Xatolarni tuzating

toml
1.  [project]
    name = "loyiha"
    dependencies = ["requests", "flask"]     # versiyasiz

2.  dependencies = ["requests", "pytest", "coverage"]   # dev aralash

3.  [project]
    name = "loyiha"
    # requires-python yo'q

4.  # .gitignore:
    uv.lock                                  # qulf git'ga qo'shilmagan

5.  # ish oqimi:
    # poetry add X
    # pip install Y                          # ikki vosita
Javoblar
toml
1.  dependencies = ["requests>=2.31,<3.0", "flask~=3.0"]

2.  dependencies = ["requests>=2.31,<3.0"]
    [project.optional-dependencies]
    dev = ["pytest>=8.0", "coverage"]

3.  [project]
    name = "loyiha"
    requires-python = ">=3.11"

4.  # .gitignore dan uv.lock ni olib tashlang
    # (qulf fayli git'ga qo'shiladi)

5.  # bitta vosita:
    # uv add X
    # uv add Y

Vazifa 3: pyproject.toml yaratuvchi

Interaktiv yoki argumentli skript:

  1. Loyiha nomi, versiya, Python versiyasini so'rasin
  2. pyproject.toml ni PEP 621 formatida yozsin
  3. dev bog'liqliklar guruhini qo'shsin
  4. tomllib bilan qayta o'qib to'g'riligini tekshirsin

Vazifa 4: Konfiguratsiya migratori

requirements.txt → pyproject.toml:

  1. requirements.txt ni o'qing (packaging.Requirement)
  2. [project.dependencies] ga o'tkazing
  3. dev bog'liqliklarni (-dev.txt bo'lsa) ajrating
  4. Natijani tomllib bilan tekshiring

Vazifa 5: Vosita solishtiruvchi

Bir loyiha uchun uch ish oqimini hujjatlang:

  1. pip+venv, poetry, uv uchun bir xil vazifalar
  2. Har biriga qadamlar soni va buyruqlar
  3. Afzallik/kamchilik jadvali
  4. Qaysi holatda qaysi biri afzal — tavsiya

Vazifa 6: Qulf fayli tahlili

uv.lock yoki poetry.lock (TOML) ni tahlil qiling:

  1. Bevosita va bilvosita bog'liqliklarni ajrating
  2. Har paket versiyasini chiqaring
  3. Bog'liqlik daraxtini quring
  4. pyproject.toml bilan nomuvofiqliklarni toping

Vazifa 7: O'ylash

Python paket ekotizimida yillar davomida ko'p vosita paydo bo'ldi: easy_install, pip, pipenv, poetry, pdm, va endi uv. Boshqa tillar (Rust cargo, Node npm) bitta rasmiy vositaga ega. Nima uchun Python'da bunday "vositalar ko'pligi" muammosi mavjud, va uv kabi yangi vositalar buni hal qila oladimi?

Javob

Qisqa javob: Python'da vositalar ko'pligi tarixiy va tashkiliy sabablardan: Python paketlash markazlashmagan — rasmiy "cargo" yo'q, har muammoni turli jamoalar turli yo'l bilan hal qildi. Bu Python'ning ochiq, yosh (1991) va OS bilan chambarchas (tizim Python) tabiatidan kelib chiqadi. uv va standartlar (pyproject.toml, PEP lar) bu tarqoqlikni kamaytirmoqda, lekin to'liq birlik — sekin jarayon, chunki mavjud ekotizim va orqaga moslik saqlanishi kerak.

1. Nega vositalar ko'p

Sabab Tafsilot
Markazsizlik Rasmiy yagona vosita yo'q
Tarix Har davr o'z yechimini yaratdi
Turli ehtiyoj Ilova vs kutubxona vs skript
Tizim Python OS bilan chalkashlik (Linux)
Orqaga moslik Eski vositalar yo'qolmaydi

2. Cargo/npm bilan farq

Til Nega yagona
Rust (cargo) Boshidan rasmiy, markazlashgan
Node (npm) Rasmiy, standart
Python Ekotizim tarqoq, standartlar keyin keldi

3. Standartlashtirish harakatlari

Standart Nima birlashtiradi
pyproject.toml (PEP 518, 621) Konfiguratsiya formati
PEP 517 Build interfeysi
PEP 440 Versiya belgilash
uv Yagona, tez vosita

4. uv nima o'zgartiradi

Xususiyat Ta'sir
Yagona vosita venv+pip+poetry o'rnini bosadi
Tezlik Qabul qilishni tezlashtiradi
Standartlarga mos pyproject.toml, PEP lar
pip-mos Migratsiya oson

5. To'liq birlik bo'ladimi

Omil Ta'sir
Ekotizim inertsiyasi Mavjud loyihalar ko'p
Orqaga moslik Eski vositalar qoladi
Standartlar Umumiy asos yaratmoqda
uv momentum Tez qabul qilinmoqda

6. Muhandislik saboqlari

  1. Erta standartlashtirish — uzoq muddatli birlik
  2. Markazsizlik — moslashuvchanlik, lekin tarqoqlik
  3. Standartlar (pyproject.toml) — vositalarni birlashtiradi
  4. Yangi vosita ekotizimni yaxshilaydi, lekin sekin

7. Xulosa

  1. Python vositalar ko'pligi — markazsizlik va tarixdan
  2. Cargo/npm boshidan rasmiy, Python keyin standartlashtirdi
  3. pyproject.toml va uv birlikni kuchaytirmoqda
  4. To'liq birlik — sekin, lekin yo'nalish to'g'ri

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda zamonaviy bog'liqlik vositalarini — poetry va uv ni o'rgandik.

Eng muhim uch fikr:

  1. poetry/uv alohida vositalarni birlashtiradi. pip + venv + requirements.txt yondashuvida qadamlar ko'p va qo'lda sinxronlash kerak. poetry va uv muhit, bog'liqlik, qulflash va nashrni bitta vositada birlashtiradi: uv add requests bitta buyruq bilan muhitni yaratadi, paketni o'rnatadi, pyproject.toml ni yangilaydi va qulf faylini yangilaydi. Ular muhitni avtomatik boshqaradi — qo'lda venv yaratish va faollashtirish shart emas.

  2. pyproject.toml va qulf fayli. pyproject.toml (PEP 621, TOML) — Python loyihasining zamonaviy standarti: bog'liqliklar, metama'lumot va vosita sozlamalarini bitta joyda saqlaydi. Qulf fayli (poetry.lock, uv.lock) — aynan qaysi versiyalar (bilvosita bog'liqliklar va xeshlar bilan) o'rnatilganini yozadi: pyproject.toml niyat (>=2.31), qulf haqiqat (==2.31.0). Qulf fayli git'ga qo'shiladi va "menda ishlaydi" muammosini yo'q qiladi.

  3. uv — tezlik va zamonaviylik, lekin asoslar umumiy. uv (Rust'da, 2024) pip/poetry dan o'nlab marta tez va yagona vosita sifatida venv+pip+poetry o'rnini bosadi. Yangi loyiha (2025+) uchun tavsiya. Ammo vosita tanlash muhim bo'lsa-da, asosiy tushunchalar — izolyatsiya, versiya belgilash, qulflash — barcha vositaga umumiy. Avval pip/venv asoslarini tushunib, keyin zamonaviy vositaga o'ting.

Keyingi darsda kod sifatining bir jihatiga — lint ga o'tamiz: ruff bilan kodni avtomatik tekshirish, xatolar va uslub muammolarini kod ishga tushmasdan topish.

Sifat va vositalar · 3-dars yakunlandi

18.3-dars: poetry va uv

19 daqvaqt
0belgi
Keyingi dars: 18.4-dars: ruff — lint
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0