How to Identify the Python version in #! using environment variables

I have a problem which is caused by our encapsulated design. Up till now lots of our scripts were written in bash and as a result the #!/bin/bash was always simple.

However now that we are rewriting our scripts in python that is a bit more difficult. We deliver a specific version of python (to avoid version differences in client installed environments from breaking our implementation). Because the specific version of python lives in a installed directory structure I need to route to it.

However I don't think the #! statement can accept environment variables from the shell that executes the file(tried and got a bad interpreter).

eg:

in foo.py I have #!$dirloc/wherepythonlives/python

In the bash shell I executed the file and got bad interpreter. Is there a way of sneaking an environment variable into that #! line?

Or will I have to depend on an explicit path? We want to support multiple ver开发者_Python百科sions of our software (which may mean multiple python versions) on one environment so I was hoping to somehow keep Python's !# statement inside the directory level we install into.

---

A common way to do this is to use the env program:

#!/usr/bin/env python

This will cause env to look along the PATH environment for a binary called python.

---

I'm not aware of being able to use environment variable in the shebang. You can use relative paths though

#! ../../usr/bin/python

edit: You could always use env to specify to use a specific version. Then if that version can be found in $PATH it will be used otherwise the script will fail

#! /usr/bin/env python2.7

Or you could make the entry point a generic script instead.

eg

#! /usr/bin/env bash

if [[ $MYPYTHON ]]
then 
    $MYPYTHON main.py
else
    echo error message
fi

---

The optimal solution to this dilemma is using distutils (setup.py, which creates correct stubs for you automatically, for a number of given "console entry points") and virtualenv (handling the "isolated multiple installations" part).

---

I suppose it all depends on how and in what environment your scripts will be invoked. You could call you scripts using #!/usr/bin/env python, which would allow you to control which python is used by manipulating the environment's PATH.

You could always specify a wrapper script as the interpreter, which runs a python executable relative to the script's location:

foo.py:

#!/bin/pyselector

import sys
sys.exit(0)

pyselector:

#!/bin/sh
SCRIPT_PATH="$(readlink -f $1)"
SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"

"${SCRIPT_DIR}/my/local/python" "$@"