We Keep Coding

Pip install a package in a way that it gets not listed in requirements.txt

Is it possible to install a pip package in a way so that it gets not listed when doing pip freeze > requirements.txt?
I am thinkging of an equivalent to: poetry add --dev which adds (installs) a package as a development dependency, but it does not appear in dependency list.
Is there a way in pip to do something similar?

What you want is pipenv.
There are ways of making RStudio work with pipenv (link to an article).
This allows both complete package control, python version specification for a project as well as virtualenv, all in one.
Otherwise, you'd have to maintain your requirements.txt file manually, and further down the line use a constraints.txt file, also.
Think of pipenv files as what yarn.lock files (JS) vs package.json file + some extra sweet features.
You can use pipenv to generate a requirements.txt file by doing:
pipenv lock -r > requirements.txt
While you can add/install packages in development mode by:
pipenv install --dev <mypackage>

How to separate packages for private use from relevant to the project in the same virtual environment?

Here's a typical workflow when working with virtual environments:
1) Create virtual envinronment:
python3 -m venv venv
2) Activate it:
source venv/bin/activate
3) Install needed requirements:
(venv): pip install ...
4) (Write the code of the Package)
5) Freeze the code/Create the Package dependencies.
At the last point selected python tool wraps up all the packages from my virtual environment installed at point 3).
And here's my problem. What if some requirements installed at point 3) are just private packages used only by me for development purposes? For example, in order to have Spyder editor working in different virtual environments I need to install spyder-kernels. They are not needed for my Package, and they are not needed for other developers if they don't use this editor. However, when I
(venv): pip freeze > requirements.txt
I get requirements.txt with spyder-kernels package included in it, and then
(venv2): pip install -r requirements.txt
installs all the packages from requirements.txt unless I manually delete unwanted lines.
Is there any flag for pip install that could tell pip to install some packages as hidden/private for freezing/packaging process? Or any other automatic workaround that could achieve my goal?
The perfect scenario would be something like this:
python3 -m venv venv
source venv/bin/activate
(venv): pip install important_packages
(venv): pip install -privateFLAG spyder-kernels
(venv): pip freeze > requirements.txt # (stores important_packages)
(venv): pip freeze -privateFLAG > private_requirements.txt
and then one can choose to recreate the environment depenedencies with:
'''pip install -r requirements.txt'''
or
'''pip install -r requirements.txt private_requirements.txt'''
if he needs whatever in private_requirements.txt is.
Can we do some similar trick for freezing code?

I'm not aware of such functionality in pip.
When you install a "private" package, you could add said package to a file, for example private_requirements.txt. Then with a simple shell script you could filter the output of pip freeze in a way that if a package appears in private_requirements.txt then the matching line should be removed from freeze output.
It should not be hard to implement, for example you could use:
pip freeze | grep -v -f private_requirements.txt > requirements.txt

You could experiment with one of the following tools, see if it fits your needs:
pipdeptree --freeze --packages MyProject > requirements.txt
pipreqs .
deptree MyProject > requirements.txt (Disclaimer: my code)
These should fill the requirements.txt with only the dependencies for that one project.

Do we need to upload virtual env on github too?

This is my GitHub repo
https://github.com/imsaiful/backmyitem
I push from my local machine and pull the changes in Amazon EC2.
Earlier I have not added the virtual env file in my repo but now I have changed some file in admin directory which is containing in the virtual env. So should I go for to add the virtual env too on my GitHub or instead I change the same thing on my remote server manually?

As was mentioned in a comment it is standard to do this through a requirements.txt file instead of including the virtualenv itself.
You can easily generate this file with the following:
pip freeze > requirements.txt
You can then install the virtualenv packages on the target machine with:
pip install -r requirements.txt
It is important to note that including the virtualenv will often not work at all as it may contain full paths for your local system. It is much better to use a requirements.txt file.

No - although the environment is 100% there, if someone else where to pull it down the path environment hasn't been exported not to mention Python version discrepancies will likely crop up.
The best thing to do is to create what is known as a requirements.txt file.
When you have created your environment, you can pip install this and pip install that. You'll start to built a number of project specific dependencies.
Once you start to build up a number of project dependencies I would then freeze your local python environment (analogoues to a package.json for node.js package dependency management). I would recommend doing the following in your terminal:
(local_python_environment) $ pip install django && pip freeze > requirements.txt
(local_python_environment) $ pip install requests && pip freeze > requirements.txt
That is to say, freeze your environment to a requirements.txt file every time a new dependency is installed.
Once a collaborator pulls down your project - they can then install a fresh python environment:
$ python3 -m venv local_python_environment
(* Please use Python 3 and not Python 2!)
And then activate that environment and install from your requirements.txt which you have included in your version control:
$ source local_python_environment/bin/activate
(local_python_environment) $ pip install -r requirements.txt
Excluding your virtual environment is probably analogous to ignoring node_modules! :)

No Its not necessary to upload virtualenv file on github. and even some time when you push your code to github then it ignore python file only if add into ignore.
Virtual Environment
Basically virtual environment is nothing but itis a tool that helps to keep dependencies required by different projects separate by creating isolated python virtual environments for them. This is one of the most important tools that most of the Python developers use. Apart from that you can add requirement.txt file into your project.
Requirement.txt
It is file that tells us to which library and application are need to run this application. you can add requirement.txt file with this simple command.
pip freeze > requirements.txt
After run this command all application and library add in this file. and if you make your project without activate any virtualenv then python automatically use system environment variable it will also add all the file that not necessary for your project.

You should add the virtualenv in your gitignore. Infact github has a recommended format for python, which files should be added and which shouldn't
Github recommendation for gitignore

Global installations - Flask & Python

How can I tell if flask or python are installed globally? Everytime I attempt to push a flask python app locally I need to copy the flask, jinja2, markupsafe,and werkzeug directories along with file itsdangerous.py
I have had a little experience with paths before, as such I did the echo $PATH command and received my path
/home/me/rampup/webapp/venv/bin:/usr/local/heroku/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
Should I append my $PATH with the path locations of python and flask? If so how would I identify the paths of those applications?

You probably don't want to manually copy your dependencies around. (It's tedious and error prone). Instead, install pip (to manage your dependencies) and virtualenv[1] (to allow you to work on multiple projects with conflicting dependencies). Then:
Create a virtual environment: virtualenv venv
Activate said virtual environment . venv/bin/activate
Use pip to install your dependencies pip install Flask
There is no step #4
For deployments, simply ask pip to produce a manifest of all the dependencies you have with the command pip freeze (you can redirect it to a requirements.txt file with the following command pip freeze > requirements.txt). Then you can install the same dependencies with pip install -r requirements.txt on the remote machine.
[1]: If you are on Python 3.4+ you already have both - although you'll use pyvenv-3.4 instead of virtualenv.

Python equivalent of npm or rubygems?

I've been looking around for a package manager that can be used with python. I want to list project dependencies in a file.
For example ruby uses Gemfile where you can use bundle install.
How can I achieve this in Python?

The pip tool is becoming the standard in equivalent of Ruby's gems.
Like distribute, pip uses the PyPI package repository (by default) for resolving and downloading dependencies.
pip can install dependencies from a file listing project dependencies (called requirements.txt by convention):
pip install -r requirements.txt
You can "freeze" the current packages on the Python path using pip as well:
pip freeze > requirements.txt
When used in combination with the virtualenv package, you can reliably create project Python environments with a project's required dependencies.

Pipenv
(I know it's an old question, and it already has an answer but for anyone coming here looking for a different answer like me.)
I've found a very good equivalent for npm, It's called pipenv. It handles both virtualenv and pip requirements at the same time so it's more like npm.
Simple Use Case
pip install pipenv
then you can make a new virtualenv with third version of python, as well as making a pipfile that will be filled with your projects requirement and other stuff:
pipenv install --three
using your created virtualenv:
pipenv shell
installing a new python package:
pipenv install requests
running your .py file is like:
pipenv run python somefile.py
you can find it's doc here.

Python uses pip for a package manager. The pip install command has a -r <file> option to install packages from the specified requirements file.
Install command:
pip install -r requirements.txt
Example requirements.txt contents:
Foo >= 1.2
PickyThing <1.6,>1.9,!=1.9.6,<2.0a0,==2.4c1
SomethingWhoseVersionIDontCareAbout
See the Requirements Parsing section of the docs for a full description of the format: https://pip.pypa.io/en/stable/user_guide/#requirements-files

This is how I restrict pip's scope to the current project. It feels like the opposite if you're coming from NodeJS's npm or PHP's composer where you explicitly specify global installations with -g or --global.
If you don't already have virtualenv installed, then install it globally with:
pip install virtualenv
Each Python project should have its own virtualenv installation. It's easy to set one up, just cd to your project's root and:
python3 -m virtualenv env # creates env folder with everything you need
Activate virtualenv:
source env/bin/activate
Now, any interaction with pip is contained within your project.
Run pip install package_name==version for each of your dependencies. They are installed in ./env/lib/python3.x/site-packages/
When you want to save your project's dependencies to a file, run:
pip freeze > requirements.txt
You actually don't need -l or --local if you're in an activated project-specific virtualenv (which you should be).
Now, when you want to install your dependencies from requirements.txt, set up your virtualenv, and run:
pip install -r requirements.txt
That's all.

This is an old question but things are constantly evolving.
Further to the other answer about pipenv. There is also a python package manger called poetry.
There is a detailed comparison between pipenv and poerty here: Feature comparison between npm, pip, pipenv and poetry package managers. It also links the features to common npm features.

Here is a comparison of pipenv vs poetry vs pdm: https://dev.to/frostming/a-review-pipenv-vs-poetry-vs-pdm-39b4
The conclusion is that pdm is the winner.
But in my experience, poetry is easier than pdm to integrate with IDEs.