Introduction

In this world of diverse programming needs, Python stands out for its simplicity. However, managing multiple projects with different dependencies can be a challenge. Enter Python Virtual Environments. This post will explore what they are, their importance in Python development, and why they’re essential for maintaining an efficient and organized workflow. Ideal for both experienced developers and newcomers, we’ll uncover how Python Virtual Environments can revolutionize your project management. Let’s dive in and discover this key tool for streamlined programming.

What is Python venv?

Python venv, short for virtual environment, is an isolated runtime environment that allows developers to work on a specific project without affecting others. It is a feature built into Python since version 3.3, as a part of the standard library.

A virtual environment is a self-contained directory tree that contains a Python installation for a particular version of Python, along with a number of additional packages. Different applications can then use different virtual environments, thereby avoiding conflicts between different versions of the same package.

Why Use Python venv?

Virtual environments are essential tools for Python developers for several reasons:

1. Isolation: A virtual environment helps you keep your project dependencies isolated from each other. This isolation ensures that each of your projects can have its own set of dependencies, which can be helpful when different projects require different versions of the same package.
2. Versatility: The ability to switch between different versions of Python is helpful when testing code compatibility across different Python versions.
3. Simplicity: Virtual environments make it easy to manage dependencies. This helps simplify the process of sharing your code or deploying it to production.
4. Consistency: They ensure that everyone on your team is working with the same set of dependencies, which helps eliminate the “works on my machine” problem.

For an example, we have 2 versions of Python existing in our system:

• Python 3.10 has package requests==2.3.0
• Python 3.8 has package requests==2.0.0

In project A, we need Python 3.8 with requests==2.0.0:

Now in folder of project A we can call: python3.8 main.py, it will execute the file main.py that we wrote that needs requests==2.0.0. It is fine now right?

But what if we have another project B that needs Python 3.8 and requests==2.3.0?

In project B, we cannot reuse the global Python 3.8 anymore. If we do python3.8 main.py then it will use requests==2.0.0. We cannot use Python 3.10 either… So how do we do it?

How to Use Python venv

Let’s get into the step-by-step guide on how to use Python venv.

Continuing with our example on project B, in the project’s folder:

Step 1: Creating a Virtual Environment

To create a virtual environment, decide upon a directory where you want to place it, and run the venv module as a script with the directory path:

python3.8 -m venv venv

This command will create a directory named venv if it doesn’t already exist, and also create directories inside it containing a copy of the Python interpreter, the standard library, and various supporting files.

Step 2: Activating the Virtual Environment

Before you can start installing or using packages in your virtual environment, you’ll need to activate it. Activating this environment will put the virtual environment-specific python and pip executables into your shell’s PATH.

On Windows:

venv\Scripts\activate.bat

On Unix or MacOS:

source venv/bin/activate

After this, we have an output like this:

~/projectB $ python3.8 -m venv venv 

~/projectB $ source venv/bin/activate

(venv) ~/projectB $ python3.8 -V

Python 3.8.15

(venv) ~/projectB $ python -V 

Python 3.8.15

It’s handy to use python instead of python3.8 now, because in your isolated environment, Python 3.8 is the default Python for you!

Step 3: Using the Virtual Environment

Now that you’re in your virtual environment, you can install packages locally without affecting the broader system. For instance, let’s install a package named requests:

pip install requests==2.3.0

Now we can safely run our script in this isolated environment, no more conflict! We can upgrade the requests package and it won’t affect anything else: pip install requests==2.31.0

Step 4: Deactivating the Virtual Environment

When you are done working in the virtual environment, you can deactivate it:

deactivate

This puts you back to the system’s default Python interpreter with all its installed libraries.

Step 5: Removing the Virtual Environment

If you’re done with the virtual environment, you can just delete its directory. You probably never have to do this unless you need to reinstall everything from scratch.

rm -rf venv

Step 6: Sharing the Virtual Environment

To share your project along with its dependencies, it is common to create a requirements.txt file, which lists all of the packages in the current environment.

pip freeze > requirements.txt

This requirements.txt file can be committed to version control and shared. Other users can then install these dependencies using:

pip install -r requirements.txt

In conclusion

Python venv is a tool that helps to segregate Python environments for different projects, making dependency management easier, reliable and more predictable. It’s a must-have tool for every Python developer.

Work With Us Today

TopSquad offers a comprehensive technology services that caters to the specific needs of businesses. With our expertise in the tech industry and a deep understanding of the skills required for programming roles, we assist companies in sourcing and attracting top-notch programming talent. Our service encompasses everything from crafting compelling job descriptions to conducting rigorous screening processes.

By partnering with TopSquad, businesses can streamline their hiring process and gain access to the best programmers in the industry, ultimately bolstering their teams and driving success.