# The Python Mess
Python packaging has always felt a bit messy to me. For one project, I would use pip to install packages globally because I forgot to create a virtual environment. For another, I would create a venv, forget to activate it, and accidentally install packages globally again.
For bigger projects, I would switch to Poetry for dependency management, packaging, and lock files. It is a powerful tool, but compared to pip, it often felt slow and heavy for the kind of projects I was building.
None of these tools are bad. They are popular for good reasons. pip is the default package installer for Python, venv helps create isolated environments, and Poetry gives you dependency management and reproducible lock files.
But after using uv, I started asking myself one simple question:
Why am I using three different tools when one tool can do most of the work?
# What Is uv?
uv is a fast Python package and project manager built by Astral, the same team behind Ruff.
The easiest way to think about uv is this: instead of using one tool for installing packages, another for virtual environments, another for lock files, and another for managing Python versions, uv brings most of that workflow into one place.
It can replace tools like pip, pip-tools, pipx, Poetry, pyenv, twine, and virtualenv for many common Python workflows.
It is also much faster than the traditional setup. uv is designed to be 10-100x faster than pip (according to Astral’s benchmarks), supports project management, creates lock files, manages Python versions, and still provides a familiar pip-compatible interface.
That sounds like a big claim, but in daily use, the main benefit is simple:
uv makes Python project setup faster, cleaner, and less annoying.
# My Old Python Workflow
Before uv, my Python workflow usually looked something like this.
First, I would create a virtual environment:
python -m venv .venv
source .venv/bin/activate
On Windows, I would activate it with:
.venv\Scripts\Activate.ps1
Then I would install the packages I needed:
pip install pandas scikit-learn streamlit
pip freeze > requirements.txt
For larger projects, I would usually switch to Poetry:
poetry init
poetry add pandas scikit-learn streamlit
poetry run python main.py
This worked, but it always felt like I was jumping between different tools and different workflows.
Sometimes I had a requirements.txt file. Sometimes I had a pyproject.toml file. Sometimes I had a lock file. Sometimes I forgot to activate the virtual environment and installed packages globally by mistake.
None of this was impossible to manage, but it was not clean either. I wanted a workflow that felt faster, simpler, and more consistent across small scripts, data science projects, and larger Python applications.
# My New Workflow With uv
With uv, starting a new Python project feels much simpler.
I can create a project, add dependencies, and run the code with just a few commands:
uv init my-project
cd my-project
uv add pandas scikit-learn streamlit
uv run main.py
That’s it.
When I run these commands, uv handles most of the setup for me. It creates the project structure, manages dependencies in pyproject.toml, creates a .venv environment, and generates a uv.lock file for reproducible installs.
So instead of manually creating a virtual environment, activating it, installing packages, and freezing dependencies, I can let uv manage the full workflow.
The best part is that I do not have to activate the environment every time.
Instead of doing this:
source .venv/bin/activate
python script.py
I can just run:
uv run checks that the environment is in sync with the lock file and then runs the command using the right dependencies.
For me, this is the biggest quality-of-life improvement. I spend less time thinking about environments and more time actually building the project.
# Why I Like uv
The main reason I like uv is that it removes a lot of small annoyances from everyday Python development.
// Bringing the Python Workflow Into One Tool
This is the biggest reason I switched.
Before uv, my workflow was split across different tools. I used pip to install packages, venv or virtualenv to create environments, pip freeze to generate a requirements.txt file, Poetry for larger projects, and sometimes pyenv for managing Python versions.
Each tool solved a different problem, but together the workflow felt scattered.
With uv, most of this can happen in one place:
uv init
uv add requests
uv add --dev pytest
uv run pytest
This creates a cleaner workflow. I can create the project, add dependencies, manage the environment, generate a lock file, and run commands without constantly switching between tools.
That is the real benefit for me. uv is not just a faster pip. It gives me one consistent way to manage Python projects.
// Being Fast
Speed is not everything, but it matters when you are creating projects again and again.
Installing dependencies with pip can feel slow, especially in fresh environments or CI pipelines. uv is written in Rust and is designed for speed, and in my own workflow, that difference is noticeable.
Project setup feels much faster with uv, especially for projects that need heavier dependencies like transformers, torch, scikit-learn, or other data science and machine learning packages.
Another thing I like is that I do not have to think as much about dependency resolution. uv handles the environment, resolves dependencies, updates the lock file, and keeps things in sync automatically.
In normal day-to-day work, this means less waiting, fewer setup issues, and more time actually building.
// Making Project Setup Cleaner
With uv, the project flow feels more modern:
uv init
uv add fastapi
uv add --dev pytest
uv run pytest
This keeps dependencies inside pyproject.toml, creates a lock file, and makes the project easier to reproduce on another machine.
Instead of telling someone:
“Create a virtual environment, activate it, install the requirements, and make sure the Python version is correct.”
You can often just say:
That is much cleaner.
// Making Migration Easy
Another reason I like uv is that I do not have to change everything at once.
If I have an older project that still uses a requirements.txt file, I can use uv without converting the whole project to the full uv workflow.
For example:
uv venv
source .venv/bin/activate
uv pip install -r requirements.txt
On Windows, I can activate the environment with:
.venv\Scripts\Activate.ps1
Then install the dependencies:
uv pip install -r requirements.txt
This is useful because migration does not have to be all or nothing. I can start by using uv as a faster installer in existing projects, then use uv init, uv add, and uv sync for new projects.
That makes uv easy to adopt gradually instead of forcing a full workflow change on day one.
// Managing Python Versions
Another nice feature is that uv can install and manage Python versions too. This means it can also replace parts of a pyenv workflow for many people.
For example, I can install a specific Python version:
Then pin my current project to use that version:
After that, I can create or sync the environment as usual:
So instead of separately managing Python versions, virtual environments, and dependencies, I can keep more of that workflow inside one tool.
# Installing uv
Installing uv is straightforward. Open your terminal or PowerShell and run the command for your operating system.
For macOS and Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
For Windows PowerShell:
irm https://astral.sh/uv/install.ps1 | iex
That is the easiest way to install uv using the official standalone installer.
You can also install uv using pip, Homebrew, WinGet, Scoop, Docker, Cargo, and other methods. But for most users, the standalone installer is the simplest option.
# Should You Switch to uv?
For new Python projects, I think uv is an easy recommendation.
It is fast, modern, and brings project setup, dependency management, virtual environments, lock files, Python versions, and tool execution into one workflow. The docs also say uv provides a familiar pip-compatible interface, so you can start with uv pip before fully moving to uv init, uv add, and uv sync.
That said, I would not tell everyone to switch immediately. For data science beginners, conda is still a good starting point because it is widely used for managing environments and packages in data science workflows.
For vibe coders using AI coding tools, pip, venv, and requirements.txt are still worth knowing because many AI models are trained on older Python workflows and may generate instructions that do not work smoothly with uv.
But for Python developers, product engineers, and people setting up projects often, I would highly recommend trying uv. It gives you a cleaner workflow and also includes uvx, which works like npx for Python tools. You can run Python-based command-line interface (CLI) tools in isolated temporary environments without installing them globally.
So my recommendation is simple: keep conda if you are just starting with data science, learn pip because it is still everywhere, but use uv for new Python projects where you want a faster and cleaner developer experience.
Abid Ali Awan (@1abidaliawan) is a certified data scientist professional who loves building machine learning models. Currently, he is focusing on content creation and writing technical blogs on machine learning and data science technologies. Abid holds a Master’s degree in technology management and a bachelor’s degree in telecommunication engineering. His vision is to build an AI product using a graph neural network for students struggling with mental illness.
