What is a Python virtual environment?

A virtual environment is an isolated Python runtime that gives each project its own set of dependencies and Python version. It prevents package conflicts between projects and avoids modifying the system Python installation.

Do I need a virtual environment in Python?

Yes. Without a virtual environment, all projects share the same packages, which leads to version conflicts when different projects need different versions of the same library. Virtual environments isolate each project so dependencies cannot interfere with each other.

How do I create a Python virtual environment?

Run `python -m venv .venv` to create one with Python's built-in venv module, then activate it with `source .venv/bin/activate` on macOS or Linux, or `.venv\Scripts\Activate.ps1` on Windows. Modern tools like uv create and manage environments automatically when you run `uv sync` or `uv run`, removing the activation step entirely.

What is the difference between venv and virtualenv?

venv ships with the Python standard library since Python 3.3 and creates environments using whatever interpreter you invoke it from. virtualenv is a third-party package that predates venv, supports older Python versions, and creates environments faster by copying a cached set of files instead of bootstrapping pip from scratch. For most modern projects, venv is sufficient and requires no extra installation.

Where should I put my virtual environment?

Place the virtual environment inside the project directory, conventionally as `.venv/`. This is the layout uv, Poetry, and PDM all use by default. Add `.venv/` to `.gitignore` because environments are not portable across machines or operating systems and should be rebuilt from a lockfile or `requirements.txt`.

What is a Virtual Environment?

by Tim Hopper

Virtual Environments

A virtual environment is an isolated Python runtime environment that enables development with project-specific dependencies and Python versions without interference from other projects or the system Python installation.

Think of a virtual environment like a clean workshop for each project. Instead of having all your tools mixed in one garage (which could lead to version conflicts or missing dependencies), each project gets its own dedicated space with precisely the tools it needs.

Without virtual environments, several critical problems emerge when installing Python packages globally:

Version Conflicts: Different projects often require different versions of the same package
Dependency Pollution: Global package installation makes tracking project-specific requirements difficult
System Integrity Risk: Modifying system Python packages can break system tools that depend on specific versions
Poor Reproducibility: Lack of isolation makes it challenging to ensure consistent behavior across different machines

A virtual environment consists primarily of:

A Python interpreter (or symlinks to one)
A dedicated site-packages directory for installing dependencies
Activation scripts that modify shell environment variables
Configuration files specifying the environment’s properties

How activation works

Creating a virtual environment does not change anything by itself. Activating it rewrites the shell’s PATH so that the environment’s python and pip take precedence over the system installation. The command depends on the platform and shell:

source .venv/bin/activate

After activation, the shell prompt usually changes to show the environment name in parentheses, and running pip or python invokes the environment’s copies. Running deactivate restores the original shell.

What isolation looks like in practice

A short console session makes the abstract idea of isolation concrete. On macOS or Linux:

$ which python
/usr/bin/python

$ python -m venv .venv
$ source .venv/bin/activate

(.venv) $ which python
/path/to/project/.venv/bin/python

(.venv) $ pip install cowsay
(.venv) $ python -c "import cowsay; print(cowsay.__file__)"
/path/to/project/.venv/lib/python3.14/site-packages/cowsay/__init__.py

(.venv) $ deactivate
$ python -c "import cowsay"
ModuleNotFoundError: No module named 'cowsay'

Inside the environment, cowsay imports from a file inside .venv/. Outside, the import fails entirely. Nothing was written to the system Python, and a second project can maintain its own independent set of packages without touching this one.

Modern Virtual Environment Management

While traditional tools like venv and virtualenv require manual environment creation and activation, modern tools like uv handle virtual environments automatically:

Creates environments on demand
Installs dependencies into the environment automatically
Activates project environments implicitly when running commands
Maintains environment synchronization with project requirements

Traditional vs Modern Environment Creation

Traditional approach: three commands plus an explicit activation step.

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python main.py

Modern approach with uv: one command that creates the environment, installs dependencies from pyproject.toml, and runs the script.

uv run main.py

Learn More

How to create and use a Python virtual environment with venv walks through the create / activate / install / deactivate lifecycle step by step.
Why should I use a virtual environment?
How to require a virtualenv when installing packages with pip
How to customize uv’s virtual environment location
venv reference
virtualenv reference

Last updated on April 27, 2026

What is a version specifier?What Is an Editable Install?

Please submit corrections and feedback...