We Keep Coding

Already have a python project can I set up a virtual environment?

I already started a python project and I found out about using virtual environments and how it is a good practice. I installed virtualenv and created a new environment. But, my existing project is still running on the default python i.e with global modules and everything. How do you get the project files to run on the virtual environment? I am using VS Code and python 3.10.1

you will have to activate the virtual env and then reinstall all the required packages in the virtual env

You can activate your virtual environment by saying;
source venv/bin/activate
then pip the required packages for your project
pip install package_name
You can see all the packages you have installed with pip freeze
To keep the modules and versions you have installed in a file called requirements.txt;
pip freeze > requirements.txt
You can now install these packages to the environment and project you want with a single command. pip install -r requirements.txt

I cant get studio code to install dotenv with pip install. Error cant find module, how do I fix it please?

PS C:\Users\gwill\OneDrive\Documents\new luno\Luno10> pip install dotenv
Fatal error in launcher: Unable to create process using '"C:\Users\gwill\AppData\Local\Programs\Python\Python310\python.exe" "C:\Users\gwill\AppData\Local\Programs\Python\Python310\Scripts\pip.exe" install dotenv': The system cannot find the file specified.

It should be pip install python-dotenv.

TL;DR;
In the project folder type this step by step depending on the platform (Linux/macOS or Windows):
Command-Line Linux/macOS
Command-Line Windows
Description
python3 -m venv .venv
python -m venv .venv
Creates the virtualenv (in this casethe .venv folder)
. ./.venv/bin/activate(bash/zsh). ./.venv/bin/activate.fish(fish shell)
.venv\Scripts\activate.bat(cmd.exe).venv\Scripts\Activate.ps1(Powershell)
Activates it
pip install dotenv
pip install dotenv
Installs a 3rd partypackage (in thiscase dotenv)
python script.py
python script.py
Runs the script(in this case script.py)
deactivate
deactivate
Deactivates it later
What is a Virtual Environment?
By default, Python installs 3rd-party packages on the System Site Directories. And in most cases, this even requires admin privileges like sudo (Linux/macOS) or Run as Administrator (Windows).
The System Site Directories is the default environment for the installed Python. It's global for all the projects being worked on on the same system.
So, installing the requirements/3rd-party packages from each project on the System Site Directories is going to pollute it. And worse, it could clash versions of the same module dependency between different projects. And could make projects completely unrunnable.
That's why Virtual Environments exist in the first place. The Virtual Environment is a completely separate Site Directories from the System Site Directories and is (should be) exclusive to the project being developed at the moment. The project itself is going to be totally isolated from other Virtual Environments. And even the Python binaries are going to be copied/sym-linked into the Virtual Environment.
Creating Virtual Environments
Adapted from the official documentation:
Since Python 3.3 it's possible to create a Virtual Environment with the standard venv module that comes preinstalled with Python already (Before, the standard way was to use the virtualenv package).
The creation of Virtual Environments is done by executing the command venv:
Linux/macOS
python3 -m venv .venv
Windows
python -m venv .venv
Running this command creates:
The target directory (.venv in this case);
The .venv/bin folder (or .venv\Scripts on Windows) containing a copy/sym-link of the Python binary/binaries;
The Virtual Site Directories (initially empty): .venv/lib/pythonX.Y/site-packages folder (on Windows, this is .venv\Lib\site-packages).
Activating a Virtual Environment
Once a virtual environment has been created, it can be “activated” using a script in the virtual environment’s binary directory. The invocation of the script is platform-specific:
Platform
Shell
Command to activate the Virtual Environment
POSIX
bash/zsh
source .venv/bin/activate
fish
source <venv>/bin/activate.fish
csh/tcsh
source <venv>/bin/activate.csh
PowerShell Core
.venv/bin/Activate.ps1
Windows
cmd.exe
.venv\Scripts\activate.bat
PowerShell
.venv\Scripts\Activate.ps1
As soon as the Virtual Environment is active, every install with pip is going to install on the Virtual Environment, safe from every other Virtual Environment.
Deactivate a Virtual Environment
You can deactivate a virtual environment by typing deactivate in your shell.

How to create a Python virtual environment independent of OS and Python version

I am trying to create a virtual environment to run a script which requires Python 3.6. I started off with Pipenv but I am unable to create the same environment on other platforms via the Pipfile.lock or requirements.txt unless the other platform(s) has Python 3.6 installed. I have read this post but I am unsure which direction I should take to create a virtual environment which can be shared and run its own version of Python independent of operating system and version of Python installed on the other platform.

Virtual environments are not portable, they depend on the Python installation you have.
You can't share/distribute virtual environment with others, because you can't control which version of Python others are using.
If you want to distribute your code along with all dependencies including the specific version of Python interpreter, you can use PyInstaller. It is far from perfect and little bit hacky. Also it generates a package which is specific to operating system.
https://pyinstaller.readthedocs.io/en/stable/operating-mode.html
There is also a detailed step-by-step guide on how to use PyInstaller.
https://realpython.com/pyinstaller-python/

This is step-by-step how I use Python virtual environment and share it with co-workers.
To check python and virtualenv presence, run following commands:
which python3
python3 -m pip list | grep env
which virtualenv
Install a python virtual environment builder:
python3 -m pip install virtualenv
Create a virtual environment named venv inside the project's directory: virtualenv venv
To activate this environment use this command inside project's directory: source venv/bin/activate
Install python modules dependencies listed in a requirements.txt:
python3 -m pip install -r requirements.txt
You should activate virtual environment when you working with python in this directory for package installation and for running commands in the project directory. When you need to deactivate the virtual environment do it using deactivate command.
To deactivate environment simply run: deactivate

What will happen to packages installed when the virtual environment is deleted?

I create a new project with the following commands:
mkdir ~/my_project
python -m venv ~/my_project
source ～/my_project/Scripts/activate
pip install flask
pip install kivy
pip install foo
pip install bar
And let's say that I decide to remove my_project and create a new project:
rm -rf ~/my_project
mkdir ~/new_project
python -m venv ~/new_project
source ~/Scripts/activate
Questions:
What happens to previously installed packages "flask", "kivy", "foo", and "bar"? Do I need to re-install them for my new_project's virtual environment?
If I don't need to re-install these packages, then I am missing the point of virtual environment? I thought the whole point of virtual environment is that packages installed in the virtual environment is isolated in that environment. Can someone elaborate?

Indeed, pip installs libraries into a subdirectory of the virtualenv when the env is active. Anything in there is independent of any system-wide installs, and vice versa. Removing the env obviously removes the stuff in the subdirectories.
On the other hand, virtualenv can optionally fall back to system-installed packages if you let it. The system-wide installs will obviously still be there after you remove the virtualenv.
As an aside, the current activate hard-codes some things so that you cannot even rename a virtualenv directory; you have to zap and reinstall it. Keeping all the things it needs in a requirements.txt or similar is a good way to simplify this process, as well as document the dependencies.

The point of Virtual Environment is to separate your development environment from your actual environment. Different projects have different package dependencies. So for these cases Virtual Environment comes in handy.
If you installed flask, kivy, foo, and bar inside a virtual environment, then YES, you need to install them when you move into another Virtual Environment (That's the whole purpose of Virtula Environment).
If you find that the packages are available globally then may be you are not using it correctly. You need to activate your Virtual Environment before you install anything or the packages will be installed globally.
For your case I can see you are activating before installing packages. So it should work right. you can always use pip freeze to see what packages are installed.

when I pip install, my packages are going in my macs local library

when I pip install a package it gets insalled on my macs library. I am using pycharm whih allows me to click on a package like a hyperlink. And instead of going to my site-packages in my virtualenv it's going to my macs library which is
/Library/Frameworks/Python.Framework/Versions/3.5/lib/python3.5/site-packages/gdata/youtube/
when it should be
myproject/lib/python3.5/site-packages/gdata/youtube/
why is that.

You should activate your virtual environment to install packages on that. In Pycharm you can do it like this:
Go to File > Settings > Project > Project Interpreter
Now you have to select the interpreter for this project. Browse or select the interpreter from drop-down if available. In your case this should be:
myproject/lib/python3.5
I am using Pycharm community edition on Ubuntu. But the
process should be similar in Mac.

I think you want to create a virtual environment for your project.
Install this tool virtualenv.
$ pip install virtualenv
Then create your project's folder
$ cd my_project_folder
$ virtualenv venv
This creates a copy of Python in whichever directory you ran the command in, placing it in a folder named venv.
Source
https://github.com/pypa/virtualenv
For further knowledge read
https://realpython.com/blog/python/python-virtual-environments-a-primer/

You should install your virtual environment and then run pip within that environment. So, for example, I use Anaconda (which I thoroughly recommend if you are installing alot of scientific libraries).
To activate the environment "hle" I type in:
source /Users/admin/.conda/envs/hle/bin/activate hle
Once I've done this the pip command will reference the virtual environment location and not the standard mac location. So, when I install "mypackage" as follows:
pip install mypackage
It subsequently installs files in the virtual folder and not in the usual mac system folders.
You can find out about the Anaconda virtual environment (and download it) over here: http://conda.pydata.org/docs/install/quick.html but other virtual environments (like Virtualenv) work in the same way.