Adventures in Machine Learning

Mastering Python Errors: Handling Modules Versions and Virtual Environments

As a Python developer, you are bound to encounter various errors and issues while working with different modules and versions of the language. Two of the most common areas where developers get stuck include handling the “ModuleNotFoundError” error and working with multiple versions of Python.

In this article, we will explore these two critical areas, understand how they can cause problems, and provide practical solutions to help you overcome such errors. So, let’s get started.

Fixing the “ModuleNotFoundError” Error

The “ModuleNotFoundError” error is a common error that developers face while working with Python modules, especially those dealing with HTTP/HTTPS requests. Before we learn how to fix this issue, let’s have a quick look at how to reproduce it.

How to Reproduce the Error:

To reproduce the “ModuleNotFoundError” error, you need to follow these steps:

1. Import the “requests” module in your Python script.

2. Execute an HTTP/HTTPS request, using the “requests.get()” function.

3. Run the script.

If your Python environment does not have the “requests” module installed, you will encounter the “ModuleNotFoundError” error.

How to Fix this Error:

To fix the “ModuleNotFoundError” error, you can use the following steps:


Open your command prompt or terminal, depending on your operating system. 2.

Use the “pip install” command to install the “requests” module.


Make sure that you have the correct version of Python selected in your environment. 4.

You can install the correct version of Python by using tools such as “pyenv” or “conda.”

5. Restart your IDE or text editor.

Other Common Causes for this Error:

There are other reasons why you might encounter the “ModuleNotFoundError” error. These include:


Working with multiple versions of Python. Each version of Python has its own modules, and if the version you are using doesn’t have the “requests” module, you’ll see this error.

2. Working within a virtual environment.

Virtual environments allow you to keep your project-specific dependencies separated from the global Python environment. However, if the “requests” module is not installed within your project’s virtual environment, you will see this error.

3. IDE configuration.

If your Python IDE is misconfigured, it might not recognize the installed modules, resulting in this error.

Handling Multiple Versions of Python

Another common issue that Python developers face is working with multiple versions of the language. If you’re not aware of how to manage different Python versions correctly, you may experience various problems while installing packages or running scripts.

We’re going to look at ways to manage the different versions of Python available.

Install Requests

If you need to install a package like “Requests,” you need to ensure that the right Python version is selected before proceeding. You can use a command like this to install Requests in a specific Python version:

pip3.9 install requests

Python Versions

The first step is to identify the different versions of Python installed on your system. On Unix-based systems such as macOS or Linux, you can use the “which” command to check the location of installed Python versions.

On Windows, you can check the installed versions by opening the command prompt and typing “python -V.”

/opt/homebrew/bin/python3 vs. /usr/bin/python3

After identifying the different versions of Python available, you can choose which version you want to use.

Suppose you want to use a different version of Python other than the one provided by your operating system. In that case, you can install another version of Python to a different location, such as /opt/homebrew/bin/python3.

You can then use this version of Python instead of the one provided by your operating system. Pip

Install Requests

Once you have identified the correct Python version to use, you can then install the necessary packages using a command like “

pip install requests”.

New Python Version

If you need to use a new version of Python or switch to a specific version, you can use:

1. Pyenv – This tool allows you to manage multiple Python versions, dependencies, and virtual environments efficiently.

You can use it to switch between Python versions, set the global Python version, or create virtual environments. 2.

Conda – This tool is geared towards scientific and data analysis workflows. It allows you to create and manage Python environments, install packages, and manage dependencies.


In this article, we have explored two critical areas that Python developers face when working with the language. We have learned how to fix the “ModuleNotFoundError” error and how to manage multiple versions of Python correctly.

By implementing the solutions provided, you can optimize your development workflow, make your work more efficient, and avoid unnecessary complications.

Handling Python Virtual Environments

Virtual environments are a crucial component of any Python project. They allow developers to work with different versions of Python and dependencies without interfering with the global system configurations.

While virtual environments are essential, they can cause issues such as requests installations conflicts.

The venv package is the recommended way to create and manage virtual environments in Python.

Here’s how to create a new environment and install dependencies using the venv package:

Creating a new virtual environment:

1. Open your terminal and navigate to your project directory.

2. Use the following command to create a new virtual environment:


python3 -m venv myenv


This command will create a new folder called “myenv,” which will contain the virtual environment’s files. 3.

Activate the virtual environment by running the following command:


source myenv/bin/activate


You should now see “(myenv)” at the beginning of your terminal prompt. 4.

Now that you’ve activated your virtual environment, you can install dependencies using pip. Installing Requests in a virtual environment:


With your virtual environment activated, run the following command to install the Requests library:


pip install requests


This command will install Requests within your virtual environment, making it available for your project. 2.

You can now use Requests within your Python project without conflicts with other libraries. Deactivating a virtual environment:

When you’re done working within a virtual environment, you can

deactivate it by running the following command:




This command will return you to your global Python environment.

IDE Using a Different Python Version

Sometimes, you may face a situation where your IDE uses a different version of Python than the one you want to use for your project. For example, if you have multiple versions of Python installed on your system, your IDE may use the wrong interpreter.

It’s crucial to use the correct Python version, especially when developing a project that requires specific dependencies or packages. Here’s how to ensure that your IDE uses the correct Python version.

Using the Correct Python Interpreter in VSCode:

1. Open VSCode and navigate to your project folder.

2. Click on “View” on the top menu and select “Command Palette.”


In the search bar, type “Python: Select Interpreter” and hit enter. 4.

A list of interpreters will appear. Select the interpreter with the version of Python that you want to use for your project.

Importing Requests:

After setting up your IDE to use the correct interpreter, you can now import and use Requests in your Python script.

Here’s how to do that:


import requests

response = requests.get(‘’)


This code imports the Requests library and uses it to make an HTTP GET request to Google’s homepage.


In conclusion, virtual environments and correct Python interpreter usage are essential for efficient and optimized development workflows. The venv package is an excellent way to create and manage virtual environments, while choosing the correct Python interpreter in your IDE enables you to work with the correct version of Python.

With this knowledge and implementation of the best practices, Python developers can work with better efficiency and avoid common errors in their projects. In conclusion, managing Python modules, versions, and virtual environments are crucial for a smooth and efficient development workflow.

From handling the “ModuleNotFoundError” error by installing the correct Python package, to managing multiple versions of Python using tools like pyenv and conda, to creating and managing virtual environments using the venv package, and to selecting the right Python interpreter in an IDE, each step plays a vital role in ensuring your project’s success. These best practices ensure that developers have a better understanding of their development environment, leading to fewer errors and improvements in code quality.

Keeping these practices in mind can enhance the development process and make Python programming an enjoyable experience.

Popular Posts