Coder Perfect

Should I use #! (shebang) in Python scripts, and if so, in what format?


Is it necessary to include the whole shebang in my Python scripts? What form will it take?

#!/usr/bin/env python 



Are these also transportable? Which one is the most popular?

The shebang is used in the tornado project. The Django project, on the other hand, does not.

Asked by treecoder

Solution #1

cript’s ability to run as a standalone executable without first running python in a terminal or double-clicking it in a file manager (when configured properly). It’s not required, but it’s usually included so that when someone sees the file open in an editor, they know what they’re looking at. The shebang line you use, on the other hand, is crucial.

Python 3 scripts should be used as follows: (defaults to version 3.latest)

#!/usr/bin/env python3

Python 2 scripts should be used as follows: (defaults to version 2.latest)

#!/usr/bin/env python2

Except in the rare scenario of writing code that is compatible with both Python 2.x and 3.x, the following should not be used:

#!/usr/bin/env python

The reason for these recommendations, given in PEP 394, is that python can refer either to python2 or python3 on different systems. On most distributions, it currently corresponds to python2, but this is expected to change in the future.

Also, DO NOT Use:


—”#!/usr/bin/env python” as opposed to “#!/usr/local/bin/python”

Answered by GlassGhost

Solution #2

It’s all a matter of personal preference. If you include the shebang, folks will be able to run the script directly (if it’s designated as executable); if you don’t, python will have to be run manually.

The program’s eventual outcome is unaffected in either case; it’s merely a question of means.

Answered by Amber

Solution #3

In a Python script, add a shebang to indicate:

If you’re manually writing a shebang, always use #!/usr/bin/env python unless you have a good reason not to. Even Windows understands this form (Python launcher).

Installed scripts must utilize a specified Python executable, such as /usr/bin/python or /home/me/.virtualenvs/project/bin/python. When you activate a virtualenv in your shell, it’s horrible if some tool breaks. In most circumstances, setuptools or your distribution package tools construct the necessary shebang automatically (on Windows, setuptools can generate wrapper .exe scripts automatically).

In other words, you’ll probably see #!/usr/bin/env python if the script is in a source checkout. The shebang is a path to a specific Python executable, such as #!/usr/local/bin/python, if it is installed (NOTE: you should not write the paths from the latter category manually).

To choose whether you should use python, python2, or python3 in the shebang, see PEP 394 – The “python” Command on Unix-Like Systems:

Answered by jfs

Solution #4

If you have many versions of Python and the script requires a specific version, the she-bang can ensure that the correct version is utilized when the script is run directly, for example:


The script can still be launched with a full Python command line or via import, in which case the she-bang is skipped. This is a good reason to utilize the she-bang for scripts that are run directly.

The best technique is #!/usr/bin/env python, however this helps in rare instances.

It is usually preferable to create a Python virtual environment, in which case the generic #!/usr/bin/env python command will select the appropriate Python instance for the virtualenv.

Answered by Chris Johnson

Solution #5

If you want the script to be executable, you should include a shebang. You should also run the script through an installation program that alters the shebang to make it compatible with the target platform. Distutils and Distribute are two examples of this.

Answered by Lennart Regebro

Post is based on