#!/bin/sh vs #!/usr/local/bin/python in executables

Question

In the pip program, the She-bang is

#!/usr/local/bin/python

if __name__ == "__main__":
    # Python program body

while in the Install Certificates.command that Python Launcher offers:

#!/bin/sh

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 << "EOF"

# python program body

EOF

Are there any differences between those two approaches? And is there any reason to prefer one to another?

It seems to me they are all the same, except for the second one has one more bash subroutine. Is this right?

Answer 1

In the general case, you simply want to specify the interpreter you actually want.

Outside of this, you sometimes see workarounds like this as portability hacks. On POSIX systems, /usr/bin/env covers the majority of scenarios quite nicely; but if you need portability to older or otherwise peculiar systems, falling back to the lowest common denominator and then working your way back up to a place where you can reliably run e.g. Python on a variety of systems may require all kinds of unobvious constructs. (The previous - upvoted! - answer by Dan D. is a good example.)

There are also cases where you want sh to set something up (fetch some environment variables which are specified in a file which uses sh syntax, for example) and then hand over execution to Python;

#!/bin/sh
# source some variables
. /etc/defaults/myenv.sh
# Then run Python
exec env python -c '
# ... Your Python script here
    ' "$@"

Answer 2

There is a line length limit on the #! line. Perhaps they did that to get around that.

The options are the path to the program but only if it is short enough. Use of env python which uses the path. Or chain loading like this.

Answer 3

This specific code for the Install Certificates.command script was introduced in Python Issue #17128. As far as I can tell, the author hasn't explained why he wrote the code this way.

Note that .command files are Shell scripts on Mac OS X that can be executed by double-clicking on them in Finder.

I believe the likely explanation is that the author simply wanted to honour Mac OS X's expectation that .command files should be Shell scripts.

You could test this by placing the following content in a file ~/Desktop/test.command:

#!/usr/bin/env python
print "Hello world"

Then view the Desktop folder in Finder, and note that it is reported as a "shell" file:

(Although it is reported incorrectly as a Shell file, this Python script can still be executed by double-clicking on it. It doesn't break Finder or anything.)

To answer the specific question, one reason for preferring this pattern might be, as Dan D. said, to avoid a Shebang line limit.

In general, you would prefer to use #!/usr/bin/env python as your Shebang line. Creating a Bash Heredoc (i.e. the python3.6 << EOF pattern) would create all sorts of problems, such as your syntax highlighting won't work, you have to watch out for Bash variable interpolation inside the Heredoc, etc.