Test si exécutable existe en Python?

Meilleure façon que je peux penser:

def which(program):
    import os
    def is_exe(fpath):
        return os.path.isfile(fpath) and os.access(fpath, os.X_OK)

    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            if is_exe(exe_file):
                return exe_file

    return None

Modifier: mise à Jour de l'exemple de code pour inclure la logique de gestion des cas où l'argument fourni est déjà un chemin d'accès complet vers l'exécutable, c'est à dire "qui /bin/ls". Cela imite le comportement d'UNIX, 'qui' la commande.

Modifier: mis à Jour pour utiliser le système d'exploitation.chemin d'accès.isfile() à la place de l'os.chemin d'accès.exists() par des commentaires.

Modifier: path.strip('"') semble que la mauvaise chose à faire ici. Ni Windows ni POSIX semblent encourager la cité élément de CHEMIN d'accès.

Python 3.3 offre maintenant shutil.qui().

N'oubliez pas de préciser l'extension de fichier sous windows. Sinon, vous devez écrire un beaucoup plus compliqué is_exe pour windows à l'aide PATHEXT variable d'environnement. Vous pouvez utiliser FindPath.

Otoh, que, pourquoi êtes-vous encore la peine de rechercher l'exécutable? Le système d'exploitation va le faire pour vous dans le cadre de popen appel & va lever une exception si le fichier exécutable n'est pas trouvé. Tout ce que vous devez faire est d'attraper le bon d'exception pour les OS. Notez que sous Windows, subprocess.Popen(exe, shell=True) échoue silencieusement si exe n'est pas trouvé.

Intégrant PATHEXT dans le ci-dessus la mise en œuvre de which (dans Jay réponse):

def which(program):
    def is_exe(fpath):
        return os.path.exists(fpath) and os.access(fpath, os.X_OK) and os.path.isfile(fpath)

    def ext_candidates(fpath):
        yield fpath
        for ext in os.environ.get("PATHEXT", "").split(os.pathsep):
            yield fpath + ext

    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            for candidate in ext_candidates(exe_file):
                if is_exe(candidate):
                    return candidate

    return None

Voir os.chemin module pour certaines fonctions utiles sur les chemins. Pour vérifier si un fichier est exécutable, l'utilisation os.d'accès(path, mode), avec le système d'exploitation.X_OK mode.

os.X_OK

Valeur à inclure dans le paramètre de mode d'accès() pour déterminer si le chemin d'accès peut être exécutée.

EDIT: L'a suggéré which() implémentations sont le manque d'une idée - à l'aide de os.chemin d'accès.join() pour construire des noms de fichiers complets.

Je sais que je suis un peu d'un nécromancien ici, mais je suis tombé sur cette question et la solution retenue n'a pas fonctionné pour moi, pour tous les cas Pensé qu'il pourrait être utile de soumettre de toute façon. En particulier, le mode "exécutable" de la détection et de l'exigence de la fourniture de l'extension de fichier. En outre, les deux python3.3 shutil.which (utilise PATHEXT) et python2.4+'s distutils.spawn.find_executable (essaie juste l'ajout de '.exe') ne fonctionnent que dans un sous-ensemble de cas.

J'ai donc écrit un "super" version (basé sur la accepté de répondre, et le PATHEXT suggestion de Suraj). Cette version de which la tâche un peu plus en profondeur, et tente une série de "broadphase" en largeur d'abord des techniques, et essaye par la suite plus fine des recherches sur le PATH espace:

import os
import sys
import stat
import tempfile
def is_case_sensitive_filesystem():
tmphandle, tmppath = tempfile.mkstemp()
is_insensitive = os.path.exists(tmppath.upper())
os.close(tmphandle)
os.remove(tmppath)
return not is_insensitive
_IS_CASE_SENSITIVE_FILESYSTEM = is_case_sensitive_filesystem()
def which(program, case_sensitive=_IS_CASE_SENSITIVE_FILESYSTEM):
""" Simulates unix `which` command. Returns absolute path if program found """
def is_exe(fpath):
""" Return true if fpath is a file we have access to that is executable """
accessmode = os.F_OK | os.X_OK
if os.path.exists(fpath) and os.access(fpath, accessmode) and not os.path.isdir(fpath):
filemode = os.stat(fpath).st_mode
ret = bool(filemode & stat.S_IXUSR or filemode & stat.S_IXGRP or filemode & stat.S_IXOTH)
return ret
def list_file_exts(directory, search_filename=None, ignore_case=True):
""" Return list of (filename, extension) tuples which match the search_filename"""
if ignore_case:
search_filename = search_filename.lower()
for root, dirs, files in os.walk(path):
for f in files:
filename, extension = os.path.splitext(f)
if ignore_case:
filename = filename.lower()
if not search_filename or filename == search_filename:
yield (filename, extension)
break
fpath, fname = os.path.split(program)
# is a path: try direct program path
if fpath:
if is_exe(program):
return program
elif "win" in sys.platform:
# isnt a path: try fname in current directory on windows
if is_exe(fname):
return program
paths = [path.strip('"') for path in os.environ.get("PATH", "").split(os.pathsep)]
exe_exts = [ext for ext in os.environ.get("PATHEXT", "").split(os.pathsep)]
if not case_sensitive:
exe_exts = map(str.lower, exe_exts)
# try append program path per directory
for path in paths:
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
# try with known executable extensions per program path per directory
for path in paths:
filepath = os.path.join(path, program)
for extension in exe_exts:
exe_file = filepath+extension
if is_exe(exe_file):
return exe_file
# try search program name with "soft" extension search
if len(os.path.splitext(fname)[1]) == 0:
for path in paths:
file_exts = list_file_exts(path, fname, not case_sensitive)
for file_ext in file_exts:
filename = "".join(file_ext)
exe_file = os.path.join(path, filename)
if is_exe(exe_file):
return exe_file
return None

Utilisation ressemble à ceci:

>>> which.which("meld")
'C:\\Program Files (x86)\\Meld\\meld\\meld.exe'

La solution retenue n'a pas de travail pour moi dans cette affaire, puisqu'il y avait des fichiers comme meld.1, meld.ico, meld.doap, etc également dans le répertoire, dont ont été retournés à la place (sans doute depuis lexicographiquement premier) parce que l'exécutable test dans l'acceptation réponse est incomplète, et donner des faux positifs.

J'ai trouvé quelque chose dans StackOverflow qui a résolu le problème pour moi. Cela fonctionne à condition que l'exécutable a une option (comme --help ou --version) que les sorties de quelque chose et renvoie un code de sortie de zéro. Voir Supprimer la sortie en Python appels à des fichiers exécutables - le "résultat" à la fin de l'extrait de code dans cette réponse sera égal à zéro si l'exécutable est dans le chemin, sinon, il est plus susceptible d'être 1.

Une question importante est de "Pourquoi avez-vous besoin de tester si l'exécutable existent-ils?" Peut-être que vous ne le faites pas? 😉

Récemment, j'ai besoin de cette fonctionnalité pour lancer la visionneuse de fichier PNG. J'ai voulu effectuer une itération sur quelques modes de téléspectateurs et d'exécuter le premier qui existe. Heureusement, je suis tombé sur os.startfile. C'est beaucoup mieux! Simple, portable et utilise la par défaut viewer sur le système:

>>> os.startfile('yourfile.png')

Mise à jour: je me suis trompé sur os.startfile être portable... C'est Windows uniquement. Sur Mac, vous devez exécuter open de commande. Et xdg_open sur Unix. Il y a un Python problème sur l'ajout de Mac et Unix support pour os.startfile.

Ajouté le support de windows

def which(program):
path_ext = [""];
ext_list = None
if sys.platform == "win32":
ext_list = [ext.lower() for ext in os.environ["PATHEXT"].split(";")]
def is_exe(fpath):
exe = os.path.isfile(fpath) and os.access(fpath, os.X_OK)
# search for executable under windows
if not exe:
if ext_list:
for ext in ext_list:
exe_path = "%s%s" % (fpath,ext)
if os.path.isfile(exe_path) and os.access(exe_path, os.X_OK):
path_ext[0] = ext
return True
return False
return exe
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return "%s%s" % (program, path_ext[0])
else:
for path in os.environ["PATH"].split(os.pathsep):
path = path.strip('"')
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return "%s%s" % (exe_file, path_ext[0])
return None

Il semble que la évident choix est "qui", en analysant les résultats par popen, mais vous pouvez simuler en utilisant le système d'exploitation de classe. Dans pseudopython, il devrait ressembler à ceci:

for each element r in path:
for each file f in directory p:
if f is executable:
return True

Il y a un which.py script dans un standard de Python de distribution (par exemple, sur Windows '\PythonXX\Tools\Scripts\which.py').

EDIT: which.py dépend ls par conséquent, il n'est pas multi-plateforme.

À l'aide de l'python à la bibliothèque de tissu:

from fabric.api import *
def test_cli_exists():
"""
Make sure executable exists on the system path.
"""
with settings(warn_only=True):
which = local('which command', capture=True)
if not which:
print "command does not exist"
assert which