Python is a popular programming language that is used by many developers to build a wide range of applications. However, installing external dependencies and different packages on your system Python can be a real headache.
Fortunately, Python provides an efficient way to avoid these issues, and it’s called virtual environments. Virtual environments are isolated environments where you can install and run different packages and versions of Python without affecting your system Python or other virtual environments that you might have.
This article explores the different aspects of working with Python virtual environments and the reasons why they are such an essential tool for developers.
Creating and Activating a Virtual Environment
To create a virtual environment, we use the venv module that comes pre-installed with Python 3. Creating a virtual environment is very simple; we just need to run the command ‘python3 -m venv
This command will create a new directory with the given name, which will contain the virtual environment. Once you’ve created your virtual environment, it’s time to activate it.
To activate the virtual environment, navigate to the virtual environment’s directory and run the command ‘source bin/activate’. This command will activate the virtual environment and make it your current working environment.
Installing Packages into a Virtual Environment
Now that we have our virtual environment set up and activated, we can start installing packages into it. To install packages, we use the pip command, which is the package installer for Python.
To install a package, we use the command ‘pip install
Deactivating a Virtual Environment
Once you’ve finished working in your virtual environment, it’s important to deactivate it to return to your system Python environment. To deactivate the virtual environment, simply run the command ‘deactivate’.
Why Virtual Environments are Needed
Avoiding System Pollution
One of the main advantages of using virtual environments is that they avoid polluting your system Python environment. When packages and dependencies are installed into your system Python environment, they can conflict with other packages and dependencies required by other applications or Python scripts.
This can cause confusion, errors, and other issues that can be difficult to diagnose. Virtual environments help solve this problem by providing a clean, isolated environment that is entirely separate from your system Python environment.
Sidestepping Dependency Conflicts
Another advantage of virtual environments is that they allow you to sidestep dependency conflicts by installing different versions of packages and dependencies within different virtual environments. Sometimes, different packages require different versions of dependencies that may conflict with other packages that you have installed.
With virtual environments, you can install different versions of packages and dependencies without worrying about conflicts.
Minimizing Reproducibility Issues
Virtual environments can also help minimize reproducbility issues. When you’re developing an application, your code may depend on external libraries and packages that evolve over time.
If your code depends on a specific version of a package, you’ll want to ensure that you can reproduce your development environment precisely. Virtual environments can help enforce this consistency by pinning dependencies to specific versions.
Dodging Installation Privilege Lockouts
Lastly, another key advantage of virtual environments is that they can help you avoid installation privilege lockouts. When working on shared machines, you may not always have admin privileges to install packages globally.
Virtual environments allow you to install packages without the need for admin rights. This means you can work on shared machines without running into permission issues.
In this article, we’ve explored what virtual environments are, their advantages, and how to use them effectively. Virtual environments provide an excellent way to isolate your development environments, keep dependencies consistent, and avoid conflicts and pollution in your system Python environment.
By using virtual environments effectively, you can create better, more stable code, and work more efficiently as a Python developer. Python virtual environments are an essential tool for developers to create a self-contained environment in which to install and run different packages and versions of Python without affecting their system Python or other virtual environments that they might have.
In this article, we’ll dive deeper into the anatomy of a Python virtual environment and how they work under the hood.
The folder structure of a Python virtual environment is essential to understand. When creating a virtual environment using the venv module, it will create a new folder with the name you have given it.
Inside this folder there are several key subfolders. The ‘bin’ folder, for example, contains the Python executable files specific to this virtual environment.
The ‘include’ and ‘lib’ folders contain the libraries and header files needed to run Python applications. Finally, the ‘site-packages’ folder includes all the dependencies installed in the virtual environment.
Isolated Python Installation
The virtual environment has its own Python executable files, which makes it a completely separate installation from the system Python installation. This allows developers to install and configure the environment only with the packages and dependencies required for their specific project or task.
The isolation of the Python installation is important because it allows the virtual environment to be self-contained, and its use does not disrupt other Python applications on the host machine.
Copying Structure and Files
When you create a virtual environment, Python copies the standard folders from your global Python installation. This process creates an exact copy of your Python installation without requiring any modifications.
This isolation type gives you all libraries and tools you need in your development environment without risking the installation of new conflicting versions over your existing standard Python installation.
Adapting the Prefix-Finding Process
Python uses a process to determine the root of the Python installations called “sys.prefix.” By default, this system call returns the path to the global Python installation on your system. With virtual environments, sys.prefix refers to the root directory of the virtual environment.
Because there is a new prefix for each virtual environment, all dependencies and folders have no ambiguity when you want to run, install, or modify your Python environment.
Linking Back to Your Standard Library
Python virtual environments are, in some ways, a scaled-down version of your global Python installation. In order to maintain compatibility with the packages in that installation, the virtual environment has a reference to your Python’s standard library, which Python refers to as “sys.base_prefix.” This reference allows you to use your global Python installation as a backup if you don’t have a package installed within your virtual environment.
Modifying Your PYTHONPATH
Python virtual environments can manipulate the PYTHONPATH environment variable to ensure that the Python interpreter looks for libraries and modules installed within the virtual environment before checking the system’s default Python installation or other virtual environments. This manipulation ensures that you have control over which version of a dependent library you are using and that you have them available wherever you need them.
Changing Your Shell PATH Variable on Activation
Activating a virtual environment is a simple process with just one command. However, that command does a lot more than you might think.
It should trigger your virtual environment to use its executable files rather than those installed globally. This change of command is achieved with a group of activation scripts that run automatically when you activate a virtual environment.
One of the things that these scripts adjust is your shell PATH variable, prioritizing the virtual environment over other installed Python installations.
Running from Anywhere with Absolute Paths
Virtual environments are portable, which means you can move them to another machine without breaking their operation. This portability comes with a limitation for users who want to use a virtual environment created on a separate machine.
To make it possible, developers need to use absolute paths instead of relative ones when referring to a Python file. An absolute path points to a specific location within a file system despite what operating system is in place.
This functionality allows developers to transfer their virtual environments between different machines easily.
Python virtual environments are a powerful tool that allows developers to be productive and flexible by creating isolated and self-contained development environments. Understanding the different components of a virtual environment, the folder structure, changes to environment variables, and the script activation will allow developers to use Python virtual environments effectively.
Furthermore, users will also appreciate the portability of virtual environments, making it simple to develop code and test environments on new machines without the fear of conflicts or breaking current installations. Virtual environments are a crucial tool for any Python developer who wants to manage dependencies and control their Python environment.
However, Python virtual environments are not one-size-fits-all. There are many customizations and popular alternatives available to users, and this article will explore several of these customizations and alternatives in detail.
Changing the Command Prompt
When using virtual environments, you may want to include information about which environment you are currently working on in your command prompt. This information can be added using the prompt function.
Using this function, users can insert the virtual environment’s name and path as part of their command prompt. Creating a custom prompt is as easy as modifying the PS1 environment variable in Unix-based systems or PROMPT in Windows OS.
Overwriting Existing Environments
If you need to make changes to an existing virtual environment, you can either recreate the environment or delete and start again. Recreating keeps the folder structure but removes everything inside.
The process will keep you from having to recreate the environment from scratch. However, deleting the environment and creating a new one allows you to start fresh and remove any errors or problems from existing libraries that might be causing problems.
Creating Multiple Virtual Environments at Once
You can create multiple virtual environments at once using batch creation, a convenient method if you’re working on multiple projects that require isolated Python environments. Batch creation can be done manually by executing the ‘python3 -m venv’ command with a different name each time.
Additionally, virtual environment creation packages such as PyVirtualDisplay and virtualenvwrapper can manage creation and deletion of virtual environments, so developers can work on their projects without stress.
Updating the Core Dependencies
There are several core dependencies with Python, including pip and setuptools. Keep updated on the latest releases, bug fixes, and security patches by running the command ‘pip install –upgrade pip setuptools’ on any Virtual Environments that rely on pip to automatically download the latest versions of Python packages.
Avoiding Installing pip
When creating a virtual environment, the default configuration includes pip as the package manager tool. However, certain situations may require a virtual environment without pip or the ability to install packages.
In this case, you can employ the bootstrap method by using the –no-pip flag in the ‘python3 -m venv’ command. This configuration is useful for scenarios where no package installations are needed at all and only a Python environment is required.
Including the System Site-Packages
By default, a virtual environment does not inherit any globally installed site-packages included in the system’s site-packages by default. However, sometimes, developers may prefer to include system site-packages in a virtual environment.
This option may be helpful if a virtual environment needs to access an installed package from the global site-packages, which is missing in its environment. This configuration is possible by using the flag –system-site-packages with the ‘python3 -m venv’ command.
Copying or Linking Your Executables
When creating a new virtual environment, the default behavior is to include new binaries that serve as shortcuts to the virtual environment’s python executable. However, sometimes a user may prefer shared executables or identical python path across all their projects.
In this scenario, linking or copying a Python environment’s executable files to another one rather than creating new binaries is a better approach.
Upgrading Your Python to Match the System Python
Python versions continue to develop, moving away from outdated methodologies and coming up with new and improved features. If you want your Python virtual environment to be compatible with your System Python, ensure to upgrade the environment to match the Python on your machine.
To upgrade, type the command “python –version” to get your Python version number. Compare this number to the latest Python version, and if they differ, upgrade while maintaining the relevant version.
Other Popular Options for Virtual Environments
The Virtualenv Project
Virtualenv is another popular alternative to Python’s built-in venv module. Developed by Ian Bicking, Virtualenv is designed to create isolated Python environments and does this job very well.
It is still a popular choice for developers because it has been around for more than a decade. The tool is a more versatile way of creating and managing virtual environments, allowing the user to pick versions of Python, pip, and setuptools as needed.
The Conda Package and Environment Manager
Conda is a powerful package and environment manager that is widely used in the field of data science. It can create and manage virtual environments for both Python and R.
It is built for scientific computing, providing access to a vast number of scientific libraries and packages. Conda eases the process of creating new environments, and developers can use a single command to create new environments and manage their packages.
Additionally, Conda provides package installation from different repositories like pypi which it combines with other packages from anaconda.org or Conda-forge.
Python virtual environments are incredibly versatile environment tools for developers to work in isolated Python environments. This article explored various customization options for virtual environments like updating core dependencies, changing command prompts, recreating, and batch creating virtual environments.
As well as this, the article highlighted popular alternatives to Python’s built-in venv module, such as Virtualenv and Conda, that better fit different use cases. Regardless of the choice made, employ best practices, keep track of the Python environment and its dependencies, to stay focused on developing high-quality code and delivering quality software products.
Python virtual environments offer an efficient way to manage dependencies and maintain a stable development environment that is separate from existing installations of Python. However, developers must be strategic in how they manage their virtual environments to avoid confusion, potential errors, and wasted effort.
In this article, we will explore different tactics for managing virtual environments effectively.
Deciding Where to Create Environment Folders
The first thing to consider when working with virtual environments is where to create the environment folders. A good practice is to put the environments in a central location, where all developers working on a project can easily find them.
You can also create a specific folder named ‘envs’ where all virtual environments will be created. Naming conventions will also prove helpful when managing multiple environments.
A standard naming convention for virtual environments includes the name of the project and version number.
Treating Them as Disposables
Virtual environments are created to make development easier and more efficient, and as such, they should be treated as disposable. It is essential to be comfortable with recreating virtual environments as part of your development and deployment process.
Maintaining virtual environments as disposable not only ensures that developers have clean environments in which to work but also helps keep any data from influencing further work.
Pinning Your Dependencies
Pinning is the process of fixing package versions in your virtual environment. This process helps ensure that your project uses the same package versions across all environments, such as production and development, so that your codebase is consistent.
One way to fix package versions is to use a requirements.txt file. This file typically includes a list of all package dependencies for your application and their versions.
Avoiding Virtual Environments in Production
It is not recommended to use virtual environments in a production environment. Virtual environments should be used exclusively for development and testing purposes and kept isolated from the production environment.
Virtual environments provide a stable environment for developers to work in, test code, and work with different versions of packages, but they do not offer the same level of stability required for a production environment.
Using Third-Party Tools
There are a handful of third-party tools available to help make managing virtual environments easier and more efficient. One of the most popular is Pyenv, which can manage multiple Python versions and virtual environments.