In this tutorial, we’ll dive into the concept of Python virtual environments, uncover their numerous advantages, and explain how to manage them effectively.

Upon completing this tutorial, you’ll have a clear understanding of the following aspects:

• The nature of Python virtual environments
• Advantages of utilizing virtual environments
• Steps to create, enable, disable, and remove virtual environments
• Methods to install dependencies within virtual environments and replicate them on various systems
• Integrating Python virtual environments with Visual Studio Code

If Python installation on Mac is required, you can consult this tutorial on Getting Python Started on Mac.
Note: While this tutorial primarily targets macOS and Linux users, Windows users will also find the content applicable.

Understanding Python Virtual Environments

Python virtual environments encompass two vital elements: the Python interpreter that functions within the environment, and a designated folder housing third-party libraries. These environments remain isolated from others, ensuring that changes to dependencies within one environment do not impact others or the global libraries. Therefore, users can establish multiple virtual environments with varied Python versions and libraries.

The above diagram depicts the setup on your system when multiple Python virtual environments are created. As indicated, a virtual environment is essentially a directory tree housing a specific Python version, various third-party libraries, and additional scripts. There’s no restriction on the number of virtual environments one can have since they are simply directories containing particular files.

The Significance of Python Virtual Environments

Python virtual environments become indispensable when handling numerous Python projects on a single machine with different dependencies. Picture working on two separate data visualization projects utilizing the matplotlib package, each needing versions 2.2 and 3.5, respectively. This could lead to compatibility conflicts since Python cannot concurrently support multiple versions of the same package. Moreover, the need for virtual environments is accentuated when working on managed or production servers where altering global packages is restricted.

Python virtual environments foster isolated spaces, maintaining dependencies for different projects in a segregated manner. Configuring virtual environments is the optimal approach to separate distinct Python projects, particularly when they entail varying and conflicting requirements. A tip for Python beginners: always initiate a unique virtual environment for each Python venture and house all the necessary dependencies within, steering clear of global installations.

We’ve explored what virtual environments are and why they’re essential. We’ll guide you through creating, activating, and working with these environments. Let’s dive right in!

Creating a Python Virtual Environment

Begin by crafting a project folder and generating a virtual environment within it. Fire up your terminal app and type the following command:

~ % mkdir alpha-prj

Next, deploy the venv command to fashion a virtual environment inside the project folder:

~ % python3 -m venv alpha-prj/alpha-venv

NOTE: Two tools for shaping virtual environments are virtualenv and venv, both of which are often interchangeable. While virtualenv supports older Python versions and requires pip for installation, venv is specific to Python 3.3 or above and is part of the standard library, needing no separate installation.

Activating a Python Virtual Environment

Activate the virtual environment we previously crafted by executing this command:

~ % source alpha-prj/alpha-venv/bin/activate

Upon activation, the environment’s name will surface at the terminal’s beginning. Verify activation by running the which python command, revealing the Python interpreter’s location within the environment. Let’s inspect the location:

(alpha-venv) ~ % which python /Users/lotfinejad/alpha-prj/alpha-venv/bin/python

Note that the Python version within the virtual environment aligns with the version used to form it. You can verify the version as follows:

(alpha-venv) ~ % python --version Python 3.10.1

As I utilized Python 3.10 to configure the environment, it adheres to this specific version.

Installing Packages Inside a Python Virtual Environment

Inside this isolated domain, only pip and setuptools are pre-installed. Verify this by running the pip list command:

(alpha-venv) ~ % pip list Package Version ---------- ------- pip 21.2.4 setuptools 58.1.0

Before utilizing pip to add more packages, ensure it’s up to date. As we’re inside the virtual environment, the subsequent command solely upgrades pip within this specific realm:

(alpha-venv) ~ % alpha-prj/alpha-venv/bin/python3 -m pip install --upgrade pip

Recheck the changes:

(alpha-venv) ~ % pip list Package Version ---------- ------- pip 21.3.1 setuptools 58.1.0

With pip updated, let’s install pandas. You can either install the latest version:

(alpha-venv) ~ % python3 -m pip install pandas

Or specify a particular version:

(alpha-venv) ~ % python3 -m pip install pandas==1.1.1

Commands like 'pandas<1.2' or 'pandas>0.25.3' can define constraints for versions. Remember to quote the specifications due to the special meaning of > and < in the command-line shell.

After installing, it’s wise to review the environment’s package list:

(alpha-venv) ~ % pip list Package Version --------------- ------- numpy 1.22.0 pandas 1.3.5 pip 21.3.1 python-dateutil 2.8.2 pytz 2021.3 setuptools 58.1.0 six 1.16.0

While adding pandas, NumPy and some other packages were automatically included as prerequisites, showing the interconnected nature of these packages.

Reproducing a Python Virtual Environment

In real-world scenarios, reproducing a virtual environment is often required. Imagine a situation where your colleague collaborates on a project you’ve been developing. She needs to have the same packages with exact versions installed in her virtual environment. Here’s how you can achieve this:

(alpha-venv) ~ % pip freeze numpy==1.22.0 pandas==1.3.5 python-dateutil==2.8.2 pytz==2021.3 six==1.16.0

(alpha-venv) ~ % pip freeze > requirements.txt

~ % cat requirements.txt

Your colleague can then create the same environment using the requirements.txt file by running:

~ % python3 -m venv prj/venv ~ % source prj/venv/bin/activate (venv) ~ % pip install -r requirements.txt

NOTE: It’s vital to distinguish between a project folder and a virtual environment. The project contains source code, while the virtual environment holds the Python interpreter and tools like pip. The best practice is to keep them separate.

Deactivating a Python Virtual Environment

To exit or switch environments, deactivate the current one:

(alpha-venv) ~ % deactivate

Deleting a Python Virtual Environment

No uninstallation is needed to delete an environment; remove its folder:

~ % rm -rf alpha-prj/alpha-venv

Using Python Virtual Environments in Visual Studio Code

Here’s how you can manage virtual environments in VS Code:

(alpha-venv) alpha-prj % code .

If this doesn’t work, install the code command in PATH through the Command Palette in VS Code.

1. Creating a Python File: Name it my_script.py.
2. Selecting Interpreter: Press Command + Shift + P, type “Python”, and choose “Select Interpreter”. This will display all available environments for you to select.

The integrated terminal in VS Code will now show the active environment, allowing you to manage packages within it.

Conclusion

In this tutorial, we delved into Python virtual environments, revealing how they prevent conflicts between various dependencies. By switching between these isolated environments, they enable working on multiple projects with diverse dependencies, offering a streamlined and conflict-free development experience.