How to find the python command in a shell script?

If switching to zsh is an option

#! /bin/zsh -
die() { print -ru2 -- "$@"; exit 1; }
python_cmd=( ${(MOnk)commands:#python(|<2-3>(|.<->))} )
(( $#python_cmd )) || die No python
hash python=$commands[$python_cmd[1]]

python -c 'print("Hello world!")'

In zsh, $commands is a special associative array that maps commands (those found in $path) to their path (an interface to the command hash table as managed by the standard hash builtin utility).

• ${(k)commands} expands to the keys of that associative array.
• With ${(M)array:#pattern}, that's restricted to the ones that Match the pattern (here python optionally followed by 2 or 3 and optional .subversion).
• With n and O that's Ordered numerically in reverse so newer versions are preferred.

You can change the last line to exec python "$@" to make that script a python wrapper that runs the latest python 2 or 3 with the supplied arguments (and python as argv[0]), though beware that not all systems support using scripts as she-bang so using #! /path/to/that/script may not work on all.

Here's a variant for bash

python=$(
    cmd=python
    readarray -t dirs < <(tr : $'\n' <<<"$PATH")
    for dir in "${dirs[@]}"
    do
        for file in "$dir/$cmd"*
        do
            [ -x "$file" ] && echo "${file##*/}"
        done
    done |
        grep -E "^$cmd[0-9.-]*$" |
        sort -Vr |
        head -n1
)

"$python" ...

BASH Solution

In bash there's a compgen builtin that is able to "complete" a command (i.e. its trailing part). Its output is a LF-delimited list of the possible completions, and its return status is falsey when no match is found.

Here's an example of how you could use it to pick up the first available "python" command:

_{edit: I added the grep filtering as mentioned in @StéphaneChazelas comment below.}

#!/bin/bash

if IFS= read -r python_exe
then
    "$python_exe" -c 'print("Hello world!")'
else
    echo 'python interpreter not found' >&2
    exit 1
fi < <(
    compgen -c 'python' |
    grep -xE 'python([23](\.[0123456789]+)?)?'
)

POSIX Solution

In a standard shell it's possible to write a function that mimics compgen -c (at least for the commands that are in the PATH) and then use it to get the "python" executable name:

#!/bin/sh

compcmd() (
    case $1 in

    ( */* ) for f in "$1"*; do
                [ -f "$f" ] && [ -x "$f" ] && printf '%s\n' "$f";
            done ;;

    (  *  ) p=$PATH
            while [ -n "$p" ]; do
                d=${p%%:*} p=${p#"$d"} p=${p#:}
                [ -d "$d" ] || continue
                for f in "${d%/}/$1"*; do
                    [ -f "$f" ] && [ -x "$f" ] && printf '%s\n' "${f##*/}";
                done
            done ;;
    esac
)

python_exe=$(
    compcmd 'python' |
    grep -xE 'python([23](\.[0123456789]+)?)?' |
    head -n 1
)

[ -n "$python_exe" ] || {
    echo 'python interpreter not found' >&2
    exit 1
}

"$python_exe" -c 'print("Hello world!")'