comandos comuns uv

Python A Eco nunca teve falta de ferramentas de gerenciamento de embalagens e de gerenciamento ambiental, desde o clássico pipevirtualenv até pip-toolsecondae depois a modernização do PoetryePDM E assim por diante. Cada ferramenta tem sua área de especialização, mas isso também costuma tornar a cadeia de ferramentas de um desenvolvedor fragmentada e complexa.

Agora, a partir de Astral Empresa (conhecida) Python Linter Ruff (o criador do uv O Crossing abriu novas possibilidades. Este produto usa Rust ferramentas escritas no idioma, aspira a ser um Rápido, unificado e amigável ao desenvolvedor Python Gerente de pacotes e projetos. Seu objetivo é claro: aproveitar Rust ecologicamente correto Cargo A experiência bem-sucedida da empresa oferece uma solução completa.uv Além de ser rápido, ele também integra gerenciamento de ambiente, instalação de pacotes, resolução de dependências, gerenciamento de projetos e muito mais.

Por que UV?

Em comparação com as ferramentas existentesuv Oferecendo uma alternativa mais moderna e eficiente para seus principais destaques:

1. Melhoria significativa da velocidadeBaseado em Rust de otimização de tempo de compilação e processamento simultâneo eficiente.uv Em operações comuns, como resolução de dependências e instalação de pacotes, ele é mais rápido do que as ferramentas tradicionais, como o pip talvez PoetryO sistema de armazenamento em cache global integrado também torna as operações repetitivas quase instantâneas. O mecanismo de cache global eficiente incorporado também torna as operações repetitivas quase instantâneas. Por trás disso está o Rust recursos da linguagem (por exemplo, simultaneidade sem medo devido à segurança da memória) e bibliotecas subjacentes de alta qualidade (por exemplo, a TokioeReqwest) Créditos.
2. Integração funcional completa::uv Com a intenção de ser um "canivete suíço" nas mãos dos desenvolvedores, ele abrange tudo, desde a criação e o gerenciamento de ambientes virtuais até a instalação e o bloqueio de dependências (suporte nativo). pyproject.tomlcompatível requirements.txt), para executar scripts, gerenciar ferramentas globais e até mesmo instalar Python versão do processo de desenvolvimento completo.
3. Gerenciamento moderno de projetosSuporte nativo pyproject.toml (padrão PEP 517/518/621), que é o padrão moderno de Python O perfil padrão de fato do projeto.uv Capacidade de lidar claramente com agrupamentos de dependências (por exemplo, dependências de desenvolvimento) e gerar dependências entre plataformas uv.lock Arquivo bloqueado. Esse arquivo de bloqueio registra com precisão as versões específicas e as origens de todas as dependências diretas e indiretas, garantindo que um ambiente completamente consistente possa ser reconstruído em qualquer máquina, a qualquer momento, para uma compilação verdadeiramente determinística.
4. Boa compatibilidade::uv Fornece um link para o pip Interface de comando altamente compatível (uv pip ...) e pode entender requirements.txt que possibilita a migração de projetos existentes para o formato de arquivo uv O processo é relativamente tranquilo.
5. Desenvolvimento ativo e o futuro:: Por Astral A equipe mantém ativamente e faz iterações rápidas usando o MIT Licença de código aberto. Grande interesse da comunidade, grande potencial de desenvolvimento e um futuro promissor.

fazer uso de uvSe a empresa não tiver um sistema de gerenciamento de dados, espera-se que os desenvolvedores tenham uma experiência semelhante. Node.js ( npm / yarn / pnpm ) ou Rust ( Cargo ) como fluxos de trabalho de gerenciamento de dependências fluidos e uniformes.

Instalação de UV

montagem uv Muito simples. A recomendação oficial é usar o script de instalação fornecido, pois ele não depende do script de instalação existente. Python Meio ambiente. É claro que, ao pip ou o System Package Manager também são opções viáveis.

• Método recomendado (scripting entre plataformas)::

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

  tomar nota deO script oficial definirá por padrão o uv Instale em um local específico no diretório do usuário (por exemplo Linux / macOS (usado em uma expressão nominal) ~/.uv/bin talvez Windows (usado em uma expressão nominal) %LOCALAPPDATA%\uv\bin), que geralmente está localizado no disco do sistema (por exemplo C: (Disco).

• Usando o pip (requer um ambiente Python existente)::

  pip install uv
  # 或推荐使用 pipx 进行隔离安装
  # pipx install uv
  

  Se o seu Python Ambiental ou pipx O ambiente em si não está no disco do sistema e, ao instalá-lo dessa forma, o uv Em geral, ele também segue sua posição. Você pode definir isso configurando o parâmetro PIPX_HOME Variáveis de ambiente para controle pipx O caminho de instalação do

• Usando o System Package Manager (exemplo)::

  # macOS (Homebrew)
  brew install uv
  # Windows (Scoop)
  # 可以先将 Scoop 本身安装到非系统盘，然后用它安装 uv
  scoop install uv
  # Arch Linux
  pacman -S uv
  

  Se, como no caso de Scoop Esse gerenciador de pacotes é configurado em um disco que não é do sistema e, em seguida, os aplicativos que ele instala (incluindo o uv) geralmente também são instalados na mesma unidade.

• Uso do Cargo (requer um ambiente Rust)::

  cargo install uv --locked --git https://github.com/astral-sh/uv
  

  uv será instalado no diretório Cargo (usado em uma expressão nominal) bin Catálogo. Isso pode ser feito definindo a opção CARGO_HOME A variável de ambiente define todo o .cargo (que contém o arquivo crates e produtos compilados) migraram para discos que não são do sistema.

Após a conclusão da instalação, execute uv --version talvez uv help para verificar se a instalação foi bem-sucedida.

Configuração do local de armazenamento de dados UV (avançado)

Por padrão, ouv Ele armazenará em cache, fará o download do Python bem como através da versão uv tool install As ferramentas globais instaladas são armazenadas em um local padrão no diretório do usuário (geralmente na unidade do sistema). Se desejar armazená-las em outra unidade (como o diretório D: para economizar espaço no disco do sistema ou para reduzir o tempo de espera. SSD Write, que pode ser definido pela configuração dovariável de ambientepara que isso aconteça.

Aqui estão algumas das principais variáveis de ambiente:

• UV_CACHE_DIR: Controle uv Localização do diretório do cache. O cache inclui arquivos de pacotes baixados, compilados wheel etc., que podem ocupar mais espaço.
• UV_PYTHON_INSTALL_DIR:: Controle por meio de uv python install baixado e gerenciado Python O local onde o interpretador será instalado.
• UV_TOOL_INSTALL_DIR:: Controle por meio de uv tool install Global instalado Python Local de armazenamento de ferramentas e seus ambientes isolados.

Como definir variáveis de ambiente (exemplo):

Suponha que o objetivo seja combinar todos os uv Os dados são armazenados no D:\uvdata Catálogo.

• Windows (PowerShell - configuração temporária, válida apenas para a sessão atual):

  $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 (variáveis de ambiente do sistema - configurações permanentes):
  1. existir Windows Procure por "environment variables" (variáveis de ambiente) na barra de pesquisa.
  2. Clique em "Edit System Environment Variables" (Editar variáveis de ambiente do sistema).
  3. Na caixa de diálogo "Propriedades do sistema", clique no botão "Variáveis de ambiente...". botão.
  4. Na área "User Variables" (Variáveis do usuário) ou "System Variables" (Variáveis do sistema) (recomenda-se usar as variáveis do usuário, a menos que seja necessário para todos os usuários), clique em "New ..." .".
  5. Digite o nome da variável (por exemplo UV_CACHE_DIR) e valores variáveis (como D:\uvdata\cache).
  6. Repita esse procedimento para as outras duas variáveis.
  7. Clique em "OK" para fechar todas as caixas de diálogo.
  8. crux:: Obrigatórioreabrir PowerShell ou na janela do prompt de comando para que a nova variável de ambiente entre em vigor.
• Linux / macOS (bash/zsh - configurações temporárias):

  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 (configuração permanente):
  topológico export em seu arquivo de configuração do Shell (por exemplo ~/.bashrc, ~/.zshrc, ~/.profile) e, em seguida, execute o source ~/.your_config_file ou reinicie o terminal para que a configuração tenha efeito.

Observações importantes:

• Depois de definir essas variáveis de ambiente, ouv Os caminhos especificados são usados automaticamente. Certifique-se de que esses diretórios existam e que uv Ter acesso de gravação.
• Ambiente virtual (.venv) posição: uv venv Padrões em seuDiretório raiz do projetoCriar .venv pasta. Como resultado, oDesde que o projeto em si esteja localizado em um disco que não seja do sistema (como o D:\myproject), então .venv Naturalmente, ela também estará nesse disco. Normalmente não é necessário fornecer uma lista de .venv Configure os caminhos individualmente para evitar o disco do sistema. Obviamente, você também pode evitar o disco do sistema ao uv venv /path/to/custom/env Especifique explicitamente onde o ambiente virtual deve ser criado, mas isso serve mais para personalizar o caminho do ambiente do que para resolver o problema de armazenamento do disco do sistema.

Ao configurar essas variáveis de ambiente adequadamente, você pode gerenciar de forma eficaz o uv gerada, direcionando-a para um local de armazenamento onde o espaço é mais abundante ou mais adequado.

Conceitos básicos de UV

no uso de uv Ao gerenciar um projeto, é importante entender os seguintes conceitos básicos:

• pyproject.toml: Moderno Python Perfil padrão do projeto (com base no PEP 517/518/621).uv Use-o para definir os metadados do projeto (nome, versão, descrição, etc.), necessários Python Versão (requires-python) e as principais dependências do projeto (dependencies) e grupos de dependências opcionais (por exemplo dev-dependencies). É a "fonte única da verdade" para a configuração do projeto.
• uv.lock:: Por uv Um arquivo bloqueado que é gerado e gerenciado automaticamente. Ele registra com precisão os números de versão específicos e os hashes de origem de todas as dependências do projeto (inclusive as dependências indiretas). Seu principal valor é garantir queReprodutibilidade do ambiente: sempre e onde quer que seja baseado no mesmo uv.lock instala as dependências, você obtém exatamente a mesma combinação de pacotes.Esse arquivo não deve ser editado manualmente.
• Ambiente virtual (.venv)::uv Altamente recomendado e simplifica o uso de ambientes virtuais. O padrão é criar um ambiente virtual no diretório raiz do projeto chamado .venv de ambientes isolados para abrigar as dependências do projeto. A maioria dos uv (por exemplo. add, sync, run) são detectados automaticamente e as operações são realizadas nesse ambiente, evitando o Python Poluição do meio ambiente.

Gerenciando projetos Python com UV

Abaixo está uma demonstração, por meio de um processo completo, de como usar uv para criar e gerenciar um Python Projeto.

Inicialize o projeto (uv init)

fazer uso de uv init O comando pode criar rapidamente a estrutura básica de um novo projeto.

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

Após a implementação.uv estará em my_uv_project é gerado:

• .git/ responder cantando .gitignoreInicialização automática Git e fornece um repositório comum de Python evento esportivo .gitignore Documentação.
• .python-versionDocumentação de propostas de projetos ou solicitações de Python versão (por exemplo. 3.12).uv consultará este documento para selecionar ou instalar o Python Intérprete.
• pyproject.tomlArquivo de configuração central do projeto, contendo o nome, a versão e a descrição do projeto,Python Requisitos de versão e vazio dependencies Lista.
• README.md: um vazio README Documentação.
• src/my_uv_project/__init__.pyUma estrutura básica de código-fonte (se estiver usando o src (Layout). Ou um simples hello.py Exemplo de arquivo.

# 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 相关配置

Criar e sincronizar o ambiente (uv venv, uv sync)

Depois que o projeto for inicializado, você precisará criar o ambiente virtual e sincronizar o estado da dependência (mesmo que seja uma dependência vazia, a primeira sincronização gerará o uv.lock).

1. Criar um ambiente virtual (uv venv)::
   mesmo que uv sync e outros comandos criam automaticamente .venvmas também pode ser criado explicitamente:

   # 创建默认的 .venv 环境 (uv 会根据 .python-version 或系统查找合适的 Python)
   # 这个 .venv 会在当前项目目录下创建
   uv venv
   # 创建时指定 Python 版本
   uv venv --python 3.11
   # 指定自定义环境名称 (不常用，因为 uv 生态默认与 .venv 配合)
   uv venv my_custom_env
   

   Se for necessário um ambiente de operação manual (por exemplo, usando um equipamento não uv gerenciada), então você precisa ativá-la:

   # Linux/macOS
   source .venv/bin/activate
   # Windows (PowerShell)
   .venv\Scripts\Activate.ps1
   # Windows (CMD)
   .venv\Scripts\activate.bat
   

   trabalhoPara a grande maioria dos uv Comando (add, remove, sync, run etc.).A ativação manual do ambiente geralmente não é necessária(matemática) gênerouv localizará e usará automaticamente o .venv.

2. Ambiente sincronizado (uv sync)::
   Esse é um dos principais comandos usados para garantir que o estado do ambiente virtual seja o mesmo que o estado do pyproject.toml(via uv.lock documentos) ou requirements.txt O arquivo é precisamente consistente. Na primeira vez em que for executado, ele será:
   • recuperar pyproject.toml da definição de dependência.
   • Realiza a resolução de dependências.
   • gerando uv.lock Documentação.
   • existir .venv (inicialmente, apenas o projeto em si pode estar disponível como um pacote editável).

   # 在项目根目录运行
   uv sync
   

   Após a execução, você verá .venv O diretório é criado ou atualizado e um uv.lock Documentação.

Gerenciamento de dependências (uv add, uv remove, uv lock)

isto é uv As funções mais comumente usadas, recomendadas para uso com base em pyproject.toml do fluxo de trabalho.

• Adicionar uma dependência (uv add):
  Adicione o pacote à pasta pyproject.toml (usado em uma expressão nominal) [project.dependencies] e instala ou atualiza automaticamente o .venv ambiente. Ao mesmo tempo uv.lock Ele também será atualizado.

  # 添加最新稳定版的 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
  

• Remover dependências (uv remove):
  através de (uma lacuna) pyproject.toml remove o pacote especificado do diretório .venv para desinstalá-lo e as dependências downstream que não são mais necessárias.

  # 移除 pandas
  uv remove pandas
  # 移除开发依赖 pytest
  uv remove pytest --dev
  

• Atualização de dependências:
  • Atualize todas as dependências para pyproject.toml A versão mais recente permitida pelas restrições e regenera o uv.lock::

    # 1. 更新 lock 文件
    uv lock --upgrade
    # 2. 应用 lock 文件更新到环境
    uv sync
    

  • Atualizar apenas pacotes específicos para a versão mais recente:

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

• edição manual pyproject.toml imperatriz:
  Se você modificar diretamente o pyproject.toml no arquivo, é necessário executar as duas etapas a seguir para que as alterações tenham efeito:
  1. uv lock :: Baseado em pyproject.toml O novo conteúdo recalcula as dependências e atualiza o uv.lock Documentação.
  2. uv sync :: Will uv.lock O estado no arquivo é sincronizado com o .venv Ambientes virtuais.

Execute o código e os comandos (uv run)

uv run ser uv Um recurso extremamente conveniente. Ele permite que você crie um arquivo na pasta uv Execução no contexto de um ambiente virtual gerenciado Python script ou qualquer comando.Não há necessidade de ativar manualmente o ambiente com antecedência. Isto é uv Um dos principais recursos de um fluxo de trabalho simplificado que vale a pena dominar.

Princípio de funcionamento:

Quando você executa o uv run <command> [args...] Tempo:

1. Descoberta automática do ambiente::uv localizará automaticamente o diretório atual e o diretório pai do .venv Ambientes virtuais.
2. Execução do ambiente de configuração interna:
   • com relação a uv run python your_script.py tal ordem.uv chamará diretamente o .venv do diretório Python Intérprete (.venv/bin/python talvez .venv/Scripts/python.exe) para executar o script.
   • com relação a uv run pytest tests/ talvez uv run ruff format . tal ordem.uv não se esqueça deDentro do processo filho que executa o comandoO interino será .venv/bin (ou .venv/Scripts) é adicionado ao sistema PATH na parte superior das variáveis de ambiente. Dessa forma, mesmo que você não ative o ambiente, o sistema operacional poderá encontrar e executar as ferramentas de linha de comando instaladas no ambiente virtual (como o pytest, ruff).

Como faço para executar um arquivo Python?

Para executar o projeto Python (por exemplo. src/my_package/main.py ou o diretório raiz do app.py), o que é recomendado:

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

de ponta:

• Não é necessária ativação manualElimina a necessidade de inserir source .venv/bin/activate talvez .venv\Scripts\Activate.ps1 O incômodo da
• Garantia de consistência ambientalGaranta que seu código e suas ferramentas sejam sempre executados no ambiente virtual correto para a configuração do seu projeto.
• Simplificando os scripts de CI/CDEm processos automatizados, como GitHub Actions, GitLab CI) pode ser usado diretamente no uv run Execute tarefas como testes, criação e implementação sem precisar lidar com uma lógica complexa de ativação de ambiente.

mais uv run exemplo típico:

# 运行安装在环境中的 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

Quando ainda preciso fazer a ativação manual?

Ativação manual (source activate ou comandos semelhantes) foi bastante reduzido. Provavelmente, principalmente na mesma sessão do Shell de que você precisa:

• Execução interativa frequente de vários comandos que dependem do ambiente virtual (por exemplo, digitar diretamente o comando python Vá para o interpretador e depois para o pytestE mais uma vez. ruff).
• Use algumas variáveis de ambiente específicas que dependem das configurações do script de ativação (além da variável PATH (que não seja) o não Python Ferramentas.

Mas para a maioria das tarefas de desenvolvimento diárias, ouv run O gerenciamento ambiental automatizado fornecido é mais conveniente e eficiente.

fazer uso de requirements.txt (compatível com o fluxo de trabalho)

mesmo que uv Recomendado pyproject.tomlmas também oferece suporte total ao tradicional requirements.txt fluxos de trabalho e fornece pip Interface de comando compatível e mais rápida.

• Instalar dependências (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 .
  

• Desinstalação de dependências (uv pip uninstall):

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

• Gerar uma lista de dependências (uv pip freeze):

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

• Compilar dependências (uv pip compile) (Recomendado requirements fluxo de trabalho):
  Essa abordagem é semelhante à pip-tools. O usuário mantém um requirements.in (que contém apenas dependências diretas) e, em seguida, use o arquivo uv Gerar a versão exata do requirements.txt Bloquear o arquivo.

  # 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
  

• Ambiente sincronizado (uv pip sync):
  Com base em um ou mais requirements.txt O conteúdo do arquivo é sincronizado com precisão com o ambiente virtual: os pacotes ausentes são instalados e os pacotes redundantes são removidos.

  # 同步主依赖和开发依赖
  uv pip sync requirements.txt requirements-dev.txt
  

• Exibir pacotes instalados (uv pip list, uv pip show, uv pip tree):

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

Gerenciando as versões do Python (uv python)

uv Download, gerenciamento e seleção integrados Python versão do recurso, semelhante à versão pyenv. (Lembre-se de que isso pode ser feito por meio do UV_PYTHON_INSTALL_DIR As variáveis de ambiente configuram esses Python (posição de montagem)

• Lista de versões disponíveis e instaladas (uv python list):

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

• Instale a versão do Python (uv python install):

  # 安装最新的稳定版 (如果尚未安装)
  uv python install
  # 安装特定版本
  uv python install 3.11.5
  # 安装 3.10 系列的最新可用版
  uv python install 3.10
  

  uv enviará o arquivo Python Instale-o em seu diretório gerenciado (uv python dir O caminho pode ser visualizado, sujeito a UV_PYTHON_INSTALL_DIR impacto).

• Desinstale a versão do Python (uv python uninstall):

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

• Corrigida a versão do projeto Python (uv python pin):
  Criar ou atualizar no diretório atual .python-version que declara que o projeto deve usar o arquivo Python Versão.

  uv python pin 3.11
  

  além uv venv, uv run, uv sync e outros comandos encontrarão e usarão preferencialmente essa versão.

• Localize o interpretador Python (uv python find):

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

Gerenciar ferramentas globais (uv tool)

uv Pode ser algo como pipx Como sempre, instale e execute o aplicativo global Python CLI e isolar cada ferramenta em um ambiente separado para evitar conflitos de dependência. (Da mesma forma, o local de armazenamento das ferramentas pode ser alterado com o comando UV_TOOL_INSTALL_DIR configuração da variável de ambiente)

• Ferramentas de execução (implementação ad-hoc, etc.) uv tool run talvez uvx):
  Faz o download temporário (se necessário) e executa a ferramenta e não a retém após a execução. Isso é muito útil para ferramentas de uso único.uvx ser uv tool run A forma abreviada.

  # 运行 ruff 检查当前目录，临时下载 ruff
  uv tool run ruff check .
  # 使用简写 uvx
  uvx ruff check .
  # 如果命令名 (http) 和包名 (httpie) 不同，使用 --from
  uvx --from httpie http https://example.com
  

• Instalação de ferramentas globais (uv tool install):
  Instale a ferramenta e suas dependências no diretório uv ambiente autônomo gerenciado e vincule seu executável ao caminho do usuário (pode ser necessário reiniciar o terminal ou configurar manualmente o PATH (para poder chamá-lo diretamente). Isso é semelhante ao pipx install.

  uv tool install black
  uv tool install httpie
  

  Uma vez instalado, ele pode, teoricamente, ser executado diretamente de qualquer lugar black . talvez http https://example.com.

• Listar as ferramentas instaladas (uv tool list):

  uv tool list
  

• Ferramenta de atualização (uv tool upgrade):

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

• Ferramentas de desinstalação (uv tool uninstall):

  uv tool uninstall black
  

• Visualize o diretório de instalação da ferramenta (uv tool dir):
  demonstrar uv O caminho raiz em que as ferramentas globais e seus ambientes são armazenados (sujeito ao UV_TOOL_INSTALL_DIR impacto).

Gerenciar o cache (uv cache)

uv Use o cache global para acelerar o download do pacote e o processo de compilação. (O local do cache pode ser acessado por meio do comando UV_CACHE_DIR configuração da variável de ambiente)

• Limpar o cache (uv cache clean):
  Excluir tudo uv Conteúdo armazenado em cache. Isso pode ser usado para resolver possíveis problemas de poluição do cache ou para liberar espaço em disco.

  uv cache clean
  

• Exibir o diretório de cache (uv cache dir):
  Ver atual uv O local onde o arquivo de cache está armazenado (sujeito a UV_CACHE_DIR impacto).

Gerenciamento de projetos de script único

Para alguns widgets ou scripts simples, ouv Oferece suporte a uma abordagem de gerenciamento muito leve: incorporação de metadados e dependências do projeto diretamente no Python em um bloco de comentários especial no cabeçalho do script.

1. Script de inicialização (uv init --script):

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

   Isso estará no my_script.py Um bloco de comentários semelhante ao seguinte é gerado no início do arquivo:

   #!/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()
   

2. Adicionar/remover dependências de script (uv add/remove --script):
   Pode ser usado diretamente add talvez remove ordem, em conjunto com o --script para modificar a lista de dependências no cabeçalho do script.

   # 为 my_script.py 添加 requests 依赖
   uv add --script my_script.py requests
   # 从 my_script.py 移除 requests 依赖
   uv remove --script my_script.py requests
   

   Esses comandos modificam diretamente o cabeçalho do arquivo de script dependencies Lista.

3. Execute o script (uv run):
   Uso direto uv run O script pode ser executado.

   uv run my_script.py
   

   uv lê automaticamente os metadados no cabeçalho do script, cria um ambiente virtual temporário sob demanda, instala as dependências declaradas nele e, em seguida, executa o script. Essa abordagem é ideal para distribuir um único script autônomo Python Script da ferramenta.

Perspectivas e recomendações futuras

uv É, sem dúvida, um projeto ambicioso e de crescimento extremamente rápido. Ele se baseia em Rust Os benefícios de desempenho e a interface unificada e bem projetada prometem melhorar significativamente a Python Pacote do desenvolvedor e experiência em gerenciamento de ambiente. Seus principais valores sãotemporesponder cantandoconforme.

(go ahead and do it) without hesitating uv Relativamente novo, o ecossistema (por exemplo, integrações profundas de IDE, recursos de tutoriais de terceiros) ainda está crescendo rapidamente e os comandos ou comportamentos podem ser ligeiramente ajustados entre as versões devido à sua iteração ativa (recomenda-se ficar de olho no registro de alterações).

Mas, por enquanto.uv A funcionalidade principal tem sido bastante estável e robusta.

sugestão:

• com relação ade entrada Python evento esportivoÉ altamente recomendável que a adoção direta de uv. Ele oferece uma experiência de gerenciamento eficiente e renovadora desde o início.
• Para aquelesSofrendo com as cadeias de ferramentas existentes (por exemplo pip + virtualenv + pip-tools (Combinado) complexidade ou problemas de desempenho que afetamde desenvolvedores e equipes.uv é uma alternativa muito atraente e vale a pena investir tempo na avaliação e na migração para experimentá-la.
• Para aqueles que estão usando profundamente o Poetry talvez PDM e dependem de seus recursos avançados específicos (por exemplo, sistemas de plug-in complexos, gerenciamento de processos de liberação refinados), a migração pode exigir uma avaliação mais cuidadosa, ponderando os uv A velocidade e a simplicidade que vêm com ele versus a possível perda de recursos específicos.

uv está se tornando rapidamente Python Uma força a ser considerada nos fluxos de trabalho de desenvolvimento, seu surgimento pode ser tão importante quanto o ruff Por exemplo, no Python A comunidade desencadeou uma nova rodada de inovação de ferramentas. Seu futuro merece nossa atenção contínua.