In this tutorial, you will learn the following:

• What a development environment is,
• What a virtual environment is,
• How to create a Python virtual environment, and
• How to install Django in your virtual environment.

To get the most out of this tutorial, you'll need to have a basic knowledge of using a terminal/command line and have the latest stable version of Python installed on your computer.

What is a Development Environment?

A development environment is an installation of Django on your local computer. Setting up your environment is an important step in your website’s development process. It provides an isolated and controlled space for you to write, test, and debug your code before deploying to a production environment.

What is a Virtual Environment?

A virtual environment is a space that allows you to isolate the dependencies and configurations of one project from another. This way, you can create different projects with different versions of libraries, and they won’t interfere with each other.

Note that there are various types of virtual environments, but in this tutorial we'll focus on creating a Python environment.

How to Create a Python Virtual Environment

In Python, there are several tools available for creating and managing virtual environments. Here are two commonly used ones:

The venv tool:

venv is an in-built module that comes with Python versions 3.3 and later. It's a simple and lightweight way to create a virtual environment.

Here's how to create a virtual environment using venv:

python -m venv myenv

myenv is the name of your virtual environment. You can use any other name, but always use lowercase letters and add no spaces.

Also, keep the name short so it is easy to remember. Dashes are allowed and commonly used. For example, my-env instead of myenv.

The virtualenv tool:

virtualenv is a third-party tool for creating a virtual environment. Its features allow you to create an environment with a different version of Python than the one used to execute the virtualenv command.

Here's how to create a virtual environment using virtualenv:

# For macOS and Linux
pip install virtualenv
virtualenv myenv

# For windows
pip install virtualenv
python -m virtualenv myenv

pip install virtualenv is a command that uses the Python package manager pip to install virtualenv globally in your computer. After installation, virtualenv myenv creates a new virtual environment named myenv.

Just like when using the venv tool, you can change the name of the environment. But always remember to keep them short, use lowercase letters, and add no spaces. You can use dashes, too.

Django Installation

Django provides you with a set of Python scripts for creating and working with Django projects. It is very flexible in terms of where and how you can install it. But for this tutorial, you will be installing Django in the virtual environment you just created.

Here's how you can install Django in your virtual environment, for Linux and macOS:

# Activate your virtual environment
source myenv/bin/activate

# Install Django
pip install django

# Or use this to specify the version
pip install django==4.2.7

For Windows:

# Activate your virtual environment
myenv\Scripts\activate

# Install Django
pip install django

# Or use this to specify the version
pip install django==4.2.7

pip is a package installer for Python that is recommended for installing Django. The command pip install django downloads the latest version of Django and installs it in your Python environment.

After working on your project, you can deactivate your virtual environment by typing the following command into your terminal or command line:

deactivate

How to verify your Django installation

After installation, you should verify that Django is correctly installed in your virtual environment. Always ensure to activate your virtual environment before verifying your installation.

Verify your Django installation with the following command:

python -m django --version

The above command will display the Django version installed in your virtual environment.

Congratulations! Your Django development environment is now active on your computer.

Conclusion

Django facilitates the development of web applications by providing a solid foundation, reducing repetition, and promoting best practices.

Installing Django is the first step in creating an environment for your web projects. After this process, you can now set up your Django project, define its structure, configure your databases, create your applications, and start building your web application. Happy Coding.

When developing software with Python, a basic approach is to install Python on your machine, install all your required libraries via the terminal, write all your code in a single .py file or notebook, and run your Python program in the terminal.

This is a common approach for a lot of beginners and many people transitioning from working with Python for data analytics.

This works fine for simple Python scripting projects. But in complex software development projects, like building a Python library, an API, or software development kit, often you will be working with multiple files, multiple packages, and dependencies. As a result, you will need to isolate your Python development environment for that particular project.

Consider this scenario: you are working on app A, using your system installed Python and you pip install packageX version 1.0 to your global Python library. Then you switch to project B on your local machine, and you install the same packageX but version 2.0, which has some breaking changes between version 1.0 and 2.0.

When you go back to run your app A, you get all sorts of errors, and your app does not run. This is a scenario you can run into when building software with Python. And to get around this, we can use virtual environments.

This tutorial will cover everything you need to know about virtual environments and how to set one up with Virtualenv.

What is a Virtual Environment?

Python's official documentation says:

"A virtual environment is a Python environment such that the Python interpreter, libraries and scripts installed into it are isolated from those installed in other virtual environments, and (by default) any libraries installed in a “system” Python, i.e., one which is installed as part of your operating system"

To break this down, when you activate a virtual environment for your project, your project becomes its own self contained application, independent of the system installed Python and its modules.

Your new virtual environment has its own pip to install libraries, its own libraries folder, where new libraries are added, and its own Python interpreter for the Python version you used to activate the environment.

With this new environment, your application becomes self-contained and you get some benefits such as:

• Your development environment is contained within your project, becomes isolated, and does not interfere with your system installed Python or other virtual environments
• You can create a new virtual environment for multiple Python versions
• You are able to download packages into your project without admin privileges
• You can easily package your application and share with other developers to replicate
• You can easily create a list of dependencies and sub dependencies in a file, for your project, which makes it easy for other developers to replicate and install all the dependencies used within your environment

Using virtual environments is recommended for software development projects that generally grow out of a single Python script, and Python provides multiple ways of creating and using a virtual environment.

In the sections below, we will walk through how to set up your virtual environment, using venv, which gives you a lot more low level control of your environment.

Another common way to set up your virtual environment is to use pipenv, which is a more high level approach.

How to Install a Virtual Environment using Venv

Virtualenv is a tool to set up your Python environments. Since Python 3.3, a subset of it has been integrated into the standard library under the venv module. You can install venv to your host Python by running this command in your terminal:

pip install virtualenv

To use venv in your project, in your terminal, create a new project folder, cd to the project folder in your terminal, and run the following command:

 python<version> -m venv <virtual-environment-name>

Like so:

 mkdir projectA
 cd projectA
 python3.8 -m venv env

When you check the new projectA folder, you will notice that a new folder called env has been created. env is the name of our virtual environment, but it can be named anything you want.

If we check the contents of env for a bit, on a Mac you will see a bin folder. You will also see scripts that are typically used to control your virtual environment, such as activate and pip to install libraries, and the Python interpreter for the Python version you installed, and so on. (This folder will be called Scripts on windows).

The lib folder will contain a list of libraries that you have installed. If you take a look at it, you will see a list of the libraries that come by default with the virtual environment.

How to Activate the Virtual Environment

Now that you have created the virtual environment, you will need to activate it before you can use it in your project. On a mac, to activate your virtual environment, run the code below:

source env/bin/activate

This will activate your virtual environment. Immediately, you will notice that your terminal path includes env, signifying an activated virtual environment.

Note that to activate your virtual environment on Widows, you will need to run the following code below (See this link to fully understand the differences between platforms):

 env/Scripts/activate.bat //In CMD
 env/Scripts/Activate.ps1 //In Powershel

Is the Virtual Environment Working?

We have activated our virtual environment, now how do we confirm that our project is in fact isolated from our host Python? We can do a couple of things.

First we check the list of packages installed in our virtual environment by running the code below in the activated virtual environment. You will notice only two packages – pip and setuptools, which are the base packages that come default with a new virtual environment

pip list

Next you can run the same code above in a new terminal in which you haven't activated the virtual environment. You will notice a lot more libraries in your host Python that you may have installed in the past. These libraries are not part of your Python virtual environment until you install them.

How to Install Libraries in a Virtual Environment

To install new libraries, you can easily just pip install the libraries. The virtual environment will make use of its own pip, so you don't need to use pip3.

After installing your required libraries, you can view all installed libraries by using pip list, or you can generate a text file listing all your project dependencies by running the code below:

pip freeze > requirements.txt

You can name this requirements.txt file whatever you want.

Requirements File

Why is a requirements file important to your project? Consider that you package your project in a zip file (without the env folder) and you share with your developer friend.

To recreate your development environment, your friend will just need to follow the above steps to activate a new virtual environment.

Instead of having to install each dependency one by one, they could just run the code below to install all your dependencies within their own copy of the project:

 ~ pip install -r requirements.txt

Note that it is generally not advisable to share your env folder, and it should be easily replicated in any new environment.

Typically your env directory will be included in a .gitignore file (when using version control platforms like GitHub) to ensure that the environment file is not pushed to the project repository.

How to Deactivate a Virtual Environment

To deactivate your virtual environment, simply run the following code in the terminal:

 ~ deactivate

Conclusion

Python virtual environments give you the ability to isolate your Python development projects from your system installed Python and other Python environments. This gives you full control of your project and makes it easily reproducible.

When developing applications that would generally grow out of a simple .py script or a Jupyter notebook, it's a good idea to use a virtual environment – and now you know how to set up and start using one.

When we start building a Python project that goes beyond simple scripts, we tend to start using third-party dependencies.

When working on a larger project, we need to think about managing these dependencies in an efficient manner. And when installing dependencies, we always want to be inside virtual environments. It helps keep things nice and clean. It also helps avoid messing up our Python environment.

Why do we need Python Virtual Environments?

We can use Pip to install packages to our Python project. And it is common to have multiple packages installed in a single Python project. This can lead to some issues regarding the versions of the packages installed and their dependencies.

When we use pip install <package name> in a project, we are installing the package and its dependencies in the global Python namespace. And this will install the package for the specific Python version that we have configured Python for.

We can find out where this directory is by using

python3.7 -c "import sys; print('\n'.join(sys.path))"

/usr/lib/python27.zip
/usr/lib/python2.7
/usr/lib/python2.7/lib-dynload
/usr/lib/python2.7/site-packages

And if we install the same package using pip3 install <package name>, it will be installed in a separate directory with the Python 3 version. We can overcome this by using the following command:

 python2.7 -m pip install <package name>

This still does not solve our problem of packages being installed system-wide, which can lead to the following problems:

• Different projects having different versions of the same package will conflict with one another
• A project’s dependencies can conflict with system-level dependencies which can break the system altogether
• Multi-user projects is not a possibility
• Testing code against different Python and library versions is a challenging task

To avoid those problems, Python developers use Virtual Environments. These virtual environments make use of isolated contexts (directories) for installing packages and dependencies.

How to Create a Virtual Environment

We need a tool to make use of Python virtual environments. The tool we use to make them is known as venv. It is built into the standard Python library for Python 3.3+.

If we were using Python 2, we would have had to install it manually. This is one of the few packages that we do want to install globally.

python2 -m pip install virtualenv

Note: We will talk more about venv in this post and Python 3 since there are a few differences between it and virtualenv. The commands are a bit different and the tools work differently under the hood.

We will start by making a new directory wherein we want to work with our project.

mkdir my-python-project && cd my-python-project

Then we will create a new virtual environment:

python3 -m venv virtualenv

# creates a virtual environment called virtualenv, the name can be anything we want

This will create a directory called virtualenv in the directory that we just created. The directory will contain a bin folder, a lib folder, an include folder, and an environment configuration file.

All these files ensure that all Python code gets executed within the context of the current environment. This helps us achieve isolation from global environments and avoids the problems we discussed earlier.

In order to start using this environment, we need to activate it. Doing so will also change our command prompt to the current context.

$ source env/bin/activate
(virtualenv) $

The prompt is also an indicator that the virtual environment is active and Python code executes under that environment.

Inside our environment, system-wide packages are not accessible and any packages installed inside the environment are not available outside.

Only pip and setuptools are installed by default in a virtual environment.

After activating an environment, the path variable gets modified to achieve the concept of virtual environments.

When we are done and want to switch to the global environment, we can exit using the deactivate command:

(virtualenv) $ deactivate 
$

How to Manage Dependencies Across Environments

Now that we have our virtual environments setup, we do not want to keep sharing the packages that can be installed using pip. We want to exclude our virtual environment folder, and be able to reproduce our work on a different system.

We can do this by making use of a requirements file in the root directory of our project.

Let us assume that we installed Flask in our virtual environment. After that, if we run pip freeze, it will list the packages that we have installed and their version numbers.

(virtualenv) $ pip freeze
Flask==1.1.2

We can write this to a requirements.txt file to upload to Git, or share with other people in any other form.

(virtualenv) $ pip freeze > requirements.txt

This command can be used to update the file too.

And then, whenever someone wants to run our project on their computer, all they need to do is:

$ cd copied-project/
$ python3 -m venv virtualenv/
$ python3 -m pip install -r requirements.txt

And everything will work as it was on our system.

Wrapping Up

Now we can manage Python virtual environments and thus manage dependencies and packages as needed. If you have any questions regarding this, feel free to get in touch.

_You can find other articles of mine _at__ https://www.wisdomgeek.com.

I recently got myself a “new” laptop – a Lenovo x270 (yay)! And once again I needed to set up a Python virtual environment. So of course I Googled for a solution, just to find my previously written article on the same topic!

So in this article, I'll update the instructions based on my newly acquired knowledge.

And let me tell you, it’s easier than before because we are going to do only two things:

• Install virtualenvwrapper
• Edit the .bashrc file

Prerequisites

In this article I will show you how to set up virtualenvwrapper with pip3 (pip for Python 3). We are not going to use Python 2 because it's no longer supported.

To complete this tutorial, you will need a computer with Ubuntu 20.04 installed and an internet connection. Also, some knowledge of the terminal and Vim editor would be useful.

Setting up a Virtual Environment

Now open your terminal in the home directory by right clicking and choosing the option “Open in Terminal”. You can also press the CTRL, ALT, and T keys on your keyboard at the same time to open the Terminal application automatically.

You first need to create a special directory that will hold all of your virtual environments. So go ahead and create a new hidden directory called virtualenv:

mkdir .virtualenv

pip3

Now you should install pip for Python3:

sudo apt install python3-pip

Confirm the pip3 installation:

pip3 -V

virtualenvwrapper

virtualenvwrapper is a set of extensions for virtualenv. It provides commands like mkvirtualenv, lssitepackages, and especially workon for switching between different virtualenv environments.

Install virtualenvwrapper via pip3:

pip3 install virtualenvwrapper

bashrc file

We are going to modify your .bashrc file by adding a row that will adjust every new virtual environment to use Python 3. We will point virtual environments to the directory we created above (.virtualenv) and we will also point to the locations of the virtualenv and virtualenvwrapper.

Now open the .bashrc file using the Vim editor:

vim .bashrc

If you still haven’t used Vim before or you don’t have it installed on your computer, you should install it now. It is one of the most widely used Linux editors and for good reason.

sudo apt install vim

After you've installed Vim open the .bashrc file by typing in the vim .bashrc command in your terminal. Navigate to the bottom of the .bashrc file, press the letter i to enter insert mode in Vim, and add these rows:

#Virtualenvwrapper settings:
export WORKON_HOME=$HOME/.virtualenvs
VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
. /usr/local/bin/virtualenvwrapper.sh

After you are done, press the esc key, then type :wq and press enter. This command will save the file and exit Vim.

Now you need to reload the bashrc script. There are two ways to do it – close and reopen your terminal, or execute this command in the terminal:

source ~/.bashrc

To create a virtual environment in Python3 and activate it immediately use this command in your terminal:

mkvirtualenv name_of_your_env

To deactivate the environment use the deactivate command.

To list all available virtual environments use the command workon or lsvirtualenv (lsvirtualenv will show the same result as workon but in a fancier way) in your terminal:

workon

lsvirtualenv

To activate one specific environment use workon + name of your environment:

workon name_of_your_env

There are several useful command you might need to use someday:

Rmvirtualenv will remove a specific virtual environment located in your .virtualenv directory.

rmvirtualenv name_of_your_env

Cpvirtualenv will copy the existing virtual environment to a new virtual environment and activate it.

cpvirtualenv old_virtual_env new_virtual_env

Well done! You have now created your first isolated Python 3 environment.

Thank you for reading!

Check out more articles like this on my freeCodeCamp profile, Medium profile, and other fun stuff I build on my GitHub page.

Let me tell you a story. Recently, I realized that I needed to review how to set up virtualenvwrapper on top of virtualenv in Ubuntu 18.04. I have completed this process several of times on different computers, and every time it seems to be just a little bit different than before.

I just got a new laptop and on the way home I read several tutorials on “How to set up virtualenvwrapper on Ubuntu 18.04”. And let me tell you – it seemed really easy because all of those tutorials were pretty straight forward and basically explained how to do these three 3 things:

• Install virtualenv
• Install virtualenvwrapper
• Edit .bashrc/.bash_profile or both

But even though I read all those tutorials none of them really worked for me.

I had several errors while trying to figure out what went wrong while following the tutorials.

First I got some of “mkvirtualenv: command not found”, then a little of “-bash: /usr/bin/virtualenvwrapper.sh: No such file or directory”, and then a touch of “ERROR: virtualenvwrapper could not find virtualenv in your path”.

After some research I realized that all virtualenvwrapper Ubuntu 18.04 tutorials are copies an old text written before April 2016 (the release date of Ubuntu 16.04).

I know this because from Ubuntu 16.04 and onward the location of vritualenvwrapper’s pip installation changed from /usr/local/bin/virtualenvwrapper.sh to ~/.local/bin/virtualenvwrapper.sh. Note that the local directory is hidden.

So I'll start by writing a tutorial that will show you how to avoid all those issues mentioned above.

Prerequisites

In this article I will show you how to set up virtualenvwrapper with pip3 (pip for Python 3). I chosen this version of pip instead of a Python 2 because Pythons 2's end of life was January 1. 2020.

Python 2 will retire in… https://pythonclock.org/

To complete this tutorial you will need a computer with Ubuntu 18.04 installed and an internet connection :). Also some knowledge about terminals and the Vim editor would be useful. I will assume you already updated and upgraded your system.

Setting up a Virtual Environment

Now open your terminal in the home directory by right clicking and choosing the option “Open in Terminal”. You can also press the CTRL, ALT, and T keys on your keyboard at the same time to open the Terminal application automatically.

You first need to create a special directory that will hold all of your virtual environments. So proceed with creating a new hidden directory called virtualenv.

mkdir .virtualenv

Now you should install pip for Python3.

sudo apt install python3-pip

Confirm the pip3 installation.

pip3 --version

Now install virtualenv via pip3.

pip3 install virtualenv

To find where your virtualenv was installed, type:

which virtualenv

Install virtualenvwrapper via pip3:

pip3 install virtualenvwrapper

We are going to modify your .bashrc file by adding a row that will adjust every new virtual environment to use Python 3. We will point virtual environments to the directory we created above (.virtualenv) and we will also point to the locations of the virtualenv and virtualenvwrapper.

Now open the .bashrc file using Vim editor.

vim .bashrc

If you still haven’t used the Vim editor or you don’t have it installed on your computer you should install it now. It is a widely used Linux editor, and for good reason.

sudo apt install vim

After you've installed Vim open the file .bashrc file by typing the vim .bashrc command in your terminal. Navigate to the bottom of the .bashrc file, press the letter i to enter the insert mode of Vim, and add these rows:

#Virtualenvwrapper settings:
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_VIRTUALENV=/home/goran/.local/bin/virtualenv
source ~/.local/bin/virtualenvwrapper.sh

After you are done, press the esc key. Then type :wq and press enter. This command will save and exit the Vim editor. Close and reopen your terminal when you’re done.

To create a virtual environment in Python3 and activate it immediately, use this command in your terminal:

mkvirtualenv name_of_your_env

You should confirm that this environment is set up for Python3:

Python -V

To deactivate the environment use the deactivate command.

deactivate

To list all available virtual environments use the command workon or lsvirtualenv (same result as workon but shown in a fancy way) in your terminal:

workon

lsvirtualenv

To activate one specific environment use workon + name of your environment:

workon name_of_your_env

There are several useful command you might need to use someday:

Rmvirtualenv will remove a specific virtual environment located in your .virtualenv directory.

rmvirtualenv name_of_your_env

Cpvirtualenv will copy the existing virtual environment to a new virtual environment and activate it.

cpvirtualenv old_virtual_env new_virtual_env

Well done! You have now created your first isolated Python 3 environment.

Thank you for reading! Check out more articles like this on my freeCodeCamp profile and other fun stuff I build on my GitHub page.

Imagine you have two applications, App1 and App2. Both use the package Pak, but require different versions. If you install Pak version 2.3 for App1, you would not be able to run App2 because it requires version 3.1.

This is where virtual environments come in handy.

Benefits:

• You can have multiple environments, with multiple sets of packages, without conflicts among them. This way, different projects’ requirements can be satisfied at the same time.
• You can easily release your project with its own dependent modules.

Here are two ways you can create Python virtual environments.

Virtualenv

[virtualenv](https://virtualenv.pypa.io/en/stable/) is a tool used to create isolated Python environments. It creates a folder which contains all the necessary executables to use the packages that a Python project would need.

You can install it with pip:

pip install virtualenv

Verify the installation with the following command:

virtualenv --version

Create an Environment

To create a virtual environment use:

virtualenv --no-site-packages my-env

This creates a folder in the current directory with the name of the environment (my-env/). This folder contains the directories for installing modules and Python executables.

You can also specify the Python version you want to work with. Just use the argument --python=/path/to/python/version. For instance, python2.7:

virtualenv --python=/usr/bin/python2.7 my-env

List Environments

You can list the available environments with:

lsvirtualenv

Activate an Environment

Before you can start using the environment you need to activate it:

source my-env/bin/activate

This ensures that only packages under my-env/ are used.

You will notice that the name of the environment is shown on the left of the prompt. This way you can see which is the active environment.

Install Packages

You can install packages one by one, or by setting a requirements.txt file for your project.

pip install some-package
pip install -r requirements.txt

If you want to create a requirements.txt file from the already installed packages, run the following command:

pip freeze > requirements.txt

The file will contain the list of all the packages installed in the current environment, and their respective versions. This will help you release your project with its own dependent modules.

Deactivate an Environment

If you are done working with the virtual environment you can deactivate it with:

deactivate

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

Delete an Environment

Simply delete the environment folder.

Conda

Conda is a package, dependency and environment management for many languages, including Python.

To install Conda, follow these instructions.

Create an Environment

To create a virtual environment use:

conda create --name my-env

Conda will create the corresponding folder inside the Conda installation directory.

You can also specify which version of Python you want to work with:

conda create --name my-env python=3.6

List Environments

You can list all the available environments with:

conda info --envs

Activate an Environment

Before you can start using the environment you need to activate it:

source activate my-env

Install Packages

The same as with virtualenv.

Deactivate an Environment

If you are done working with the virtual environment you can deactivate it with:

source deactivate

Remove an Environment

If you want to remove an environment from Conda use:

conda remove --name my-env

You are here because:

1. You are using Windows OS version 10+
2. You would like to use multiple Python versions on the same computer
3. You are tired of the internet telling you to “Just Use Virtualenv”

TL;DR

1. Open Command Prompt and enter pip install virtualenv
2. Download the desired python version (do NOT add to PATH!), and remember the path\to\new_python.exe of the newly installed version
3. To create a virtualenv, open Command Prompt and enter
   virtualenv \path\to\env -p path\to\new_python.exe
4. If you are using PyCharm, update the Project Interpreter and the Code compatibility inspection.
5. To install packages:
   (I) Activate virtualenv: open Command Prompt and enter path\to\env\Scripts\activate.bat
   (II) Install desired packages
   (III) Deactivate with deactivate .

The Long version; Do Read

Prologue

If you are using the Anaconda App this process might be easier using their GUI. I haven’t tried it myself, please let me know how it went if you are going down that road :)

1. Install virtualenv

If you already have some virtual environments, or are using Anaconda, make sure the next steps are performed from outside all these environments.

2. Install Python

You can download python from the official site, for example for python3.7.3 go here.

The file you should be downloading is called Windows x86–64 executable installer, or Windows x86 executable installer if for some reason you are using a 32-bit windows.

Once downloading is finished, open the executable file and an installation prompt will appear.

• You do NOT want to add the new python to your PATH since we are going to have multiple python versions on the same computer, and we would like for each application to know only one python version.
• Either use the default suggested location for the new python, or supply a location of your choice. Either way, remember this location and let’s denote it from now on with C:\<some_path>\Python37 .

3. Create a virtualenv

Open the Command Prompt, or if you are using Anaconda open the Anaconda Prompt .

Decide where you want your virtualenv to be, for example,
C:\Users\<your_username>\Anaconda3\envs\<env_name> .

Enter:

virtualenv C:\Users\<your_username>\Anaconda3\envs\<env_name> -p C:\<some_path>\Python37\python.exe

4. Update PyCharm Interpreter

If you are using PyCharm, open the project you would like to work on (that is/will be written with the new python version), and go to File -> Settings -> Project -> Project Interpreter press the gear icon and then Add.. .

This will open a prompt window that allows you to define a new interpreter:

Assuming you are using Code Inspections, you might need to tell PyCharm which python version to inspect for. Go to File -> Settings-> Editor -> Inspections -> Python -> Code compatibility Inspection , make sure the box on the top indicates the specific project you are working on, and tick the box of your python version.

If you don’t see your python version on the Options list, this might also be the time to update PyCharm… yup, happened to me too…

5. Install packages

Currently, your virtualenv contains only the crucial packages, pip and setuptools . To install more packages:

1. Open Command Prompt or Anaconda Prompt , and activate your virtualenv by entering
   C:\Users\<your_username>\Anaconda3\envs\<env_name>\activate.bat
2. Use pip to install packages like you usually do.
3. Deactivate your virtualenv by entering deactivate .

Epilogue

This morning, when I decided to open a new project with a different python version, I thought, “Yeah, I’ll just use a virtualenv”, because the internet said I can “Just do it”.

Well, it’s working now, so no hard feelings dear internet, but seriously, was the “Just” really justified? Does reinstalling-PyCharm-only-because-I-want-to-have-proper-code-inspections fall under the “Just” category??

Anyway, along the way I stumbled upon several helpful guides, but each one took me “just” one step of the way, so I decided to put it all in one place.

I hope my journey helped you with yours, and may we all enjoy happy coding, with as little as IT-friction as possible :D