Python UV: Panduan Utama untuk Pengelola Paket Python Tercepat

Apa itu Python UV?

UV adalah pengelola dan penginstal paket Python modern berperforma tinggi yang ditulis dengan Rust. UV dapat menjadi pengganti langsung untuk alat manajemen paket Python tradisional seperti pip, dengan peningkatan signifikan dalam kecepatan, keandalan, dan resolusi dependensi.

Alat ini mewakili generasi baru pengelola paket Python, dirancang untuk mengatasi titik nyeri umum dalam ekosistem Python seperti waktu instalasi yang lambat, konflik dependensi, dan kompleksitas pengelolaan environment. UV mencapai hal ini melalui arsitektur inovatif dan implementasi yang efisien, menjadikannya 10–100 kali lebih cepat dibanding pengelola paket tradisional.

Fitur utama yang membuat UV menonjol:

• Instalasi paket dan resolusi dependensi yang sangat cepat
• Kompatibel dengan alat dan alur kerja Python yang sudah ada
• Manajemen virtual environment bawaan
• Dukungan untuk standar packaging modern
• Penguncian dependensi yang andal dan environment yang dapat direplikasi
• Penggunaan memori efisien, terutama untuk proyek besar

Baik untuk proyek pribadi kecil maupun aplikasi Python skala besar, UV menawarkan solusi manajemen paket yang tangguh dan efisien. Dalam tutorial ini, kami akan membahas semua aspek penting UV agar Anda bisa langsung menggunakannya.

Ringkasnya

• UV adalah pengelola paket Python bertenaga Rust yang 10–100x lebih cepat daripada pip
• Instal dengan curl -LsSf https://astral.sh/uv/install.sh | sh
• Inisialisasi proyek dengan uv init dan tambahkan dependensi dengan uv add package
• Jalankan skrip dengan uv run script.py—tanpa perlu aktivasi virtual environment secara manual
• UV menggantikan pip, virtualenv, pyenv, dan pip-tools dalam satu alat
• Lock file (uv.lock) menjamin environment yang dapat direproduksi lintas mesin
• Gunakan uvx untuk menjalankan alat CLI seperti black dan ruff tanpa instalasi permanen

Perbedaan Antara UV, Poetry, PIP, Conda, dan virtualenv

Pertanyaan pertama yang sering diajukan pengembang sebelum beralih ke alat baru adalah "Bagaimana perbandingannya dengan yang sudah saya gunakan?". Dalam ranah manajemen dependensi dan proyek Python, empat alat ini sudah paling umum:

• PIP
• Poetry
• Conda
• virtualenv

Mari bandingkan UV dengan masing-masing alat ini untuk membantu Anda memutuskan apakah UV adalah pilihan yang tepat sesuai kebutuhan Anda sebelum masuk ke detailnya.

UV vs. PIP dan virtualenv

PIP dan virtualenv telah lama menjadi alat tradisional untuk manajemen paket Python dan pembuatan virtual environment. Meski fungsional, UV menawarkan beberapa keunggulan menarik:

• Kecepatan: Implementasi Rust UV membuatnya jauh lebih cepat daripada PIP untuk instalasi paket dan resolusi dependensi, sering kali menyelesaikan tugas dalam hitungan detik yang butuh menit di PIP.
• Manajemen environment terintegrasi: Jika virtualenv hanya membuat environment dan PIP hanya mengelola paket, UV menggabungkan keduanya dalam satu alat, menyederhanakan alur kerja.

UV mempertahankan kompatibilitas penuh dengan ekosistem PIP sambil mengatasi keterbatasan utamanya. UV dapat menggunakan file requirements.txt dan indeks paket yang sama, sehingga migrasi berjalan mulus. Perbedaan kunci:

• Kinerja: Unduhan paralel UV dan resolver dependensi yang dioptimalkan membuatnya 10–100x lebih cepat daripada PIP untuk proyek besar.
• Penggunaan memori: UV menggunakan memori jauh lebih sedikit daripada PIP selama instalasi paket dan resolusi dependensi.
• Penanganan galat: UV memberikan pesan kesalahan yang lebih jelas dan resolusi konflik yang lebih baik saat dependensi berbenturan.
• Reproducibility: Pendekatan lockfile UV memastikan environment konsisten di berbagai sistem, sesuatu yang tidak dijamin dengan file requirements.txt dasar.

Walau PIP dan virtualenv tetap layak digunakan, arsitektur modern dan fungsi gabungan UV menjadikannya alternatif menarik bagi pengembang yang mencari performa lebih baik dan alur kerja yang lebih ringkas. Kemampuan menyisipkan UV ke proyek yang ada tanpa mengganggu proses yang mapan sangat menarik bagi tim yang ingin memodernisasi toolchain pengembangan Python secara bertahap.

UV vs. Conda

Mereka yang tidak menggunakan PIP dan virtualenv biasanya beralih ke Conda—dan ada alasannya:

• Conda menyediakan solusi manajemen paket lengkap yang menangani bukan hanya paket Python tetapi juga dependensi tingkat sistem
• Conda unggul dalam mengelola environment komputasi ilmiah kompleks dengan paket seperti NumPy, SciPy, dan TensorFlow
• Environment Conda lebih terisolasi dan dapat direproduksi lintas sistem operasi
• Dukungan bawaan untuk berbagai versi Python dan mudah beralih antarversi
• Distribusi Anaconda menyertakan banyak paket ilmiah pra-instal, memudahkan data scientist

Namun bahkan pengguna Conda yang hardcore pun sebaiknya mempertimbangkan beralih ke UV karena berbagai alasan. (Untuk perbandingan lebih luas alat manajemen environment, lihat Anaconda vs Python: Exploring Their Differences.) Instalasi paket dan resolusi dependensi UV yang sangat cepat dapat mempercepat penyiapan environment secara dramatis dibanding kinerja Conda yang kadang lamban. Jejak sumber dayanya yang minimal berarti penggunaan memori lebih kecil dan waktu mulai lebih cepat. UV juga terintegrasi mulus dengan standar dan alat packaging Python yang ada, memudahkan bekerja dengan ekosistem Python yang lebih luas. Untuk proyek yang tidak memerlukan manajemen paket non-Python milik Conda, UV memberikan solusi yang lebih ringkas dan efisien yang dapat meningkatkan alur kerja pengembangan secara signifikan.

UV vs. Poetry

Saya pengguna Conda hampir tiga tahun, tetapi setelah mencoba Poetry beberapa kali, saya tidak pernah menyentuh Conda yang secepat kura-kura lagi. Saat saya mulai nyaman dengan Poetry, saya menemukan UV dan ia menawarkan kemampuan yang hampir sama dengan Poetry:

• Manajemen dependensi: Keduanya menangani dependensi paket dan virtual environment secara efektif
• Struktur proyek: Keduanya menyediakan alat untuk menginisialisasi dan menstrukturkan proyek Python
• Lock file: Keduanya menghasilkan lock file untuk menjamin environment yang dapat direproduksi
• Publikasi paket: Keduanya mendukung publikasi paket ke PyPI
• Perkakas modern: Keduanya merepresentasikan pendekatan modern terhadap manajemen proyek Python

Namun, fitur pembeda UV adalah kecepatannya yang luar biasa dan penggunaan sumber daya yang minimal. Meski Poetry merupakan peningkatan besar atas alat tradisional, UV membawa kinerja ke level lain berkat implementasi Rust. Selain itu, kompatibilitas UV dengan packaging Python yang ada berarti ia dapat bekerja berdampingan dengan alat lain seperti pip, menawarkan fleksibilitas yang kadang kurang pada pendekatan Poetry yang lebih opinionated.

Berikut tabel yang merangkum perbedaan yang baru saja kita bahas: 

Jika menurut Anda UV layak untuk dicoba, lanjutkan membaca.

Memulai Dengan UV untuk Proyek Python

Di bagian ini, kita membahas cara memulai proyek dari nol menggunakan UV. Jika Anda butuh bantuan terlebih dahulu untuk menyiapkan environment pengembangan Python, lihat panduan kami. Kita akan membahas cara migrasi dari proyek yang sudah ada ke UV pada bagian berikutnya.

Menginstal UV

UV dapat diinstal untuk seluruh sistem menggunakan cURL di macOS dan Linux:

$ curl -LsSf https://astral.sh/uv/install.sh | sh

Dan dengan Powershell di Windows (pastikan Anda menjalankan Powershell dengan hak administrator):

$ powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

UV juga tersedia melalui Homebrew:

$ brew install uv

Instalasi melalui PIP didukung tetapi tidak direkomendasikan:

$ pip install uv  # Make sure you have a virtual environment activated

Setelah itu, Anda dapat memverifikasi instalasi dengan menjalankan uv version:

$ uv version
uv 0.6.14 (2026-03-13)

Memperbarui UV

UV dapat memperbarui dirinya sendiri saat diinstal melalui installer mandiri:

$ uv self update

Jika Anda menginstal UV melalui Homebrew, gunakan brew upgrade uv. Anda juga dapat mengaktifkan autocompletion shell untuk perintah UV:

$ echo 'eval "$(uv generate-shell-completion zsh)"' >> ~/.zshrc  # For Zsh
$ echo 'eval "$(uv generate-shell-completion bash)"' >> ~/.bashrc  # For Bash

Menginisialisasi proyek baru

Bekerja dengan proyek adalah inti pengalaman menggunakan UV. Mulailah dengan menginisialisasi proyek kosong menggunakan perintah uv init:

$ uv init explore-uv
Initialized project explore-uv at /Users/bexgboost/projects/explore-uv

Perintah ini akan langsung membuat direktori explore-uv baru dengan konten berikut:

$ cd explore-uv
$ tree -a
.
├── .gitignore
├── .python-version
├── README.md
├── hello.py
└── pyproject.toml

Git diinisialisasi secara otomatis dan berkas terkait git utama seperti .gitignore dan README.md kosong akan dibuat. Berkas .python-version berisi versi Python yang digunakan untuk proyek, sedangkan pyproject.toml berfungsi sebagai berkas konfigurasi utama untuk metadata proyek dan dependensi. Berkas contoh hello.py juga dibuat untuk membantu Anda mulai dengan cepat.

Anda dapat mempelajari lebih lanjut tentang membuat proyek dari dokumentasi UV.

Menambahkan dependensi awal ke proyek

UV menggabungkan pembuatan environment dan instalasi dependensi dalam satu perintah — uv add:

$ uv add scikit-learn xgboost
Using CPython 3.9.20 interpreter at: /opt/homebrew/opt/python@3.9/bin/python3.9
Creating virtual environment at: .venv
Resolved 6 packages in 1.78s
⠧ Preparing packages... (2/5)
Prepared 5 packages in 1m 23s
Installed 5 packages in 45ms
 + joblib==1.4.2
 + numpy==2.0.2
 + scikit-learn==1.5.2
 ...

Saat pertama kali menjalankan perintah add, UV membuat virtual environment baru di direktori kerja saat ini dan menginstal dependensi yang ditentukan. Pada pemanggilan berikutnya, UV akan menggunakan ulang virtual environment yang ada dan hanya memasang atau memperbarui paket yang baru diminta, memastikan manajemen dependensi yang efisien.

Proses penting lain yang terjadi pada setiap perintah add adalah resolusi dependensi. UV menggunakan resolver dependensi modern yang menganalisis keseluruhan grafik dependensi untuk menemukan himpunan versi paket yang kompatibel dan memenuhi semua kebutuhan. Ini membantu mencegah konflik versi dan memastikan environment yang dapat direproduksi. Resolver mempertimbangkan faktor seperti batasan versi, kompatibilitas versi Python, dan persyaratan spesifik platform untuk menentukan himpunan paket optimal untuk dipasang.

UV juga memperbarui berkas pyproject.toml dan uv.lock setelah setiap perintah penambahan. Berikut tampilan berkas TOML setelah memasang Scikit-learn dan XGBoost:

$ cat pyproject.toml
[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "scikit-learn>=1.5.2",
    "xgboost>=2.0.3",
]

Untuk menghapus dependensi dari environment dan berkas pyproject.toml, Anda dapat menggunakan perintah uv remove. Ini akan mencopot paket dan seluruh child-dependencies-nya:

$ uv remove scikit-learn

Kita akan membahas manajemen dependensi lebih rinci pada bagian berikutnya.

Menjalankan skrip Python dengan UV

Setelah Anda memasang dependensi yang diperlukan, Anda bisa mulai mengerjakan skrip Python seperti biasa. Jika Anda menggunakan VS Code, lihat panduan kami tentang menyiapkan VS Code untuk Python. UV menyediakan beberapa cara untuk menjalankan kode Python:

Untuk menjalankan skrip Python secara langsung, gunakan perintah uv run diikuti nama skrip Anda alih-alih sintaks biasa python script.py:

$ uv run hello.py

Perintah run memastikan skrip dieksekusi di dalam virtual environment yang dibuat UV untuk proyek.

Menjalankan skrip dengan dependensi inline (PEP 723)

UV mendukung metadata skrip inline PEP 723, yang memungkinkan Anda mendeklarasikan dependensi langsung di dalam skrip Python. Ini berguna untuk skrip mandiri yang membutuhkan paket tanpa menyiapkan proyek penuh:

# /// script
# requires-python = ">=3.11"
# dependencies = [
#     "requests",
#     "rich",
# ]
# ///

import requests
from rich.console import Console

console = Console()
response = requests.get("https://api.github.com")
console.print(f"GitHub API status: [bold green]{response.status_code}[/bold green]")

Jalankan skrip dengan uv run, dan UV secara otomatis membuat environment terisolasi dengan dependensi yang dideklarasikan:

$ uv run script.py
GitHub API status: 200

Ini sangat kuat untuk berbagi skrip yang dapat direplikasi dengan rekan kerja—siapa pun yang memasang UV dapat menjalankan skrip tanpa memasang dependensi secara manual.

Mengelola Versi Python di UV

Mengelola versi Python adalah bagian kunci dari manajemen dependensi. UV menyediakan perintah sederhana untuk mengontrol versi Python yang Anda gunakan. Mari jelajahi cara menggunakan perintah uv python.

Memasang versi Python dengan UV

UV dapat memasang dan mengelola versi Python secara langsung, menggantikan kebutuhan alat seperti pyenv:

$ uv python install 3.12
$ uv python install 3.11 3.13  # Install multiple versions at once

Instalasi Python disimpan di ~/.local/share/uv/python/ dan tidak mengganggu Python sistem Anda. Anda juga dapat mem-pin proyek ke versi Python tertentu:

$ uv python pin 3.12

Ini memperbarui berkas .python-version di direktori proyek Anda. UV kemudian akan menggunakan versi ini untuk semua operasi proyek.

Mendaftar versi Python yang ada

Karena umum bagi sistem untuk sudah memiliki Python terpasang, UV secara bawaan dapat menemukan instalasi yang sudah ada. Misalnya, untuk menampilkan semua versi Python yang terdeteksi UV di sistem Anda, jalankan perintah berikut:

$ uv python list --only-installed
cpython-3.13.0-macos-aarch64-none     /opt/homebrew/opt/python@3.13/bin/python3.13 -> ../Frameworks/Python.framework/Versions/3.13/bin/python3.13
cpython-3.12.7-macos-aarch64-none     /opt/homebrew/opt/python@3.12/bin/python3.12 -> ../Frameworks/Python.framework/Versions/3.12/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3 -> python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python -> python3.12
cpython-3.11.10-macos-aarch64-none    /opt/homebrew/opt/python@3.11/bin/python3.11 -> ../Frameworks/Python.framework/Versions/3.11/bin/python3.11
cpython-3.11.7-macos-aarch64-none     /Users/bexgboost/.local/share/uv/python/cpython-3.11.7-macos-aarch64-none/bin/python3 -> python3.11
cpython-3.10.15-macos-aarch64-none    /opt/homebrew/opt/python@3.10/bin/python3.10 -> ../Frameworks/Python.framework/Versions/3.10/bin/python3.10
cpython-3.9.20-macos-aarch64-none     /opt/homebrew/opt/python@3.9/bin/python3.9 -> ../Frameworks/Python.framework/Versions/3.9/bin/python3.9
cpython-3.9.6-macos-aarch64-none      /Library/Developer/CommandLineTools/usr/bin/python3 -> ../../Library/Frameworks/Python3.framework/Versions/3.9/bin/python3

Perintah tersebut dengan benar mendeteksi versi Python yang saya pasang melalui Conda dan Brew.

Mengubah versi Python untuk proyek saat ini 

Anda dapat beralih versi Python untuk proyek UV Anda kapan saja selama versi baru memenuhi spesifikasi di berkas pyproject.toml Anda. Misalnya, berkas berikut memerlukan Python versi 3.9 ke atas:

...
requires-python = ">=3.9"

Artinya Anda dapat mengubah versi Python di berkas .python-version ke versi mana pun di atas itu, misalnya 3.11.7. Setelahnya, panggil uv sync.

Perintah ini terlebih dahulu memeriksa instalasi Python yang ada. Jika versi yang diminta tidak ditemukan, UV akan mengunduh dan memasangnya di jalur /Users/username/.local/share/uv/python. UV juga membuat virtual environment baru di direktori proyek, menggantikan yang lama. 

Perintah uv sync menangani semuanya secara otomatis—menciptakan virtual environment baru dan memasang ulang semua dependensi dari berkas pyproject.toml dan uv.lock Anda. Tidak perlu langkah instalasi tambahan.

Perhatikan bahwa terkadang perintah uv dapat memunculkan galat Permission Denied. Dalam kasus tersebut, pastikan gunakan perintah sudo jika Anda menggunakan macOS atau Linux, atau jalankan command prompt dengan hak administrator jika Anda menggunakan Windows. Solusi yang lebih baik adalah mengubah kepemilikan direktori home UV ke pengguna:

$ sudo chown -R $USER ~/.local/share/uv  # macOS or Linux

Untuk mempelajari lebih lanjut tentang mengelola versi Python dengan UV, lihat dokumentasi. 

Apa Itu UV Tools dan Cara Menggunakannya?

Beberapa paket Python diekspos sebagai alat baris perintah seperti black untuk pemformatan kode, flake8 untuk linting, pytest untuk pengujian, mypy untuk pemeriksaan tipe, dan lain-lain. UV menyediakan dua antarmuka khusus untuk mengelola paket ini:

1. Menggunakan uv tool run:

$ uv tool run black hello.py

2. Menggunakan perintah uvx yang lebih singkat dan nyaman:

$ uvx black hello.py

Saat perintah ini dijalankan, UV membuat virtual environment sementara di cache-nya. Alat yang diminta diinstal dan dijalankan dari sana. Dengan kata lain, Anda dapat menggunakan alat baris perintah tanpa memasangnya di virtual environment proyek, menghasilkan eksekusi yang lebih cepat dan dependensi proyek yang lebih bersih.

Poin kunci tentang antarmuka menjalankan tool:

• Bekerja dengan paket Python apa pun yang menyediakan alat baris perintah seperti flake8, mypy, black, atau pytest
• Environment yang di-cache akan dibersihkan otomatis saat membersihkan cache UV
• Environment cache baru dibuat sesuai kebutuhan
• Sempurna untuk penggunaan alat pengembangan sesekali
• Untuk alat yang sering Anda gunakan, pasang secara permanen dengan uv tool install:

$ uv tool install ruff
$ uv tool install black
$ ruff check .  # Now available directly in PATH

Alat yang dipasang permanen tersedia secara global melalui PATH Anda, tanpa mengotori virtual environment proyek mana pun. Anda dapat memperbaruinya dengan uv tool upgrade ruff dan menampilkan semua alat yang terpasang dengan uv tool list.

Baca bagian UV Tools pada dokumentasi untuk mempelajari lebih lanjut tentang antarmuka ini.

Apa Itu Lock File di UV?

Lock file (uv.lock) adalah bagian penting dari manajemen dependensi di UV. Saat Anda menjalankan perintah uv add untuk memasang dependensi, UV secara otomatis membuat dan memperbarui berkas uv.lock. Lock file ini memiliki beberapa tujuan penting:

• Mencatat versi tepat dari semua dependensi dan sub-dependensinya yang dipasang.
• Memastikan build yang dapat direproduksi dengan "mengunci" versi dependensi di berbagai environment.
• Membantu mencegah "dependency hell" dengan mempertahankan versi paket yang konsisten.
• Mempercepat instalasi karena UV dapat menggunakan versi yang sudah dikunci alih-alih menyelesaikan dependensi lagi.

UV mengelola lock file secara otomatis—Anda tidak perlu mengeditnya secara manual. Lock file sebaiknya dikomit ke kontrol versi untuk memastikan semua pengembang menggunakan versi dependensi yang sama.

Perbedaan Antara Lock File dan requirements.txt

Walau lock file dan requirements.txt sama-sama melacak dependensi, keduanya memiliki tujuan dan kasus penggunaan yang berbeda. Lock file berisi informasi detail tentang versi paket yang persis beserta pohon dependensinya, memastikan environment konsisten selama pengembangan. Requirements.txt lebih sederhana, biasanya hanya mencantumkan dependensi langsung, dan didukung luas di berbagai alat Python.

Lock file penting untuk pengembangan guna menjaga build yang dapat direproduksi dan mencegah konflik dependensi. Requirements.txt lebih cocok untuk skenario deployment atau saat berbagi kode dengan pengguna yang mungkin tidak menggunakan UV. Berkas ini juga diperlukan untuk kompatibilitas dengan alat dan layanan yang tidak mendukung format lock file UV.

Anda dapat mempertahankan keduanya dengan menggunakan lock file UV untuk pengembangan sambil menghasilkan requirements.txt untuk deployment. Untuk menghasilkan requirements.txt dari lock file UV, gunakan perintah berikut:

$ uv export -o requirements.txt

Perintah ini membuat berkas teks dengan versi yang dipin berdasarkan lock file Anda, sehingga mudah membagikan dependensi proyek dalam format standar sembari tetap mendapat manfaat dari manajemen dependensi canggih UV selama pengembangan.

Anda dapat mempelajari lebih lanjut tentang mengelola lock file dari dokumentasi. 

Manajemen Dependensi Lanjutan dengan UV

Di bagian ini, kita akan mengeksplorasi metode yang lebih canggih untuk mengelola dependensi di UV. Kita akan mempelajari cara memperbarui dependensi, menjadikannya opsional, atau menjadikannya bagian dari grup dependensi.

Memperbarui dependensi

Dalam proyek jangka panjang, umum untuk memperbarui paket yang Anda gunakan agar mendapatkan fitur terbaru. Atau terkadang, paket yang Anda gunakan memperkenalkan breaking changes dan Anda ingin memastikan versi tersebut tidak terpasang secara tidak sengaja di environment Anda. Perintah add dapat digunakan lagi dalam skenario ini dan skenario lain saat Anda perlu mengubah batasan atau versi dependensi yang ada.

1. Memasang versi terbaru suatu paket:

$ uv add requests

2. Memasang versi tertentu:

$ uv add "requests==2.1.2"

3. Mengubah batasan versi paket:

$ uv add 'requests<3.0.0'

4. Menjadikan dependensi spesifik platform:

$ uv add 'requests; sys_platform="linux"' 

Menambahkan dependensi opsional

Dependensi opsional adalah paket yang tidak diperlukan untuk fungsi inti proyek Anda tetapi mungkin dibutuhkan untuk fitur tertentu. Misalnya, Pandas memiliki ekstra excel dan ekstra plot untuk menghindari pemasangan parser Excel dan matplotlib kecuali jika seseorang secara eksplisit membutuhkannya. Dependensi opsional biasanya dipasang dengan sintaks pip install pandas[plot, excel]. 

Dengan UV, sintaks ini sedikit berbeda. Pertama, pastikan paket Pandas inti terpasang:

$ uv add pandas

Kemudian, pasang dengan ekstra opsionalnya menggunakan notasi tanda kurung siku:

$ uv add "pandas[plot,excel]"

Setelah terselesaikan, dependensi ini akan tercantum di pyproject.toml Anda dengan format berikut:

[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "pandas[plot,excel]>=2.2.3",
    "requests>=2.32.3",
]

Grup dependensi

Grup dependensi memungkinkan Anda untuk mengelompokkan dependensi ke dalam grup logis, seperti dependensi pengembangan, pengujian, atau dokumentasi. Ini berguna untuk memisahkan dependensi produksi dari dependensi pengembangan.

Untuk menambahkan dependensi ke grup tertentu, gunakan flag --group:

$ uv add --group group_name package_name

Kemudian, pengguna dapat mengontrol grup mana yang akan dipasang menggunakan tag --group, --only-group, dan --no-group.

Beralih dari PIP dan Virtualenv ke UV

Migrasi dari PIP dan virtualenv ke UV mudah karena UV mempertahankan kompatibilitas dengan standar packaging Python yang ada. Berikut panduan langkah demi langkah agar transisi berjalan mulus:

1. Mengonversi proyek virtualenv yang sudah ada

Jika Anda memiliki proyek yang menggunakan virtualenv dan pip, mulailah dengan menghasilkan berkas requirements.txt dari environment Anda saat ini jika belum:

$ pip freeze > requirements.txt

Lalu, buat proyek UV baru di direktori yang sama:

$ uv init .

Terakhir, pasang dependensi dari berkas requirements Anda:

$ uv pip install -r requirements.txt

2. Mengganti perintah umum pip/virtualenv

Berikut referensi cepat untuk mengganti perintah pip dan virtualenv umum dengan padanannya di UV:

Setelah migrasi, Anda dapat dengan aman menghapus direktori virtualenv lama dan mulai menggunakan manajemen virtual environment UV. Transisi biasanya mulus, dan Anda selalu dapat kembali ke perintah pip melalui lapisan kompatibilitas pip milik UV jika diperlukan.

Menggunakan UV di CI/CD dan Docker

Kecepatan UV sangat berharga di pipeline CI/CD di mana pemasangan dependensi terjadi pada setiap build. Berikut contoh workflow GitHub Actions yang menggunakan UV:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
        uses: astral-sh/setup-uv@v3
      - name: Set up Python
        run: uv python install 3.12
      - name: Install dependencies
        run: uv sync --frozen --dev
      - name: Run tests
        run: uv run pytest tests/

Flag --frozen memastikan CI menggunakan versi persis seperti di lock file, dan akan gagal jika lock file kedaluwarsa. Ini menjamin build yang dapat direproduksi.

Integrasi Docker

UV juga dapat mempercepat build image Docker secara signifikan:

FROM python:3.12-slim

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-dev --no-editable

COPY . .
CMD ["uv", "run", "python", "app.py"]

Dengan menyalin berkas dependensi terlebih dahulu dan memasang sebelum menyalin kode sumber, Anda memaksimalkan caching layer Docker. Instalasi dependensi hanya dijalankan ulang saat pyproject.toml atau uv.lock berubah.

Kesimpulan

UV merupakan lompatan besar dalam manajemen paket Python, menawarkan alternatif yang modern, cepat, dan efisien terhadap alat tradisional. Keunggulan utamanya meliputi:

• Performa sangat cepat dengan peningkatan 10–100x dibanding pip
• Integrasi mulus dengan standar packaging Python yang ada
• Manajemen virtual environment bawaan
• Resolusi dependensi yang efisien dan dukungan lock file
• Jejak memori dan penggunaan sumber daya yang rendah

Baik Anda memulai proyek baru atau memigrasikan yang sudah ada, UV menawarkan solusi andal yang dapat meningkatkan alur kerja pengembangan Python Anda secara signifikan. Kompatibilitasnya dengan alat yang ada menjadikannya pilihan mudah bagi pengembang yang ingin memodernisasi toolchain tanpa mengganggu proses saat ini.

Seiring ekosistem Python terus berkembang, alat seperti UV menunjukkan bagaimana teknologi modern seperti Rust dapat meningkatkan pengalaman pengembangan sambil mempertahankan kesederhanaan dan aksesibilitas yang dihargai pengembang Python.

Jika Anda ingin mempelajari lebih lanjut tentang manajemen dependensi atau Python secara umum, lihat sumber tambahan berikut:

• Tutorial Python untuk Pemula
• Tutorial PIP Python: Panduan Definitif
• Kursus Mengembangkan Paket Python
• 9 Alternatif Anaconda Teratas untuk Manajemen Environment Python
• Data Scientist in Python | Belajar Python untuk Data Science
• Python Poetry: Manajemen Environment dan Dependensi Python yang Modern dan Efisien