commandes communes uv

Tutoriels pratiques sur l'IAMise à jour il y a 4 mois Sharenet.ai

972 0

Python Eco n'a jamais manqué d'outils de gestion des emballages et de gestion de l'environnement, qu'il s'agisse du classique pip,virtualenv jusqu'à (un moment) pip-tools,condapuis la modernisation de la Poetry,PDM Et ainsi de suite. Chaque outil a son domaine d'expertise, mais cela rend souvent la chaîne d'outils d'un développeur fragmentée et complexe.

Maintenant, à partir de Astral Entreprise (bien connue) Python Linter Ruff (le créateur de la uv La traversée a ouvert de nouvelles possibilités. Ce produit utilise Rust des outils écrits dans cette langue, aspire à être une Rapide, unifié et convivial pour les développeurs Python Gestionnaire de paquets et de projets. Son objectif est clair : s'appuyer sur les Rust écologiquement rationnel Cargo L'expérience réussie de l'entreprise lui permet de proposer une solution unique.uv Non seulement il est rapide, mais il intègre également la gestion de l'environnement, l'installation de paquets, la résolution des dépendances, la gestion de projets, etc.

Pourquoi les UV ?

Comparaison avec les outils existantsuv Offrir une alternative plus moderne et plus efficace à ses principaux points forts :

Amélioration significative de la vitesse: Sur la base de Rust de l'optimisation du temps de compilation et du traitement simultané efficace.uv Pour les opérations courantes telles que la résolution des dépendances et l'installation des paquets, il est plus rapide que les outils traditionnels tels que l'application pip peut-être PoetryLes opérations répétitives sont souvent plus rapides de plusieurs ordres de grandeur. Le mécanisme efficace de mise en cache globale intégré rend également les opérations répétitives presque instantanées. Derrière tout cela se trouve le Rust (par exemple, la concurrence sans crainte grâce à la sécurité de la mémoire) et des bibliothèques sous-jacentes de haute qualité (par exemple, la bibliothèque Tokio,Reqwest) Crédits.
Intégration fonctionnelle complète: :uv Conçu comme un "couteau suisse" dans les mains des développeurs, il couvre tous les aspects de la création et de la gestion des environnements virtuels, de l'installation et du verrouillage des dépendances (support natif). pyproject.tomlcompatible requirements.txt), à l'exécution de scripts, à la gestion d'outils globaux et même à l'installation d'outils spécifiques. Python de l'ensemble du processus de développement.
Gestion de projet moderneSupport natif : Support natif pyproject.toml (norme PEP 517/518/621), qui est l'équivalent moderne de la norme Python Le profil standard de facto du projet.uv Capacité à gérer clairement les groupements de dépendances (par exemple, les dépendances de développement) et à générer des applications multiplateformes. uv.lock Fichier verrouillé. Ce fichier de verrouillage enregistre avec précision les versions spécifiques et les sources de toutes les dépendances directes et indirectes, ce qui garantit qu'un environnement totalement cohérent peut être reconstruit sur n'importe quelle machine, à n'importe quel moment, pour une construction véritablement déterministe.
Bonne compatibilité: :uv Fournit un lien vers le site pip Interface de commande hautement compatible (uv pip ...) et peut comprendre requirements.txt ce qui permet de migrer les projets existants vers le format de fichier uv Le processus est relativement fluide.
Le développement actif et l'avenir: : Par Astral L'équipe s'occupe activement de la maintenance et de l'itération rapide à l'aide du système de gestion de l'information de l'entreprise. MIT Licence Open Source. Un grand intérêt de la part de la communauté, un grand potentiel de développement et un avenir prometteur.

utiliser uvLes développeurs devraient connaître des expériences similaires. Node.js ( npm / yarn / pnpm ) ou Rust ( Cargo ) comme des flux de travail fluides et uniformes pour la gestion des dépendances.

Installation de l'UV

montage uv C'est très simple. La recommandation officielle est d'utiliser le script d'installation fourni, car il ne dépend pas de la version existante de l'application Python L'environnement. Bien entendu, en pip ou System Package Manager sont également des options viables.

Méthode recommandée (scripting multiplateforme): :
```
# macOS / Linux (bash, zsh, etc.)
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```
prendre noteLe script officiel définira par défaut le uv Installer à un emplacement spécifique dans le répertoire de l'utilisateur (par ex. Linux / macOS (utilisé comme expression nominale) ~/.uv/bin peut-être Windows (utilisé comme expression nominale) %LOCALAPPDATA%\uv\bin), qui se trouve généralement sur le disque système (par ex. C: (disque).
Utilisation de pip (nécessite un environnement Python existant): :
```
pip install uv
# 或推荐使用 pipx 进行隔离安装
# pipx install uv
```
Si votre Python Environnement ou pipx L'environnement lui-même ne se trouve pas sur le disque système, et en l'installant de cette façon, le uv Il suit généralement leur position. Vous pouvez régler cela en définissant le paramètre PIPX_HOME Variables d'environnement à contrôler pipx Le chemin d'installation du
Utilisation du gestionnaire de paquets système (exemple): :
```
# macOS (Homebrew)
brew install uv
# Windows (Scoop)
# 可以先将 Scoop 本身安装到非系统盘，然后用它安装 uv
scoop install uv
# Arch Linux
pacman -S uv
```
Si, comme dans le cas de Scoop Un tel gestionnaire de paquets est lui-même configuré sur un disque hors système, puis les applications qu'il installe (y compris l'application uv) sont généralement installés dans le même lecteur.
Utilisation de Cargo (nécessite un environnement Rust): :
```
cargo install uv --locked --git https://github.com/astral-sh/uv
```
uv sera installé dans la base de données Cargo (utilisé comme expression nominale) bin Catalogue. Pour ce faire, il suffit de paramétrer l'option CARGO_HOME La variable d'environnement définit l'ensemble des .cargo (contenant les fichiers téléchargés crates et les produits compilés) ont migré vers des disques hors système.

Une fois l'installation terminée, exécutez uv --version peut-être uv help pour vérifier que l'installation s'est bien déroulée.

Configuration de l'emplacement de stockage des données UV (avancé)

Par défaut, leuv Il mettra en cache, téléchargera le Python ainsi que par le biais de la version uv tool install Les outils globaux installés sont stockés dans un emplacement par défaut dans le répertoire de l'utilisateur (généralement sur le lecteur système). Si vous souhaitez les stocker sur un autre lecteur (tel que le lecteur D: ) pour économiser de l'espace sur le disque système ou pour réduire la consommation d'énergie. SSD Write, qui peut être défini en réglant le paramètrevariable d'environnementpour y parvenir.

Voici quelques variables d'environnement clés :

UV_CACHE_DIR: Contrôle uv Emplacement du répertoire du cache. Le cache comprend les fichiers de paquets téléchargés, les fichiers wheel etc., ce qui peut prendre plus d'espace.
UV_PYTHON_INSTALL_DIR: : Contrôler par uv python install téléchargée et gérée Python L'emplacement où l'interprète sera installé.
UV_TOOL_INSTALL_DIR: : Contrôler par uv tool install Globale installée Python Lieu de stockage des outils et de leurs environnements isolés.

Comment définir les variables d'environnement (exemple):

Supposons que l'objectif soit de combiner tous les uv Les données sont stockées dans le D:\uvdata Catalogue.

Windows (PowerShell - paramètre temporaire, valable uniquement pour la session en cours):

$env:UV_CACHE_DIR = "D:\uvdata\cache"
$env:UV_PYTHON_INSTALL_DIR = "D:\uvdata\python"
$env:UV_TOOL_INSTALL_DIR = "D:\uvdata\tools"
# 之后在此会话中运行 uv 命令，数据将写入新位置
uv pip install requests

Windows (Variables d'environnement du système - paramètres permanents):
1. existent Windows Cherchez "variables d'environnement" dans la barre de recherche.
2. Cliquez sur "Modifier les variables d'environnement du système".
3. Dans la boîte de dialogue "Propriétés du système", cliquez sur le bouton "Variables d'environnement...". Cliquez sur le bouton "Variables d'environnement".
4. Dans la zone "Variables utilisateur" ou "Variables système" (il est recommandé d'utiliser les Variables utilisateur, sauf si elles sont nécessaires pour tous les utilisateurs), cliquez sur "Nouveau ..." .".
5. Saisissez le nom de la variable (par exemple UV_CACHE_DIR) et des valeurs variables (telles que D:\uvdata\cache).
6. Répétez cette opération pour les deux autres variables.
7. Cliquez sur OK pour fermer toutes les boîtes de dialogue.
8. crête: : Obligatoirerouvrir PowerShell ou la fenêtre d'invite de commande pour que la nouvelle variable d'environnement prenne effet.

Linux / macOS (bash/zsh - paramètres temporaires):

export UV_CACHE_DIR="/path/to/non_system_drive/uvdata/cache"
export UV_PYTHON_INSTALL_DIR="/path/to/non_system_drive/uvdata/python"
export UV_TOOL_INSTALL_DIR="/path/to/non_system_drive/uvdata/tools"
# 之后在此会话中运行 uv 命令
uv pip install requests

Linux / macOS (installation permanente):
topologique export dans votre fichier de configuration du Shell (par ex. ~/.bashrc, ~/.zshrc, ~/.profile), puis exécutez la commande source ~/.your_config_file ou redémarrer le terminal pour que la configuration prenne effet.

Notes importantes:

Après avoir défini ces variables d'environnement, le programmeuv Les chemins spécifiés sont utilisés automatiquement. Assurez-vous que ces répertoires existent et que uv Disposer d'un accès en écriture.
Environnement virtuel (.venv) position: uv venv Les valeurs par défaut de votreRépertoire racine du projetCréer .venv dossier. En conséquence, le dossierTant que votre projet lui-même se trouve sur un disque ne faisant pas partie du système (tel que le disque D:\myproject), alors .venv Naturellement, il figurera également sur ce disque. Il n'est généralement pas nécessaire de fournir une liste de .venv Configurez les chemins individuellement pour éviter le disque système. Bien entendu, vous pouvez également éviter le disque système en uv venv /path/to/custom/env Spécifier explicitement l'endroit où l'environnement virtuel doit être créé, mais cela sert davantage à personnaliser le chemin d'accès à l'environnement qu'à résoudre le problème de stockage du disque système.

En configurant ces variables d'environnement de manière appropriée, vous pouvez gérer efficacement le programme uv Les données de l'enquête ont été recueillies dans le cadre d'un projet de recherche et de développement, et ont été transférées vers un lieu de stockage où l'espace est plus abondant ou plus approprié.

Concepts fondamentaux de l'UV

en utilisant uv Lors de la gestion d'un projet, il est important de comprendre les concepts fondamentaux suivants :

pyproject.toml: Moderne Python Profil standard du projet (basé sur PEP 517/518/621).uv Utilisez-le pour définir les métadonnées du projet (nom, version, description, etc.). Python Version (requires-python) et les principales dépendances du projet (dependencies) et des groupes de dépendances optionnels (par ex. dev-dependencies). Il s'agit de la "source unique de vérité" pour la configuration du projet.
uv.lock: : Par uv Fichier verrouillé généré et géré automatiquement. Il enregistre avec précision les numéros de version et les hachages des sources de toutes les dépendances du projet (y compris les dépendances indirectes). Sa valeur principale est de garantir queReproductibilité de l'environnementLe droit à l'information est un droit de l'homme : chaque fois qu'il est fondé sur le même droit de l'homme. uv.lock installe les dépendances, vous obtenez exactement la même combinaison de paquets.Ce fichier ne doit pas être modifié manuellement.
Environnement virtuel (.venv): :uv Hautement recommandé, il simplifie l'utilisation des environnements virtuels. Il crée par défaut un environnement virtuel dans le répertoire racine du projet, appelé .venv d'environnements isolés pour héberger les dépendances du projet. La plupart des uv (par exemple add, sync, run) sont automatiquement détectés et les opérations sont effectuées dans cet environnement, en évitant l'utilisation de l'outil global de gestion de l'environnement. Python Pollution de l'environnement.

Gérer les projets Python avec UV

Vous trouverez ci-dessous une démonstration, à travers un processus complet, de l'utilisation de l'outil uv pour créer et gérer un Python Projet.

Initialiser le projet (`uv init`)

utiliser uv init permet de construire rapidement la structure de base d'un nouveau projet.

# 确保在期望的驱动器上操作，例如在 D: 盘
# D:
# mkdir my_uv_project
# cd my_uv_project
# 初始化名为 my_uv_project 的项目
uv init my_uv_project
cd my_uv_project

Après la mise en œuvre.uv sera en my_uv_project est généré :

.git/ répondre en chantant .gitignoreInitialisation automatique Git et fournit un référentiel commun Python événement sportif .gitignore Documentation.
.python-versionLes projets de recherche et de développement : Documentation des propositions de projets ou des demandes de financement Python (par exemple 3.12).uv se référera à ce document pour sélectionner ou installer le logiciel approprié. Python Interprète.
pyproject.tomlFichier de configuration de base du projet, contenant le nom, la version et la description du projet,Python Exigences en matière de version et vide dependencies Liste.
README.md: un vide README Documentation.
src/my_uv_project/__init__.pyLa structure d'un code source de base (si l'on utilise l'outil de gestion du code source). src (Mise en page). Ou un simple hello.py Exemple de fichier.

# pyproject.toml 示例内容 (可能略有不同)
[project]
name = "my-uv-project"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12" # 根据系统情况或指定版本生成
dependencies = []
[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
# uv 可能还会添加 tool.uv 相关配置

Créer et synchroniser l'environnement (`uv venv`, `uv sync`)

Une fois le projet initialisé, vous devez créer l'environnement virtuel et synchroniser l'état des dépendances (même s'il s'agit d'une dépendance vide, la première synchronisation générera le fichier uv.lock).

Créer un environnement virtuel (uv venv): :
même si uv sync et d'autres commandes créent automatiquement des .venvmais peuvent également être créés explicitement :
```
# 创建默认的 .venv 环境 (uv 会根据 .python-version 或系统查找合适的 Python)
# 这个 .venv 会在当前项目目录下创建
uv venv
# 创建时指定 Python 版本
uv venv --python 3.11
# 指定自定义环境名称 (不常用，因为 uv 生态默认与 .venv 配合)
uv venv my_custom_env
```
Si un environnement de travail manuel est nécessaire (par exemple, l'utilisation d'une machine non uv ), vous devez l'activer :
```
# Linux/macOS
source .venv/bin/activate
# Windows (PowerShell)
.venv\Scripts\Activate.ps1
# Windows (CMD)
.venv\Scripts\activate.bat
```
travailPour la grande majorité des uv Commande (add, remove, sync, run etc.)L'activation manuelle de l'environnement n'est généralement pas nécessaire(math.) genreuv trouvera et utilisera automatiquement le .venv.
Environnement synchronisé (uv sync): :
Il s'agit de l'une des principales commandes utilisées pour garantir que l'état de l'environnement virtuel est identique à l'état de l'environnement de travail. pyproject.toml(via uv.lock documents) ou requirements.txt Le fichier est parfaitement cohérent. La première fois qu'il est exécuté, il :
- récupérer pyproject.toml de la définition de la dépendance.
- Effectue la résolution des dépendances.
- générant uv.lock Documentation.
- existent .venv (initialement, seul le projet lui-même peut être disponible sous la forme d'un paquet modifiable).
```
# 在项目根目录运行
uv sync
```
Après l'exécution, vous verrez .venv Le répertoire est créé ou mis à jour et un uv.lock Documentation.

Gestion des dépendances (`uv add`, `uv remove`, `uv lock`)

c'est uv Les fonctions les plus couramment utilisées, dont l'utilisation est recommandée sur la base des critères suivants pyproject.toml du flux de travail.

Ajouter une dépendance (uv add):
Ajouter le paquet à la base de données pyproject.toml (utilisé comme expression nominale) [project.dependencies] et installe ou met à jour automatiquement le .venv l'environnement. Dans le même temps, les uv.lock Il sera également mis à jour.

# 添加最新稳定版的 pandas
uv add pandas
# 添加 requests，并指定版本约束
uv add "requests>=2.20,<3.0"
# 添加开发依赖 (如测试框架 pytest)，会写入 [tool.uv.dev-dependencies]
uv add pytest --dev
uv add ruff --dev
# 从 Git 仓库添加依赖
uv add git+https://github.com/psf/requests.git
# 添加本地路径的包 (以可编辑模式安装)
uv add -e ../my_local_library

Supprimer les dépendances (uv remove):
à travers (une brèche) pyproject.toml supprime le paquet spécifié de la base de données .venv pour le désinstaller ainsi que les dépendances en aval qui ne sont plus nécessaires.
```
# 移除 pandas
uv remove pandas
# 移除开发依赖 pytest
uv remove pytest --dev
```

Mise à jour des dépendances:

Mettre à jour toutes les dépendances en pyproject.toml La dernière version permise par les contraintes dans et régénérer les uv.lock: :
```
# 1. 更新 lock 文件
uv lock --upgrade
# 2. 应用 lock 文件更新到环境
uv sync
```

Mettre à jour uniquement des paquets spécifiques vers la dernière version :

# 方法一：指定包更新 lock 文件，然后同步
uv lock --upgrade-package requests
uv sync
# 方法二：直接 'add' 最新版 (也会更新 lock 和环境)
uv add requests@latest

édition manuelle pyproject.toml impératrice:
Si vous modifiez directement le pyproject.toml dans le fichier, vous devez effectuer les deux étapes suivantes pour que les modifications soient prises en compte :
1. uv lock : : Basé sur pyproject.toml Le nouveau contenu recalcule les dépendances et met à jour le fichier uv.lock Documentation.
2. uv sync : : Will uv.lock L'état du fichier est synchronisé avec le fichier .venv Environnements virtuels.

Exécuter le code et les commandes (`uv run`)

uv run être uv Une fonction extrêmement pratique. Elle vous permet de créer un fichier dans le uv Exécution dans le contexte d'un environnement virtuel géré Python ou toute autre commande.Pas besoin d'activer manuellement l'environnement au préalable. Il s'agit de uv C'est l'une des principales caractéristiques d'un flux de travail rationalisé qui mérite d'être maîtrisée.

Principe de fonctionnement:

Lorsque vous exécutez le uv run <command> [args...] Le temps :

Découverte automatique de l'environnement: :uv trouvera automatiquement le répertoire courant et le répertoire parent du fichier .venv Environnements virtuels.
Exécution de l'environnement de configuration interne:
- en ce qui concerne uv run python your_script.py une telle ordonnance.uv appellera directement le .venv du répertoire Python Interprète (.venv/bin/python peut-être .venv/Scripts/python.exe) pour exécuter le script.
- en ce qui concerne uv run pytest tests/ peut-être uv run ruff format . une telle ordonnance.uv Veillez àDans le processus enfant qui exécute la commandeDans l'intervalle, le .venv/bin (ou .venv/Scripts) est ajouté au système PATH en tête des variables d'environnement. Ainsi, même si vous n'activez pas l'environnement, le système d'exploitation sera en mesure de trouver et d'exécuter les outils de ligne de commande installés dans l'environnement virtuel (tels que la commande pytest, ruff).

Comment exécuter un fichier Python ?

Pour exécuter le projet Python (par exemple src/my_package/main.py ou le répertoire racine de l'application app.py), ce qui est recommandé :

uv run python src/my_package/main.py
# 或者
uv run python app.py

tranchant:

Aucune activation manuelle n'est nécessaireLe système de gestion de l'information : élimine la nécessité d'entrer dans le système de gestion de l'information de l'UE. source .venv/bin/activate peut-être .venv\Scripts\Activate.ps1 Les tracas de la
Garantie de cohérence environnementaleLes outils et le code s'exécutent toujours dans l'environnement virtuel correspondant à la configuration de votre projet.
Simplifier les scripts CI/CDDans les processus automatisés tels que GitHub Actions, GitLab CI) peut être utilisé directement dans le uv run Effectuer des tâches telles que les tests, la construction et le déploiement sans avoir à gérer une logique complexe d'activation de l'environnement.

plus uv run exemple typique:

# 运行安装在环境中的 pytest 测试
uv run pytest tests/
# 运行安装在环境中的 ruff 代码格式化
uv run ruff format .
# 运行任意系统命令，uv 会确保 .venv/bin 在 PATH 中
uv run alembic upgrade head
# 向脚本传递参数
uv run python your_script.py --input data.csv --output results.json

Quand dois-je encore procéder à une activation manuelle ?

Activation manuelle (source activate ou des commandes similaires) a été considérablement réduite. Probablement principalement dans la même session Shell que celle dont vous avez besoin :

Exécution interactive fréquente de plusieurs commandes dépendant de l'environnement virtuel (par exemple, saisie directe de la commande python Allez dans l'interpréteur et ensuite dans le pytestEt encore. ruff).
Utilisez certaines variables d'environnement spécifiques qui dépendent des paramètres du script d'activation (autres que la variable d'environnement PATH (autre que) le non Python Outils.

Mais pour la plupart des tâches de développement quotidiennes, l'applicationuv run La gestion automatisée de l'environnement est plus pratique et plus efficace.

utiliser `requirements.txt` (compatible avec le flux de travail)

même si uv Recommandé pyproject.tomlmais il prend également en charge les requirements.txt des flux de travail, et fournit pip Interface de commande compatible et plus rapide.

Installer les dépendances (uv pip install):

# 安装单个包
uv pip install flask
# 从 requirements 文件安装
uv pip install -r requirements.txt
# 可以同时指定多个文件
uv pip install -r requirements.txt -r requirements-dev.txt
# 安装当前项目 (以可编辑模式)
uv pip install -e .

Désinstallation des dépendances (uv pip uninstall):

uv pip uninstall flask
# 从文件批量卸载
uv pip uninstall -r requirements-to-remove.txt

Générer une liste de dépendances (uv pip freeze):

# 输出当前环境安装的所有包 (类似 pip freeze)
uv pip freeze > requirements.lock.txt # 常用于生成锁定文件

Compiler les dépendances (uv pip compile) (Recommandé requirements flux de travail):
Cette approche est similaire à pip-tools. Vous maintenez un requirements.in (qui ne contient que des dépendances directes), puis utiliser le fichier uv Générer la version exacte du requirements.txt Verrouiller le fichier.
```
# requirements.in 内容示例:
# flask
# requests>=2.25
# 生成 requirements.txt
uv pip compile requirements.in -o requirements.txt
# 为开发环境编译 (假设有 requirements-dev.in)
# uv pip compile requirements-dev.in -o requirements-dev.txt
```
Environnement synchronisé (uv pip sync):
Sur la base d'un ou plusieurs requirements.txt Le contenu du fichier est synchronisé avec précision avec l'environnement virtuel : les paquets manquants sont installés et les paquets redondants sont supprimés.
```
# 同步主依赖和开发依赖
uv pip sync requirements.txt requirements-dev.txt
```

Voir les paquets installés (uv pip list, uv pip show, uv pip tree):

uv pip list          # 列出已安装的包和版本
uv pip show flask    # 显示 flask 包的详细信息
uv pip tree          # 以树状结构显示依赖关系

Gestion des versions de Python (`uv python`)

uv Téléchargement, gestion et sélection intégrés Python de la fonctionnalité, similaire à la version pyenv. (Rappelez-vous qu'il est possible de le faire par l'intermédiaire de la UV_PYTHON_INSTALL_DIR Les variables d'environnement configurent ces Python (position de montage)

Liste des versions disponibles et installées (uv python list):

# 列出已安装和当前使用的版本
uv python list
# 显示所有可供下载的补丁版本
# uv python list --all-versions
# 只显示已安装的版本
uv python list --only-installed

Installer la version de Python (uv python install):
```
# 安装最新的稳定版 (如果尚未安装)
uv python install
# 安装特定版本
uv python install 3.11.5
# 安装 3.10 系列的最新可用版
uv python install 3.10
```
uv enverra le fichier téléchargé Python Installer le logiciel dans son répertoire géré (uv python dir Le chemin peut être consulté, sous réserve de UV_PYTHON_INSTALL_DIR ).

Désinstaller la version Python (uv python uninstall):

uv python uninstall 3.10.8
# 卸载 3.11 系列所有已安装版本
uv python uninstall 3.11

Correction de la version Python du projet (uv python pin):
Création ou mise à jour dans le répertoire actuel .python-version qui déclare que le projet doit utiliser le fichier Python Version.
```
uv python pin 3.11
```
au-delà uv venv, uv run, uv sync et d'autres commandes trouveront et utiliseront de préférence cette version.

Trouver l'interpréteur Python (uv python find):

# 查找匹配 3.12 的 Python 解释器路径
uv python find 3.12

Gérer les outils globaux (`uv tool`)

uv Il pourrait s'agir de pipx Comme toujours, installez et exécutez le programme global Python CLI et isoler chaque outil dans un environnement distinct afin d'éviter les conflits de dépendance. (De même, l'emplacement de stockage des outils peut être modifié à l'aide de la commande UV_TOOL_INSTALL_DIR configuration de la variable d'environnement)

Outils d'exécution (mise en œuvre ad hoc, etc.) uv tool run peut-être uvx):
Télécharge temporairement (si nécessaire) et exécute l'outil, et ne le conserve pas après l'exécution. Cette fonction est très pratique pour les outils à usage unique.uvx être uv tool run La forme abrégée.
```
# 运行 ruff 检查当前目录，临时下载 ruff
uv tool run ruff check .
# 使用简写 uvx
uvx ruff check .
# 如果命令名 (http) 和包名 (httpie) 不同，使用 --from
uvx --from httpie http https://example.com
```
Installation d'outils globaux (uv tool install):
Installer l'outil et ses dépendances dans le répertoire uv et lier son exécutable au chemin d'accès de l'utilisateur (ce qui peut nécessiter le redémarrage du terminal ou la configuration manuelle de l'interface utilisateur). PATH (pour pouvoir l'appeler directement). Ceci est similaire à la fonction pipx install.
```
uv tool install black
uv tool install httpie
```
Une fois installé, il peut théoriquement être exécuté directement de n'importe où. black . peut-être http https://example.com.
Liste des outils installés (uv tool list):
```
uv tool list
```

Outil de mise à niveau (uv tool upgrade):

uv tool upgrade black
# 升级所有已安装工具
# uv tool upgrade --all

Outils de désinstallation (uv tool uninstall):
```
uv tool uninstall black
```
Afficher le répertoire d'installation de l'outil (uv tool dir):
démontrer uv Le chemin racine où les outils globaux et leurs environnements sont stockés (sous réserve de l'option UV_TOOL_INSTALL_DIR ).

Gestion du cache (`uv cache`)

uv Utilisez le cache global pour accélérer le processus de téléchargement et de construction des paquets. (L'emplacement du cache est accessible via la commande UV_CACHE_DIR configuration de la variable d'environnement)

Effacer le cache (uv cache clean):
Supprimer tout uv Contenu mis en cache. Cette fonction peut être utilisée pour résoudre d'éventuels problèmes de pollution du cache ou pour libérer de l'espace disque.
```
uv cache clean
```
Afficher le répertoire du cache (uv cache dir):
Voir le courant uv L'emplacement où le fichier cache est stocké (sous réserve de l'autorisation de l'autorité compétente). UV_CACHE_DIR ).

Gestion de projet à scénario unique

Pour certains widgets ou scripts simples, l'optionuv Elle prend en charge une approche de gestion très légère : elle intègre les métadonnées et les dépendances du projet directement dans la base de données du Python dans un bloc de commentaires spécial dans l'en-tête du script.

Script d'initialisation (uv init --script):

# 创建一个名为 my_script.py 的脚本，并指定 Python 版本要求
uv init --script my_script.py --python ">=3.10"

Ce sera dans le my_script.py Un bloc de commentaires similaire au suivant est généré au début du fichier :

#!/usr/bin/env python
# /// script
# requires-python = ">=3.10"
# dependencies = [
# ]
# ///
import sys
def main() -> None:
print(f"Hello from {sys.argv[0]}!")
if __name__ == "__main__":
main()

Ajouter/supprimer des dépendances de script (uv add/remove --script):
Peut être utilisé directement add peut-être remove en conjonction avec l'ordonnance de la --script pour modifier la liste des dépendances dans l'en-tête du script.
```
# 为 my_script.py 添加 requests 依赖
uv add --script my_script.py requests
# 从 my_script.py 移除 requests 依赖
uv remove --script my_script.py requests
```
Ces commandes modifient directement l'en-tête du fichier de script. dependencies Liste.
Exécuter le script (uv run):
Utilisation directe uv run Le script peut être exécuté.
```
uv run my_script.py
```
uv lit automatiquement les métadonnées de l'en-tête du script, crée un environnement virtuel temporaire à la demande, installe les dépendances qui y sont déclarées, puis exécute le script. Cette approche est idéale pour distribuer un script unique et autonome. Python Script de l'outil.

Perspectives d'avenir et recommandations

uv Il s'agit sans aucun doute d'un projet ambitieux et en pleine expansion. Il s'appuie sur Rust Les avantages en termes de performances et l'interface unifiée et bien conçue promettent d'améliorer de manière significative le système de gestion de l'information de l'entreprise. Python L'expérience du développeur en matière de gestion des paquets et de l'environnement. Ses valeurs fondamentales sont les suivantestemporépondre en chantantconforme.

(aller de l'avant et le faire) sans hésiter uv Relativement jeune, l'écosystème (par exemple les intégrations profondes d'IDE, les ressources de tutoriels tiers) se développe encore rapidement et les commandes ou les comportements peuvent être légèrement modifiés entre les versions en raison de son itération active (il est recommandé de garder un œil sur son changelog).

Mais pour l'instant.uv La fonctionnalité de base est assez stable et robuste.

suggestion:

en ce qui concerneentrant Python événement sportifIl est fortement recommandé que l'adoption directe des uv. Il offre une expérience de gestion rafraîchissante et efficace dès le départ.
Pour ceux quiSouffrant des chaînes d'outils existantes (par ex. pip + virtualenv + pip-tools Les problèmes de complexité ou de performance (combinés) affectent les systèmes d'information et de communication.de développeurs et d'équipes.uv est une alternative très attrayante qui vaut la peine d'investir du temps dans l'évaluation et la migration pour l'essayer.
Pour ceux qui ont utilisé en profondeur Poetry peut-être PDM et s'appuient sur leurs fonctions avancées spécifiques (par exemple, systèmes de plug-in complexes, gestion fine du processus de diffusion), la migration peut nécessiter une évaluation plus minutieuse, en pesant les avantages et les inconvénients de la migration. uv La rapidité et la simplicité qui en découlent s'opposent à la perte potentielle de certaines fonctionnalités.

uv est en passe de devenir Python Une force avec laquelle il faut compter dans les flux de travail de développement, son émergence pourrait être aussi importante que la création de l'Agence européenne pour l'environnement. ruff Comme dans le cas de Python La communauté a déclenché un nouveau cycle d'innovation en matière d'outils. Son avenir mérite une attention soutenue.