Python UV: सबसे तेज़ Python पैकेज मैनेजर के लिए अंतिम मार्गदर्शिका

Python UV क्या है?

UV एक आधुनिक, उच्च-प्रदर्शन वाला Python पैकेज मैनेजर और इंस्टॉलर है, जो Rust में लिखा गया है। यह पारंपरिक Python पैकेज मैनेजमेंट टूल्स जैसे pip का ड्रॉप-इन रिप्लेसमेंट है और गति, विश्वसनीयता तथा डिपेंडेंसी रेज़ोल्यूशन में बड़े सुधार प्रदान करता है।

यह टूल Python इकोसिस्टम के आम दर्द-बिंदुओं—जैसे धीमी इंस्टॉलेशन, डिपेंडेंसी कॉन्फ्लिक्ट्स, और जटिल एन्वायरनमेंट मैनेजमेंट—को संबोधित करने के लिए डिज़ाइन किए गए नए दौर के पैकेज मैनेजर्स का प्रतिनिधित्व करता है। अपनी अभिनव आर्किटेक्चर और कुशल इम्प्लीमेंटेशन के कारण UV पारंपरिक पैकेज मैनेजर्स से 10–100 गुना तेज़ है।

वे प्रमुख विशेषताएं जो UV को अलग बनाती हैं:

• बिजली-सी तेज़ पैकेज इंस्टॉलेशन और डिपेंडेंसी रेज़ोल्यूशन
• मौजूदा Python टूल्स और वर्कफ़्लोज़ के साथ संगत
• बिल्ट-इन वर्चुअल एन्वायरनमेंट मैनेजमेंट
• आधुनिक पैकेजिंग मानकों का समर्थन
• विश्वसनीय डिपेंडेंसी लॉकिंग और पुनरुत्पाद्य (reproducible) एन्वायरनमेंट्स
• विशेषकर बड़े प्रोजेक्ट्स के लिए मेमोरी-कुशल संचालन

चाहे आप छोटे व्यक्तिगत प्रोजेक्ट्स पर काम कर रहे हों या बड़े स्तर के Python अनुप्रयोगों का प्रबंधन कर रहे हों, UV पैकेज मैनेजमेंट के लिए एक मजबूत और कुशल समाधान देता है। इस ट्यूटोरियल में, हम UV के सभी आवश्यक पहलू कवर करेंगे ताकि आप इसे तुरंत उपयोग करना शुरू कर सकें।

TL;DR

• UV एक Rust-समर्थित Python पैकेज मैनेजर है जो pip से 10–100x तेज़ है
• curl -LsSf https://astral.sh/uv/install.sh | sh से इंस्टॉल करें
• uv init से प्रोजेक्ट इनिशियलाइज़ करें और uv add package से डिपेंडेंसी जोड़ें
• uv run script.py से स्क्रिप्ट चलाएं—वर्चुअल एन्वायरनमेंट को मैन्युअली एक्टिवेट करने की ज़रूरत नहीं
• UV एक ही टूल में pip, virtualenv, pyenv, और pip-tools को रिप्लेस करता है
• लॉक फ़ाइलें (uv.lock) मशीनों के बीच पुनरुत्पाद्य एन्वायरनमेंट सुनिश्चित करती हैं
• uvx से black और ruff जैसे CLI टूल्स बिना स्थायी इंस्टॉलेशन के चलाएं

UV, Poetry, PIP, Conda, और virtualenv में अंतर

डेवलपर्स नया टूल अपनाने से पहले अक्सर पूछते हैं, "यह मेरे मौजूदा टूल से कैसे तुलना करता है?" Python डिपेंडेंसी और प्रोजेक्ट मैनेजमेंट के क्षेत्र में ये चार टूल पहले से ही सबसे आम हैं:

• PIP
• Poetry
• Conda
• virtualenv

विवरण में जाने से पहले, आइए UV की इन टूल्स से तुलना करें ताकि आप तय कर सकें कि आपकी ज़रूरतों के लिए UV सही विकल्प है या नहीं।

UV बनाम PIP और virtualenv

PIP और virtualenv Python पैकेज मैनेजमेंट और वर्चुअल एन्वायरनमेंट निर्माण के पारंपरिक टूल रहे हैं। ये काम कर देते हैं, लेकिन UV कई प्रभावशाली फायदे देता है:

• स्पीड: Rust में लिखे जाने के कारण UV पैकेज इंस्टॉलेशन और डिपेंडेंसी रेज़ोल्यूशन में PIP से काफी तेज़ है—जो काम PIP को मिनटों में लगते हैं, UV अक्सर सेकंडों में कर देता है।
• इंटीग्रेटेड एन्वायरनमेंट मैनेजमेंट: जहां virtualenv केवल एन्वायरनमेंट बनाता है और PIP केवल पैकेज मैनेज करता है, UV दोनों फ़ंक्शनैलिटी को एक ही टूल में समेटता है, जिससे वर्कफ़्लो सुगम होता है।

UV PIP के इकोसिस्टम के साथ पूर्ण संगतता बनाए रखते हुए उसकी मुख्य सीमाओं को दूर करता है। यह समान requirements.txt फ़ाइलें और पैकेज इंडेक्स का उपयोग कर सकता है, जिससे माइग्रेशन सहज हो जाता है। मुख्य अंतर हैं:

• प्रदर्शन: पैरेलल डाउनलोड्स और अनुकूलित डिपेंडेंसी रेज़ॉल्वर UV को बड़े प्रोजेक्ट्स में PIP से 10–100x तक तेज़ बनाते हैं।
• मेमोरी उपयोग: पैकेज इंस्टॉलेशन और डिपेंडेंसी रेज़ोल्यूशन के दौरान UV PIP से काफी कम मेमोरी उपयोग करता है।
• एरर हैंडलिंग: डिपेंडेंसी टकराव होने पर UV स्पष्ट एरर संदेश और बेहतर कॉन्फ्लिक्ट रेज़ोल्यूशन प्रदान करता है।
• रीप्रोड्यूसिबिलिटी: UV की लॉकफ़ाइल पद्धति अलग-अलग सिस्टम्स पर सुसंगत एन्वायरनमेंट सुनिश्चित करती है—जो बेसिक requirements.txt से गारंटीड नहीं।

हालांकि PIP और virtualenv अब भी व्यवहार्य विकल्प हैं, UV की आधुनिक आर्किटेक्चर और संयुक्त फ़ंक्शनैलिटी बेहतर प्रदर्शन और अधिक सुव्यवस्थित वर्कफ़्लो चाहने वाले डेवलपर्स के लिए इसे आकर्षक विकल्प बनाती है। मौजूदा प्रोजेक्ट्स में UV को बिना स्थापित प्रक्रियाओं को बाधित किए अपनाने की क्षमता उन टीमों के लिए विशेष रूप से उपयोगी है जो अपने Python डेवलपमेंट टूलचेन को क्रमिक रूप से आधुनिक बनाना चाहती हैं।

UV बनाम Conda

जो लोग PIP और virtualenv का उपयोग नहीं करते, वे अक्सर Conda की ओर रुख करते हैं—और इसके अच्छे कारण हैं:

• Conda संपूर्ण पैकेज मैनेजमेंट समाधान देता है जो Python पैकेजों के साथ-साथ सिस्टम-स्तरीय डिपेंडेंसी भी संभालता है
• यह NumPy, SciPy, और TensorFlow जैसे पैकेजों के साथ जटिल वैज्ञानिक कंप्यूटिंग एन्वायरनमेंट मैनेज करने में उत्कृष्ट है
• Conda एन्वायरनमेंट अधिक पृथक (isolated) होते हैं और विभिन्न ऑपरेटिंग सिस्टम्स पर अधिक रीप्रोड्यूसिबल होते हैं
• इसमें अलग-अलग Python वर्ज़न का बिल्ट-इन सपोर्ट है और इनके बीच आसानी से स्विच किया जा सकता है
• Anaconda डिस्ट्रीब्यूशन कई प्री-इंस्टॉल्ड वैज्ञानिक पैकेजों के साथ आता है, जो डेटा साइंटिस्ट्स के लिए सुविधाजनक है

लेकिन कट्टर Conda उपयोगकर्ताओं को भी कई कारणों से UV पर स्विच करने पर विचार करना चाहिए। (एन्वायरनमेंट मैनेजमेंट टूल्स की व्यापक तुलना के लिए देखें Anaconda बनाम Python: उनके अंतर.) UV की बिजली-सी तेज़ इंस्टॉलेशन और डिपेंडेंसी रेज़ोल्यूशन Conda के कभी-कभी सुस्त प्रदर्शन की तुलना में एन्वायरनमेंट सेटअप को काफी तेज़ कर सकती है। इसका न्यूनतम संसाधन-फुटप्रिंट कम मेमोरी उपयोग और तेज़ स्टार्टअप देता है। UV मौजूदा Python पैकेजिंग मानकों और टूल्स के साथ भी सहजता से एकीकृत होता है, जिससे व्यापक Python इकोसिस्टम के साथ काम करना आसान होता है। जिन प्रोजेक्ट्स को Conda के नॉन-Python पैकेज मैनेजमेंट की आवश्यकता नहीं है, उनके लिए UV अधिक सुव्यवस्थित, कुशल समाधान देता है जो विकास वर्कफ़्लोज़ को उल्लेखनीय रूप से बेहतर बना सकता है।

UV बनाम Poetry

मैं लगभग तीन वर्षों तक Conda उपयोगकर्ता रहा, लेकिन Poetry आज़माने के बाद मैंने कछुआ-गति वाली Conda को फिर नहीं छुआ। जैसे ही Poetry के साथ सहज हो रहा था, मुझे UV मिला—और यह लगभग Poetry जैसी ही क्षमताएं प्रदान करता है:

• डिपेंडेंसी मैनेजमेंट: दोनों टूल पैकेज डिपेंडेंसी और वर्चुअल एन्वायरनमेंट को प्रभावी ढंग से संभालते हैं
• प्रोजेक्ट संरचना: दोनों Python प्रोजेक्ट्स को इनिशियलाइज़ और स्ट्रक्चर करने के टूल देते हैं
• लॉक फ़ाइलें: दोनों रीप्रोड्यूसिबल एन्वायरनमेंट सुनिश्चित करने के लिए लॉक फ़ाइलें जेनरेट करते हैं
• पैकेज पब्लिशिंग: दोनों PyPI पर पैकेज प्रकाशित करने का समर्थन करते हैं
• आधुनिक टूलिंग: दोनों Python प्रोजेक्ट मैनेजमेंट के आधुनिक अप्रोच का प्रतिनिधित्व करते हैं

हालांकि, UV की परिभाषित विशेषता इसकी बिजली-सी तेज़ स्पीड और न्यूनतम संसाधन-उपयोग है। Poetry पारंपरिक टूल्स पर महत्वपूर्ण सुधार है, लेकिन Rust इम्प्लीमेंटेशन के कारण UV प्रदर्शन को एक नए स्तर पर ले जाता है। साथ ही, मौजूदा Python पैकेजिंग के साथ UV की संगतता का मतलब है कि यह pip जैसे अन्य टूल्स के साथ भी काम कर सकता है—एक लचीलापन जो कभी-कभी Poetry के अधिक मत-वाले (opinionated) अप्रोच में कम होता है।

यहां एक तालिका है जो अभी कवर किए गए अंतरों का सार प्रस्तुत करती है: 

यदि आपको लगता है कि UV पर स्विच करना सार्थक है, तो आगे पढ़ें।

Python प्रोजेक्ट्स के लिए UV के साथ शुरुआत

इस अनुभाग में, हम UV का उपयोग करके शुरुआत से प्रोजेक्ट कैसे शुरू करें, यह कवर करेंगे। यदि आपको पहले अपना Python डेवलपमेंट एन्वायरनमेंट सेट अप करने में सहायता चाहिए, तो हमारा समर्पित गाइड देखें। मौजूदा प्रोजेक्ट्स को UV में माइग्रेट करना हम आगे के अनुभाग में चर्चा करेंगे।

UV इंस्टॉल करना

macOS और Linux पर UV को cURL से सिस्टम-वाइड इंस्टॉल किया जा सकता है:

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

और Windows पर Powershell से (सुनिश्चित करें कि आप Powershell को एडमिनिस्ट्रेटर अधिकारों के साथ चलाएं):

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

UV Homebrew के माध्यम से भी उपलब्ध है:

$ brew install uv

PIP इंस्टॉल समर्थित है, लेकिन अनुशंसित नहीं है:

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

इसके बाद, आप uv version चलाकर इंस्टॉलेशन सत्यापित कर सकते हैं:

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

UV अपडेट करना

स्टैंडअलोन इंस्टॉलर से इंस्टॉल होने पर UV स्वयं को अपडेट कर सकता है:

$ uv self update

यदि आपने UV को Homebrew से इंस्टॉल किया है, तो इसके बजाय brew upgrade uv का उपयोग करें। आप UV कमांड्स के लिए शेल ऑटो-कम्प्लीशन भी सक्षम कर सकते हैं:

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

नया प्रोजेक्ट इनिशियलाइज़ करना

प्रोजेक्ट्स पर काम करना UV अनुभव का मूल भाग है। आप uv init कमांड से एक खाली प्रोजेक्ट इनिशियलाइज़ करके शुरू करते हैं:

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

कमांड तुरंत एक नया explore-uv डायरेक्टरी निम्न सामग्री के साथ बना देगा:

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

Git स्वतः इनिशियलाइज़ हो जाता है और .gitignore तथा एक खाली README.md जैसे मुख्य git-संबंधित फ़ाइलें जनरेट हो जाती हैं। .python-version फ़ाइल में प्रोजेक्ट के लिए प्रयुक्त Python वर्ज़न होता है, जबकि pyproject.toml प्रोजेक्ट मेटाडेटा और डिपेंडेंसीज़ के लिए मुख्य कॉन्फ़िगरेशन फ़ाइल है। एक नमूना hello.py फ़ाइल भी बनाई जाती है ताकि आप जल्दी शुरू कर सकें।

आप UV दस्तावेज़ में प्रोजेक्ट्स बनाने के बारे में और जान सकते हैं।

प्रोजेक्ट में प्रारंभिक डिपेंडेंसी जोड़ना

UV एन्वायरनमेंट निर्माण और डिपेंडेंसी इंस्टॉलेशन को एक ही कमांड—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
 ...

पहली बार add कमांड चलाने पर, UV वर्तमान वर्किंग डायरेक्टरी में नया वर्चुअल एन्वायरनमेंट बनाता है और निर्दिष्ट डिपेंडेंसी इंस्टॉल करता है। बाद के रन में, UV मौजूदा वर्चुअल एन्वायरनमेंट को पुन: उपयोग करेगा और केवल नए अनुरोधित पैकेज इंस्टॉल/अपडेट करेगा, जिससे डिपेंडेंसी मैनेजमेंट कुशल रहता है।

हर add कमांड के दौरान होने वाली एक और महत्वपूर्ण प्रक्रिया है डिपेंडेंसी रेज़ोल्यूशन। UV एक आधुनिक रेज़ॉल्वर का उपयोग करता है जो संपूर्ण डिपेंडेंसी ग्राफ़ का विश्लेषण कर ऐसा संगत पैकेज-संग्रह ढूंढता है जो सभी आवश्यकताओं को पूरा करे। इससे वर्ज़न कॉन्फ्लिक्ट रोकने और पुनरुत्पाद्य एन्वायरनमेंट सुनिश्चित करने में मदद मिलती है। रेज़ॉल्वर वर्ज़न बाधाओं, Python वर्ज़न संगतता, और प्लेटफ़ॉर्म-विशिष्ट आवश्यकताओं जैसे कारकों पर विचार करता है ताकि इंस्टॉल किए जाने वाले पैकेजों का सर्वोत्तम सेट निर्धारित हो सके।

UV हर add कमांड के बाद pyproject.toml और uv.lock फ़ाइलें भी अपडेट करता है। यहां Scikit-learn और XGBoost इंस्टॉल करने के बाद TOML फ़ाइल इस प्रकार दिखती है:

$ 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",
]

एन्वायरनमेंट और pyproject.toml फ़ाइल से किसी डिपेंडेंसी को हटाने के लिए, आप uv remove कमांड का उपयोग कर सकते हैं। यह पैकेज और उसकी सभी उप-डिपेंडेंसीज़ को अनइंस्टॉल करेगा:

$ uv remove scikit-learn

हम डिपेंडेंसी मैनेजमेंट पर विस्तार से आगे के अनुभाग में चर्चा करेंगे।

UV के साथ Python स्क्रिप्ट्स चलाना

आवश्यक डिपेंडेंसी इंस्टॉल हो जाने के बाद, आप सामान्य रूप से अपनी Python स्क्रिप्ट्स पर काम शुरू कर सकते हैं। यदि आप VS Code का उपयोग कर रहे हैं, तो हमारा Python के लिए VS Code सेट करने पर गाइड देखें। UV Python कोड चलाने के लिए कुछ तरीके देता है:

Python स्क्रिप्ट सीधे चलाने के लिए, आप सामान्य python script.py सिंटैक्स के बजाय uv run कमांड के बाद अपनी स्क्रिप्ट का नाम दे सकते हैं:

$ uv run hello.py

run कमांड यह सुनिश्चित करता है कि स्क्रिप्ट UV द्वारा बनाए गए वर्चुअल एन्वायरनमेंट के अंदर ही निष्पादित हो।

इनलाइन डिपेंडेंसी (PEP 723) के साथ स्क्रिप्ट चलाना

UV PEP 723 इनलाइन स्क्रिप्ट मेटाडेटा का समर्थन करता है, जो आपको सीधे Python स्क्रिप्ट के अंदर डिपेंडेंसी घोषित करने देता है। यह स्टैंडअलोन स्क्रिप्ट्स के लिए उपयोगी है जिन्हें बिना पूरा प्रोजेक्ट सेटअप किए पैकेज चाहिए:

# /// 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]")

uv run से स्क्रिप्ट चलाएं, और UV घोषित डिपेंडेंसीज़ के साथ स्वतः एक पृथक एन्वायरनमेंट बना देगा:

$ uv run script.py
GitHub API status: 200

यह सहकर्मियों के साथ पुनरुत्पाद्य स्क्रिप्ट साझा करने के लिए विशेष रूप से शक्तिशाली है—UV इंस्टॉल होने पर कोई भी बिना डिपेंडेंसी मैन्युअली इंस्टॉल किए स्क्रिप्ट चला सकता है।

UV में Python वर्ज़न मैनेज करना

Python वर्ज़न मैनेज करना डिपेंडेंसी मैनेजमेंट का एक महत्वपूर्ण हिस्सा है। UV यह नियंत्रित करने के लिए सरल कमांड्स देता है कि आप कौन सा Python वर्ज़न उपयोग करते हैं। आइए uv python कमांड का उपयोग करना देखें।

UV के साथ Python वर्ज़न इंस्टॉल करना

UV सीधे Python वर्ज़न इंस्टॉल और मैनेज कर सकता है, जिससे pyenv जैसे टूल्स की आवश्यकता समाप्त हो जाती है:

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

Python इंस्टॉलेशन्स ~/.local/share/uv/python/ में स्टोर होती हैं और आपकी सिस्टम Python में दख़ल नहीं देतीं। आप किसी प्रोजेक्ट को एक विशेष Python वर्ज़न पर पिन भी कर सकते हैं:

$ uv python pin 3.12

यह आपके प्रोजेक्ट डायरेक्टरी की .python-version फ़ाइल अपडेट करता है। इसके बाद UV प्रोजेक्ट की सभी क्रियाओं के लिए यही वर्ज़न उपयोग करेगा।

मौजूद Python वर्ज़न सूचीबद्ध करना

चूंकि सिस्टम्स में अक्सर पहले से Python इंस्टॉल होता है, UV डिफ़ॉल्ट रूप से इन मौजूदा इंस्टॉलेशन्स को खोज सकता है। उदाहरण के लिए, सिस्टम पर UV द्वारा पहचाने गए सभी Python वर्ज़न सूचीबद्ध करने के लिए यह कमांड चलाएं:

$ 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

कमांड ने मेरे Conda और Brew से इंस्टॉल Python वर्ज़न्स को सही ढंग से डिटेक्ट कर लिया।

वर्तमान प्रोजेक्ट के लिए Python वर्ज़न बदलना 

आप किसी भी समय अपने मौजूदा UV प्रोजेक्ट के लिए Python वर्ज़न बदल सकते हैं, बशर्ते नया वर्ज़न आपके pyproject.toml में दी गई स्पेसिफ़िकेशन्स को संतुष्ट करता हो। उदाहरण के लिए, निम्न फ़ाइल में Python 3.9 या उससे ऊपर की आवश्यकता है:

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

इसका अर्थ है कि आप .python-version फ़ाइल में Python वर्ज़न 3.11.7 जैसे किसी भी उच्चतर वर्ज़न में बदल सकते हैं। इसके बाद uv sync चलाएं।

कमांड सबसे पहले मौजूदा Python इंस्टॉलेशन्स के खिलाफ़ जांच करता है। यदि अनुरोधित वर्ज़न नहीं मिलता, तो UV उसे /Users/username/.local/share/uv/python पथ में डाउनलोड और इंस्टॉल करता है। UV प्रोजेक्ट डायरेक्टरी के अंदर नया वर्चुअल एन्वायरनमेंट भी बनाता है और पुराने को प्रतिस्थापित करता है। 

uv sync कमांड सब कुछ स्वतः संभालता है—यह नया वर्चुअल एन्वायरनमेंट बनाता है और आपकी pyproject.toml तथा uv.lock फ़ाइलों से सभी डिपेंडेंसीज़ को पुनः इंस्टॉल करता है। अतिरिक्त इंस्टॉलेशन चरण की आवश्यकता नहीं है।

ध्यान दें कि कभी-कभी uv कमांड्स Permission Denied एरर दे सकते हैं। ऐसे मामलों में, macOS या Linux पर sudo का उपयोग करें या Windows पर एडमिनिस्ट्रेटर अधिकारों के साथ कमांड प्रॉम्प्ट चलाएं। इससे भी बेहतर समाधान है UV होम डायरेक्टरी का ओनरशिप यूज़र को दे देना:

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

UV के साथ Python वर्ज़न मैनेज करने के बारे में और जानने के लिए दस्तावेज़ देखें। 

UV टूल्स क्या हैं और उनका उपयोग कैसे करें?

कुछ Python पैकेज कमांड-लाइन टूल्स के रूप में उपलब्ध होते हैं, जैसे कोड फ़ॉर्मैटिंग के लिए black, लिंटिंग के लिए flake8, टेस्टिंग के लिए pytest, टाइप चेकिंग के लिए mypy इत्यादि। UV ऐसे पैकेजों को मैनेज करने के लिए दो विशेष इंटरफेसेज़ देता है:

1. uv tool run का उपयोग करके:

$ uv tool run black hello.py

2. छोटे और अधिक सुविधाजनक uvx कमांड का उपयोग करके:

$ uvx black hello.py

इन कमांड्स के चलने पर, UV अपने कैश में एक अस्थायी वर्चुअल एन्वायरनमेंट बनाता है। अनुरोधित टूल वहां इंस्टॉल और वहीं से चलाया जाता है। दूसरे शब्दों में, आप कमांड-लाइन टूल्स को प्रोजेक्ट के वर्चुअल एन्वायरनमेंट में इंस्टॉल किए बिना उपयोग कर सकते हैं—जिससे एक्सीक्यूशन तेज़ होता है और प्रोजेक्ट डिपेंडेंसीज़ साफ़ रहती हैं।

टूल-रन इंटरफेसेज़ के प्रमुख बिंदु:

• किसी भी ऐसे Python पैकेज के साथ काम करता है जो flake8, mypy, black या pytest जैसे कमांड-लाइन टूल देता है
• UV का कैश साफ़ करने पर कैश्ड एन्वायरनमेंट्स अपने-आप साफ़ हो जाते हैं
• ज़रूरत पड़ने पर नए कैश्ड एन्वायरनमेंट ऑन-डिमांड बनाए जाते हैं
• कभी-कभार उपयोग होने वाले डेवलपमेंट टूल्स के लिए उपयुक्त
• जिन टूल्स का आप बार-बार उपयोग करते हैं, उन्हें स्थायी रूप से uv tool install से इंस्टॉल करें:

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

स्थायी रूप से इंस्टॉल किए गए टूल्स आपके PATH के माध्यम से ग्लोबली उपलब्ध होते हैं, बिना किसी प्रोजेक्ट के वर्चुअल एन्वायरनमेंट को प्रदूषित किए। आप इन्हें uv tool upgrade ruff से अपडेट कर सकते हैं और uv tool list से सभी इंस्टॉल्ड टूल्स देख सकते हैं।

इन इंटरफेसेज़ के बारे में और जानने के लिए दस्तावेज़ की UV टूल्स सेक्शन पढ़ें।

UV में लॉक फ़ाइलें क्या हैं?

लॉक फ़ाइलें (uv.lock) UV में डिपेंडेंसी मैनेजमेंट का एक आवश्यक हिस्सा हैं। जब आप डिपेंडेंसी इंस्टॉल करने के लिए uv add कमांड चलाते हैं, तो UV स्वतः uv.lock फ़ाइल जेनरेट और अपडेट करता है। यह लॉक फ़ाइल कई महत्वपूर्ण उद्देश्यों की पूर्ति करती है:

• यह इंस्टॉल की गई सभी डिपेंडेंसीज़ और उनकी सब-डिपेंडेंसीज़ के सटीक वर्ज़न दर्ज करती है।
• यह अलग-अलग एन्वायरनमेंट्स में डिपेंडेंसी वर्ज़न "लॉक" करके रीप्रोड्यूसिबल बिल्ड सुनिश्चित करती है।
• यह सुसंगत पैकेज वर्ज़न बनाए रखकर "डिपेंडेंसी हैल" से बचाती है।
• यह इंस्टॉलेशन को तेज़ करती है क्योंकि UV फिर से रेज़ोल्व करने के बजाय लॉक्ड वर्ज़न का उपयोग कर सकता है।

UV लॉक फ़ाइल को स्वतः मैनेज करता है—आपको इसे मैन्युअली संपादित करने की आवश्यकता नहीं है। सभी डेवलपर्स एक ही डिपेंडेंसी वर्ज़न का उपयोग करें, यह सुनिश्चित करने के लिए लॉक फ़ाइल को वर्ज़न कंट्रोल में कमिट किया जाना चाहिए।

लॉक फ़ाइलों और requirements.txt के बीच अंतर

हालांकि लॉक फ़ाइलें और requirements.txt दोनों डिपेंडेंसी ट्रैक करने का काम करते हैं, उनकी प्रयोज्यता और उपयोग अलग-अलग हैं। लॉक फ़ाइलें सटीक पैकेज वर्ज़न और उनकी पूरी डिपेंडेंसी ट्री की विस्तृत जानकारी रखती हैं, जिससे विकास में सुसंगत एन्वायरनमेंट सुनिश्चित होते हैं। Requirements.txt आमतौर पर केवल डायरेक्ट डिपेंडेंसी सूचीबद्ध करता है और Python टूल्स में व्यापक रूप से समर्थित है।

रीप्रोड्यूसिबल बिल्ड बनाए रखने और डिपेंडेंसी कॉन्फ्लिक्ट रोकने के लिए विकास में लॉक फ़ाइलें आवश्यक हैं। Requirements.txt डिप्लॉयमेंट परिदृश्यों या ऐसे उपयोगकर्ताओं के साथ कोड साझा करने के लिए अधिक उपयुक्त है जो UV का उपयोग नहीं करते। यह उन टूल्स और सेवाओं के साथ संगतता के लिए भी आवश्यक है जो UV के लॉक फ़ाइल फ़ॉर्मेट को सपोर्ट नहीं करतीं।

आप UV की लॉक फ़ाइल का उपयोग विकास में करते हुए डिप्लॉयमेंट के लिए requirements.txt जेनरेट कर दोनों फ़ाइलें बनाए रख सकते हैं। UV लॉक फ़ाइल से requirements.txt बनाने के लिए यह कमांड उपयोग करें:

$ uv export -o requirements.txt

यह आपकी लॉक फ़ाइल के आधार पर पिन किए हुए वर्ज़न्स के साथ टेक्स्ट फ़ाइल बनाता है, जिससे आप विकास के दौरान UV के उन्नत डिपेंडेंसी मैनेजमेंट का लाभ लेते हुए भी अपने प्रोजेक्ट की डिपेंडेंसीज़ मानक फ़ॉर्मेट में आसानी से साझा कर सकते हैं।

आप दस्तावेज़ से लॉक फ़ाइलें मैनेज करने के बारे में और जान सकते हैं। 

UV के साथ उन्नत डिपेंडेंसी मैनेजमेंट

इस अनुभाग में, हम UV में डिपेंडेंसी मैनेज करने के अधिक परिष्कृत तरीकों का अन्वेषण करेंगे। हम सीखेंगे कि डिपेंडेंसी कैसे अपडेट करें, उन्हें वैकल्पिक (optional) कैसे बनाएं, या डिपेंडेंसी ग्रुप का भाग कैसे बनाएं।

डिपेंडेंसी अपडेट करना

लंबे समय के प्रोजेक्ट्स में, नवीनतम फीचर्स पाने के लिए उपयोग किए जा रहे पैकेजों को अपडेट करना सामान्य है। या कभी-कभी कोई पैकेज ब्रेकिंग चेंजेज़ लाता है और आप चाहते हैं कि वह वर्ज़न आपके एन्वायरनमेंट में गलती से इंस्टॉल न हो। मौजूदा डिपेंडेंसी की बाधाओं या वर्ज़न्स को बदलने के हर परिदृश्य में add कमांड का पुनः उपयोग किया जा सकता है।

1. किसी पैकेज का नवीनतम वर्ज़न इंस्टॉल करना:

$ uv add requests

2. किसी विशिष्ट वर्ज़न को इंस्टॉल करना:

$ uv add "requests==2.1.2"

3. किसी पैकेज की बाधाओं (constraints) की सीमाएं बदलना:

$ uv add 'requests<3.0.0'

4. किसी डिपेंडेंसी को प्लेटफ़ॉर्म-विशिष्ट बनाना:

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

वैकल्पिक (optional) डिपेंडेंसी जोड़ना

वैकल्पिक डिपेंडेंसी वे पैकेज हैं जो आपके प्रोजेक्ट की कोर फ़ंक्शनैलिटी के लिए आवश्यक नहीं होते, परंतु विशिष्ट फीचर्स के लिए ज़रूरी हो सकते हैं। उदाहरण के लिए, Pandas में excel और plot एक्स्ट्राज़ हैं ताकि Excel पार्सर्स और matplotlib तब तक इंस्टॉल न हों जब तक उन्हें स्पष्ट रूप से न मांगा जाए। ऑप्शनल्स आमतौर पर pip install pandas[plot, excel] सिंटैक्स से इंस्टॉल किए जाते हैं। 

UV के साथ यह सिंटैक्स थोड़ा अलग है। पहले सुनिश्चित करें कि कोर Pandas पैकेज इंस्टॉल है:

$ uv add pandas

फिर, इसे इसके ऑप्शनल एक्स्ट्राज़ के साथ स्क्वेयर-ब्रैकेट नोटेशन से इंस्टॉल करें:

$ uv add "pandas[plot,excel]"

रिज़ॉल्व हो जाने पर, वे आपकी pyproject.toml में निम्न स्वरूप में सूचीबद्ध होंगे:

[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",
]

डिपेंडेंसी ग्रुप्स

डिपेंडेंसी ग्रुप्स आपको अपनी डिपेंडेंसीज़ को तार्किक समूहों—जैसे डेवलपमेंट, टेस्ट, या डॉक्यूमेंटेशन डिपेंडेंसी—में व्यवस्थित करने देते हैं। इससे प्रोडक्शन डिपेंडेंसीज़ को डेवलपमेंट डिपेंडेंसीज़ से अलग रखने में मदद मिलती है।

किसी विशिष्ट ग्रुप में डिपेंडेंसी जोड़ने के लिए --group फ़्लैग का उपयोग करें:

$ uv add --group group_name package_name

इसके बाद, उपयोगकर्ता --group, --only-group, और --no-group टैग्स का उपयोग करके कौन से ग्रुप इंस्टॉल करने हैं, नियंत्रित कर पाएंगे।

PIP और Virtualenv से UV पर स्विच करना

क्योंकि UV मौजूदा Python पैकेजिंग मानकों के साथ संगतता बनाए रखता है, इसलिए PIP और virtualenv से UV पर माइग्रेट करना सीधा-सादा है। सुगम ट्रांज़िशन के लिए यहां चरण-दर-चरण मार्गदर्शिका है:

1. मौजूदा virtualenv प्रोजेक्ट को कन्वर्ट करना

यदि आपके पास virtualenv और pip का उपयोग करने वाला मौजूदा प्रोजेक्ट है, तो यदि आपने पहले से नहीं किया है तो वर्तमान एन्वायरनमेंट से requirements.txt फ़ाइल जनरेट करके शुरू करें:

$ pip freeze > requirements.txt

फिर, उसी डायरेक्टरी में नया UV प्रोजेक्ट बनाएं:

$ uv init .

अंत में, अपनी requirements फ़ाइल से डिपेंडेंसी इंस्टॉल करें:

$ uv pip install -r requirements.txt

2. सामान्य pip/virtualenv कमांड्स को बदलना

यहां आम pip और virtualenv कमांड्स के UV समकक्षों के लिए त्वरित संदर्भ है:

माइग्रेशन के बाद, आप अपने पुराने virtualenv डायरेक्टरी को सुरक्षित रूप से हटा सकते हैं और UV के वर्चुअल एन्वायरनमेंट मैनेजमेंट का उपयोग शुरू कर सकते हैं। ट्रांज़िशन आमतौर पर सहज रहता है, और आवश्यकता पड़ने पर आप UV की pip कम्पैटिबिलिटी लेयर के जरिए pip कमांड्स पर वापस जा सकते हैं।

CI/CD और Docker में UV का उपयोग

UV की स्पीड इसे CI/CD पाइपलाइन्स में विशेष रूप से मूल्यवान बनाती है, जहां हर बिल्ड पर डिपेंडेंसी इंस्टॉल होती हैं। यहां UV का उपयोग करते हुए GitHub Actions वर्कफ़्लो का एक उदाहरण है:

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/

--frozen फ़्लैग सुनिश्चित करता है कि CI ठीक-ठीक आपकी लॉक फ़ाइल में दिए गए वर्ज़न का उपयोग करे—यदि लॉक फ़ाइल पुरानी हो तो यह असफल हो जाएगा। यह रीप्रोड्यूसिबल बिल्ड्स की गारंटी देता है।

Docker इंटीग्रेशन

UV Docker इमेज बिल्ड्स को भी उल्लेखनीय रूप से तेज़ कर सकता है:

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"]

डिपेंडेंसी फ़ाइलों को पहले कॉपी करके और सोर्स कोड कॉपी करने से पहले इंस्टॉल करके, आप Docker लेयर कैशिंग का पूरा लाभ उठाते हैं। डिपेंडेंसी इंस्टॉलेशन केवल तब पुनः चलता है जब pyproject.toml या uv.lock बदलता है।

निष्कर्ष

UV Python पैकेज मैनेजमेंट में एक महत्वपूर्ण प्रगति का प्रतिनिधित्व करता है—यह पारंपरिक टूल्स का आधुनिक, तेज़ और कुशल विकल्प है। इसके प्रमुख फायदे हैं:

• pip की तुलना में 10–100x तक तेज़, धमाकेदार प्रदर्शन
• मौजूदा Python पैकेजिंग मानकों के साथ सहज इंटीग्रेशन
• बिल्ट-इन वर्चुअल एन्वायरनमेंट मैनेजमेंट
• कुशल डिपेंडेंसी रेज़ोल्यूशन और लॉक फ़ाइल सपोर्ट
• कम मेमोरी फ़ुटप्रिंट और संसाधन उपयोग

चाहे आप नया प्रोजेक्ट शुरू कर रहे हों या किसी मौजूदा को माइग्रेट कर रहे हों, UV एक मजबूत समाधान देता है जो आपके Python डेवलपमेंट वर्कफ़्लो को उल्लेखनीय रूप से बेहतर बना सकता है। मौजूदा टूल्स के साथ इसकी संगतता इसे उन डेवलपर्स के लिए आसान विकल्प बनाती है जो बिना मौजूदा प्रक्रियाओं में व्यवधान डाले अपने टूलचेन को आधुनिक बनाना चाहते हैं।

जैसे-जैसे Python इकोसिस्टम विकसित होता जा रहा है, UV जैसे टूल दिखाते हैं कि Rust जैसी आधुनिक तकनीकें विकास अनुभव को कैसे बेहतर बना सकती हैं—साथ ही वह सादगी और अभिगम्यता बनाए रखते हुए जिसे Python डेवलपर्स महत्व देते हैं।

यदि आप डिपेंडेंसी मैनेजमेंट या सामान्य रूप से Python के बारे में और सीखना चाहते हैं, तो इन अतिरिक्त स्रोतों को देखें:

• Python ट्यूटोरियल (शुरुआती के लिए)
• PIP Python ट्यूटोरियल: निर्णायक गाइड
• Developing Python Packages कोर्स
• Python एन्वायरनमेंट मैनेजमेंट के लिए शीर्ष 9 Anaconda विकल्प
• Data Scientist in Python | डेटा साइंस के लिए Python सीखें
• Python Poetry: आधुनिक और कुशल Python एन्वायरनमेंट व डिपेंडेंसी मैनेजमेंट