Python uv : 패키지 관리 도구Python uv: A Package Management Tool

Introducing uv

uv is a Python package and project management tool built in Rust by Astral. Its biggest advantage is that installing packages is incredibly fast.

Take a look at the graph comparing how long pip and other package managers take to install the Trio Python package, and you’ll see just how fast uv is.

> Source : Installing Trio’s dependencies with a warm cache.

It also helps you manage dependencies more efficiently. It’s getting even more attention now that it’s officially recommended for MCP (Model Context Protocol) development.

Installing uv

Follow the Installing uv page to install it.

There are two main ways to install it: through an existing package manager, or as a standalone installation.

Standalone Installation

# On Windows.
> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# On macOS and Linux.
$ curl -LsSf https://astral.sh/uv/install.sh | sh

Installing with an Existing Package Manager

# With pip.
$ pip install uv

# Or pipx.
$ pipx install uv

Verifying the Installation

Check the uv version with the command below to make sure it installed correctly.

$ uv --version

uv 0.6.3 (a0b9f22a2 2025-02-24)

Updating the Version

You can update uv with the command below only if you installed it as standalone.

$ uv self update

uv Command Structure

The basic usage looks like this. Let’s go over a few key commands.

Usage: uv [OPTIONS] <COMMAND>

Commands:
  run      Run a command or script
  init     Create a new project
  add      Add dependencies to the project
  remove   Remove dependencies from the project
  sync     Update the project's environment
  lock     Update the project's lockfile
  export   Export the project's lockfile to an alternate format
  tree     Display the project's dependency tree
  tool     Run and install commands provided by Python packages
  python   Manage Python versions and installations
  pip      Manage Python packages with a pip-compatible interface
  venv     Create a virtual environment
  build    Build Python packages into source distributions and wheels
  publish  Upload distributions to an index
  cache    Manage uv's cache
  self     Manage the uv executable
  version  Display uv's version
  help     Display documentation for a command

Key Commands

You can find the options and descriptions for every command on the CLI Reference page.

• python
• run
• venv
• init
• add / remove
• sync / pip / export
• tree

Key Features of uv

Installing Python: uv python

With the uv python command, you can install whichever Python versions you want in one go.

$ uv python install 3.12 3.13

Running in a Virtual Environment: uv run

With the uv run command, you can run a script while automatically installing any Python version that isn’t installed yet and including the packages it needs.

$ uv run --python 3.10 --with fastapi,pytest main.py

• Automatically downloads and installs Python 3.10 if it isn’t installed
• Installs the fastapi and pytest packages
• Runs the main.py file

Virtual Environments: uv venv

uv venv creates and manages virtual environments. You can create a virtual environment with a specific Python version. If that version isn’t installed, it’s installed automatically.

$ uv venv --python 3.10 .venv

Managing Projects with uv

Initializing a Project: uv init

The uv init command automatically sets up the project structure and generates the basic files you need.

$ uv init my-app --app --python 3.10

└── my-app
   ├── .venv
   ├── README.md
   ├── main.py
   ├── pyproject.toml
   └── uv.lock

• --app: Create a project for an application
• --python <PYTHON>: Set the minimum supported Python version

If needed, you can also add just a pyproject.toml file to an existing project to install and manage packages.

$ uv init --bare

• --bare: Create only the pyproject.toml file
• --script: Create a script
• --package: Set up the project as a Python package
• --lib: Create a project for a library

Managing Packages

You can add packages with uv add.

• --extra <EXTRA>: Install the package’s optional dependencies (extras)
• --dev: Add as a development dependency
• --group <GROUP>: Add the dependency to a specific group

$ uv add fastapi

$ uv add uvicorn --extra standard

$ uv add ruff --dev

$ uv add pytest --group test

[project]
name = "my-app"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.10"
dependencies = [
    "fastapi>=0.115.12",
    "uvicorn[standard]>=0.34.0",
]

[dependency-groups]
dev = [
    "ruff>=0.11.4",
]
test = [
    "pytest>=8.3.5",
]

To remove dependencies, use the uv remove command. It takes options similar to add.

$ uv remove fastapi uvicorn
$ uv remove --dev
$ uv remove --group test

Installing and Syncing Packages

If you have a pyproject.toml file, you can use uv sync. Various options let you choose which groups of packages to install.

# Install all dependencies (default)
$ uv sync

# Install without development dependencies
$ uv sync --no-dev

# Install only development dependencies
$ uv sync --only-dev

# Install including a specific group explicitly
$ uv sync --group test

Or you can install packages from requirements.txt with uv pip install.

$ uv pip install -r requirements.txt

Conversely, the uv export command turns the currently installed packages into a requirements.txt file.

$ uv export -o requirements.txt

Visualizing Dependencies

You can check your project’s dependency structure with uv tree.

$ uv tree

my-app v0.1.0
└── fastapi v0.115.12
    ├── pydantic v2.11.3
    │   ├── annotated-types v0.7.0
    │   ├── pydantic-core v2.33.1
    │   │   └── typing-extensions v4.13.1
    │   ├── typing-extensions v4.13.1
    │   └── typing-inspection v0.4.0
    │       └── typing-extensions v4.13.1
    ├── starlette v0.46.1
    │   └── anyio v4.9.0
    │       ├── exceptiongroup v1.2.2
    │       ├── idna v3.10
    │       ├── sniffio v1.3.1
    │       └── typing-extensions v4.13.1
    └── typing-extensions v4.13.1

Wrapping Up

uv has already established itself as the next-generation Python package and project management tool. On top of that, it’s gaining even more recognition thanks to its use with MCP.

• Speed: Installs packages several times faster than existing tools
• All-in-one management: From Python version management to package installation and virtual environment creation
• Ease of use: A pip-compatible interface makes it easy to pick up
• Project management: Keeps environments consistent with project initialization, dependency management, and lockfile support

If you use Python, install uv and give it a try right now! Thank you! 😊

References

• astral.sh - uv
• Mikuk Engineer: Python: EP122 - Let's Learn About the Insanely Fast uv
• Hwanggeumbyeol blog - Simple Usage and Examples of python `uv`