Since you have Linux, and if you want to simply type "python" instead of "python3" in order to run Python programs, a solution is simply to define an alias in you shell configuration file (.bashrc, etc.). For Bourne shells, it should be something like

alias python=python3

(or whatever your Python 3 name is).

This way, you do not have to change anything on your system, so this solution should quite innocuous and it should not break your system.

The site module documentation and Modifying Python's Search Path seem to be what you're looking for.

As far as I understand it, those entries are being added to sys.path by:

• /usr/lib/python2.6/site.py
• /usr/lib/python2.6/dist-packages/site.py
  (Change 2.6 to your version of Python.)

The easiest way to change it is to add a file /usr/local/lib/python2.6/dist-packages/site-packages.pth containing ../site-packages.

Alternatively, maybe you can teach the package to use site.getsitepackages()?

It's not good to change the default python. Many system programs depends on python2 not python3. if you want to use python3, you just type the command python3.

As long as a custom python3 is installed in /usr/local/bin/, it will show up as the default python3 executable. why? Because by default, /usr/local/bin/ is listed earlier in the search path then /usr/bin. This way, your custom executables have priority over these installed by the system.

To make the system find /usr/bin/python3 first, you must move out /usr/local/bin/python3. The alternative would be to ticker with your PATH, moving /usr/local/bin behind, but that would affect every other custom executable.

Thus, rename /usr/local/bin/python3 to /usr/local/bin/python3cust or something. Then, you will be using the default python version.

On Ubuntu, you actually may not change the default python version. Python is extensively used in the operating system. Changing the version will likely break things.

I'm assuming that when you installed anaconda 2, you manually set the PYTHONPATH environment variable, by putting something like

PYTHONPATH=/home/user/anaconda2/python
export PYTHONPATH

in your .bash_profile or .bash_rc.

But since you deleted the /home/user/anacanda2/ directory, that path no longer exists.

Thus you want to change PYTHONPATH to point to the executable in /usr/lib, by changing the above to

PYTHONPATH=/usr/lib/my_python_distribution
export PYTHON

Your PATH environment variable. It has a list of directories which bash searches (in the same order) when it's looking for an program to execute. Basically you want to put /usr/local/bin at the start of your PATH environment variable. Add the following to your ~/.bashrc file:

export PATH=/usr/local/bin:$PATH

You can have a look at the current setting by running the set command in bash.

Alternatively, you can simply rename /usr/bin/python to /usr/bin/python2.3 and create a symlink pointing to the new version, e.g.

ln -s /usr/local/bin/python /usr/bin/python

1. PYTHONPATH is an environment variable which you can set to add additional directories where python will look for modules and packages. e.g.:

   # make python look in the foo subdirectory of your home directory for   
   # modules and packages 
   export PYTHONPATH=${PYTHONPATH}:${HOME}/foo 
   

   Here I use the sh syntax. For other shells (e.g. csh,tcsh), the syntax would be slightly different. To make it permanent, set the variable in your shell's init file (usually ~/.bashrc).

2. Ubuntu comes with python already installed. There may be reasons for installing other (independent) python versions, but I've found that to be rarely necessary.

3. The folder where your modules live is dependent on PYTHONPATH and where the directories were set up when python was installed. For the most part, the installed stuff you shouldn't care about where it lives -- Python knows where it is and it can find the modules. Sort of like issuing the command ls -- where does ls live? /usr/bin? /bin? 99% of the time, you don't need to care -- Just use ls and be happy that it lives somewhere on your PATH so the shell can find it.

4. I'm not sure I understand the question. 3rd party modules usually come with install instructions. If you follow the instructions, python should be able to find the module and you shouldn't have to care about where it got installed.

5. Configure PYTHONPATH to include the directory where your module resides and python will be able to find your module.

Now my system is like this:

$ ls -la /usr/bin/python
lrwxrwxrwx. 1 root root 7 Oct  1  2012 /usr/bin/python -> python2
$ ls -la /usr/bin/python2
lrwxrwxrwx. 1 root root 9 Oct  1  2012 /usr/bin/python2 -> python2.7
$ ls -la /usr/bin/python2.7
-rwxr-xr-x. 1 root root 10768 Jul 24  2012 /usr/bin/python2.7

You want to do this I think:

sudo rm /usr/bin/python
sudo ln -s /usr/bin/python2.7 /usr/bin/python

So that /usr/bin/python -> /usr/bin/python2.7

But I can not use yum and update my system as Klaus Warzecha pointed out.

If what you want is to get a specific version of the Python interpreter when you type python in your shell, there is no environment variable that can help you in that sense. It is the shell that decides the binary of the interpreter to use, and by the time it is spawned it cannot be swapped to a different one. Some ways that you can work around this:

• As you said, making a symlink somewhere. It does not need to be in a system directory, many users have something like $HOME/bin in their $PATH (some Linux distributions do this by default).
• Make an alias (e.g. in your .bashrc or similar).
• Make a function (same as previous). You could even program it to receive some argument that decides which version of the interpreter you want to use, or to use the value of some environment variable, as you suggested.
• In distributions supporting it, set up an alternative.
• Make a virtual environment using the interpreter that you want and work within that environment.

In any case, there are a few things you should take into account:

• As mentioned in another answer, changing the version of the Python interpreter system-wide may break things. Particularly, switching the command python from Python 2 to Python 3 (or the other way around) is almost guaranteed to cause quite a lot of trouble. Some of the solutions above may be unaffected by this (e.g. setting and alias or function in .bashrc should not affect other scripts, unless sourced), but you should be careful about it.
• A common pitfall here is that changing the python command does not change every Python-based command. For example, if you use IPython and just type ipython you need to make sure that the correct interpreter and script are launched. Depending on your context there may be a few tools that you may need to consider in that sense.

A virtual environment is probably the easiest and cleanest solution, since it was designed for that particular problem (even though issues still arise sometimes, e.g. if you run ipython but you forgot to install it in your environment first you will get the system-wide one, obviously), although if you want to use it for every shell session then it may not be as convenient.

The comments somewhat cover the answer to the question, but to clarify:

When you installed Anaconda you must have agreed to have it added to your PATH. You'll want to check in your ~/.bash* files and look for any export PATH= lines to check this. So Anaconda is always on your path. The source deactivate command will only deactivate "sub" Conda environments. It will never remove what is called the "root" Conda environment (the one you originally installed). If you don't want Anaconda on your PATH by default then remove it from your ~/.bash* startup files. Then when you want to use Anaconda you'll need to add it to your PATH. Or just add the specific Conda environment you are interested in to your PATH directly, and don't worry about the activate and deactivate scripts. At their core all they do is modify PATH.

I hope that helps clarify things.