Python Virtual Environments allows you to create dependency-specific projects. It helps the programmer to manage different Python package versions across various projects.

Python applications often use external packages and modules that do not come with the standard library. Sometimes, the application may require a specific version of a library.

It means using the same version of a library across various projects might cause conflicts. If application A needs version 1.0 of a particular module and application B needs version 2.0 of the same module.

Using a virtual environment can help you resolve such conflict. That way, application A can have version 1.0 and application B can have another version of the same module.

This article will teach you how to use the `venv` module to create a lightweight virtual environment and `pip` to manage Python packages in your virtual environment.

What Is A Virtual Environment?

A virtual environment is a self-isolated space where installed software packages live without affecting the global system.

It helps isolate projects, ensuring they have their own set of dependencies to avoid conflict with other projects on the same system.

Creating a Virtual Environment

The tool used in creating and managing virtual environments is known as `venv`. `venv` typically installs the latest Python version accessible on your system.

To create a virtual environment, navigate to the projects directory and run the `venv` module as a script with the directory path.

python -m venv test-env

This command will create a `test-env` directory if it does not exist. Additionally, it will create sub-folders within it that include a copy of the Python interpreter and various supporting files.

Where you have multiple Python versions on your system, you can select a specific Python version by running `python3` or whichever version you want.

Activating a Virtual Environment

Once you have created the virtual environment, you can activate it with the command below.

source test-env/Scripts/activate

It will modify the environment so that when you run the `python` command, it corresponds to the specific version and installation of Python. For instance:

$ source test-env/Scripts/activate
(test-env) 
$ python
Python 3.12.0 (default, Oct  2 2023, 10:59:36)
    ...
>>> import sys
>>> sys.path
['', '~\\Python312\\python312.zip', ...,
'~\\test-env\\Lib\\site-packages']
>>> exit()

Notice that the `sys` module is located in a path inside the virtual environment.

Deactivating a Virtual Environment

To deactivate a virtual environment, type `deactivate` in your terminal.

(test-env)
$ deactivate

$

Managing Python Packages with pip

You can manage Python packages using a program called `pip`. `pip` allows you to install, upgrade, and remove packages.

By default, `pip` will install packages from the Python Package Index. `pip` includes several subcommands such as "install", "uninstall", "freeze", and more.

To install the latest version of a package, you can do so by running the following commands, along with the package's name.

(test-env)
$ python -m pip install numpy
Collecting numpy
    ...
Successfully installed numpy-1.26.2

You can also install a specific version of a package by giving the package name followed by == and the version number:

(test-env)
$ python -m pip install Django==3.0
Collecting Django==3.0
    ...
Successfully installed Django-3.0

If you execute this command again, pip will recognize that the specified version is installed on your computer and will take no action.

To obtain a different version, you specify a different version number or use "python -m pip install --upgrade <package>" to update the package to the most recent version.

`pip` has subcommands that you can use to manage packages in the virtual environment. Some useful commands are;

1. python -m pip uninstall <package1> <package2> - This will remove the packages from the virtual environment.

2. python -m pip list - This will list all the packages installed in the virtual environment.

3. python -m pip show <package1> - This will display information about a particular package in the virtual environment.

Create a requirements.txt file

Executing `python -m pip freeze` generates a comparable list of installed packages, with the output formatted for use with `python -m pip install`. A common practice is to store the list in a `requirements.txt` file:

(test-env)
$ python -m pip freeze > requirements.txt
(test-env)
$ cat requirements.txt
numpy==1.26.2
Django==3.0

The `requirements.txt` file can be added to version control as part of an application. This allows users to install all the required packages using `install -r`

(test-env)
$ python -m pip install -r requirements.txt
Collecting numpy==1.26.2 (from -r requirements.txt (line 1))
  ...
Collecting Django==3.0 (from -r requirements.txt (line 2))
  ...
Installing collected packages: numpy, Django
  ...
Successfully installed numpy-1.26.2 Django-3.0
(test-env)
$

Summary

This article explores the fundamentals of virtual environments in Python. It begins by defining what a virtual environment is and delves into the process of creating one.

The article also covers the essential skill of managing Python packages using the pip tool within virtual environments.

Additionally, it emphasizes the importance of creating a requirements.txt file, offering a standardized approach for package management and version control.

The article is a comprehensive guide to understanding, creating, and effectively utilizing virtual environments in Python development.