Tester si l'exécutable existe en Python?

En Python, existe-t-il un moyen portable et simple de tester si un programme exécutable existe?

Par simple, je veux dire quelque chose comme la whichcommande qui serait tout simplement parfaite. Je ne veux pas rechercher manuellement PATH ou quelque chose impliquant d'essayer de l'exécuter avec Popen& al et voir s'il échoue (c'est ce que je fais maintenant, mais imaginez que c'est launchmissiles)

La façon la plus simple à laquelle 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

Edit : exemple de code mis à jour pour inclure la logique de gestion du cas où l'argument fourni est déjà un chemin complet vers l'exécutable, c'est-à-dire "which / bin / ls". Cela imite le comportement de la commande UNIX 'which'.

Edit : mis à jour pour utiliser os.path.isfile () au lieu de os.path.exists () par commentaires.

Edit : path.strip('"')semble être la mauvaise chose à faire ici. Ni Windows ni POSIX ne semblent encourager les éléments PATH cités.

Je sais que c'est une question ancienne, mais vous pouvez l'utiliser distutils.spawn.find_executable. Cela a été documenté depuis python 2.4 et existe depuis python 1.6.

import distutils.spawn
distutils.spawn.find_executable("notepad.exe")

En outre, Python 3.3 propose désormais shutil.which().

Python 3.3 propose désormais shutil.which () .

Pour python 3.2 et versions antérieures:

my_command = 'ls'
any(os.access(os.path.join(path, my_command), os.X_OK) for path in os.environ["PATH"].split(os.pathsep))

Ceci est une ligne de la réponse de Jay , également ici en tant que fonction lambda:

cmd_exists = lambda x: any(os.access(os.path.join(path, x), os.X_OK) for path in os.environ["PATH"].split(os.pathsep))
cmd_exists('ls')

Ou enfin, en retrait en fonction:

def cmd_exists(cmd):
    return any(
        os.access(os.path.join(path, cmd), os.X_OK) 
        for path in os.environ["PATH"].split(os.pathsep)
    )

Pour python 3.3 et versions ultérieures:

import shutil

command = 'ls'
shutil.which(command) is not None

En tant que doublure de Jan-Philip Gehrcke Answer :

cmd_exists = lambda x: shutil.which(x) is not None

En déf:

def cmd_exists(cmd):
    return shutil.which(cmd) is not None

N'oubliez pas de spécifier l'extension du fichier sur Windows. Sinon, vous devez écrire une variable beaucoup plus compliquée is_exepour Windows en utilisant PATHEXTla variable d'environnement. Vous voudrez peut-être simplement utiliser FindPath .

OTOH, pourquoi vous dérangez-vous même de rechercher l'exécutable? Le système d'exploitation le fera pour vous dans le cadre de l' popenappel et déclenchera une exception si l'exécutable n'est pas trouvé. Tout ce que vous devez faire est d'attraper l'exception correcte pour un système d'exploitation donné. Notez que sous Windows, subprocess.Popen(exe, shell=True)échouera silencieusement s'il exen'est pas trouvé.

Intégration PATHEXTdans la mise en œuvre ci-dessus de which(dans la réponse de Jay):

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

Pour les plates-formes * nix (Linux et OS X)

Cela semble fonctionner pour moi:

Édité pour travailler sur Linux, grâce à Mestreion

def cmd_exists(cmd):
    return subprocess.call("type " + cmd, shell=True, 
        stdout=subprocess.PIPE, stderr=subprocess.PIPE) == 0

Ce que nous faisons ici, c'est utiliser la commande intégrée typeet vérifier le code de sortie. S'il n'y a pas une telle commande, se typeterminera par 1 (ou un code d'état différent de zéro de toute façon).

Le bit sur stdout et stderr est juste pour faire taire la sortie de la typecommande, car nous ne sommes intéressés que par le code d'état de sortie.

Exemple d'utilisation:

>>> cmd_exists("jsmin")
True
>>> cmd_exists("cssmin")
False
>>> cmd_exists("ls")
True
>>> cmd_exists("dir")
False
>>> cmd_exists("node")
True
>>> cmd_exists("steam")
False

Voir le module os.path pour quelques fonctions utiles sur les noms de chemin. Pour vérifier si un fichier existant est exécutable, utilisez os.access (chemin, mode) , avec le mode os.X_OK.

os.X_OK

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

EDIT: Il which()manque un indice aux implémentations suggérées - utiliser os.path.join()pour construire des noms de fichiers complets.

Sur la base qu'il est plus facile de demander pardon que de permission, j'essayerais simplement de l'utiliser et de détecter l'erreur (OSError dans ce cas - j'ai vérifié que le fichier n'existe pas et que le fichier n'est pas exécutable et qu'ils donnent tous les deux OSError).

Cela aide si l'exécutable a quelque chose comme un --versionindicateur qui est un non-fonctionnement rapide.

import subprocess
myexec = "python2.8"
try:
    subprocess.call([myexec, '--version']
except OSError:
    print "%s not found on path" % myexec

Ce n'est pas une solution générale, mais ce sera le moyen le plus simple pour de nombreux cas d'utilisation - ceux où le code doit rechercher un seul exécutable bien connu.

Je sais que je suis un peu un nécromancien ici, mais je suis tombé sur cette question et la solution acceptée n'a pas fonctionné pour moi dans tous les cas J'ai pensé qu'il pourrait être utile de soumettre de toute façon. En particulier, la détection du mode "exécutable" et la nécessité de fournir l'extension de fichier. De plus, python3.3 shutil.which(utilise PATHEXT) et python2.4 + distutils.spawn.find_executable(essaie simplement d'ajouter '.exe') ne fonctionnent que dans un sous-ensemble de cas.

J'ai donc écrit une version "super" (basée sur la réponse acceptée et la PATHEXTsuggestion de Suraj). Cette version de whichfait la tâche un peu plus en profondeur, et essaie d'abord une série de techniques en largeur "première phase", puis essaie finalement des recherches plus fines sur l' PATHespace:

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

L'utilisation ressemble à ceci:

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

La solution acceptée n'a pas fonctionné pour moi dans ce cas, car il les fichiers étaient comme meld.1, meld.ico, meld.doap, etc également dans le répertoire, dont un a été renvoyé à la place (probablement depuis lexicographique en premier) parce que le test exécutable dans la réponse acceptée était incomplète et donner faux positifs.

Le meilleur exemple devrait être le module intégré python shutil.which () en Python 3. Le lien est https://hg.python.org/cpython/file/default/Lib/shutil.py

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

Cela semble assez simple et fonctionne à la fois en python 2 et 3

try: subprocess.check_output('which executable',shell=True)
except: sys.exit('ERROR: executable not found')

Une question importante est " Pourquoi avez-vous besoin de tester si un exécutable existe?" Peut-être pas? ;-)

Récemment, j'avais besoin de cette fonctionnalité pour lancer la visionneuse pour le fichier PNG. Je voulais répéter sur certains téléspectateurs prédéfinis et exécuter le premier qui existe. Heureusement, je suis tombé sur os.startfile. C'est beaucoup mieux! Simple, portable et utilise la visionneuse par défaut sur le système:

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

Mise à jour: j'avais tort d' os.startfileêtre portable ... C'est Windows uniquement. Sur Mac, vous devez exécuter la opencommande. Et xdg_opensur Unix. Il y a un problème Python sur l'ajout de la prise en charge Mac et Unix pour os.startfile.

Vous pouvez essayer la bibliothèque externe appelée "sh" ( http://amoffat.github.io/sh/ ).

import sh
print sh.which('ls')  # prints '/bin/ls' depending on your setup
print sh.which('xxx') # prints None

Ajout du support 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

vous pouvez savoir si un fichier existe avec le module os. un exécutable en particulier semble tout à fait impraticable étant donné que beaucoup de choses sont exécutables sur nix qui ne sont pas sur windows et vice versa.

Il semblerait que le choix évident soit "qui", en analysant les résultats via popen, mais vous pouvez le simuler autrement en utilisant la classe os. En pseudopython, cela ressemblerait à ceci:

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

Donc, fondamentalement, vous voulez trouver un fichier dans un système de fichiers monté (pas nécessairement dans les répertoires PATH uniquement) et vérifier s'il est exécutable. Cela se traduit par le plan suivant:

• énumérer tous les fichiers dans les systèmes de fichiers montés localement
• faire correspondre les résultats avec le modèle de nom
• pour chaque fichier trouvé, vérifiez s'il est exécutable

Je dirais que faire cela de manière portable nécessitera beaucoup de puissance de calcul et de temps. Est-ce vraiment ce dont vous avez besoin?

Il existe un script which.py dans une distribution Python standard (par exemple sous Windows '\PythonXX\Tools\Scripts\which.py').

EDIT: which.pydépend lsdonc il n'est pas multi-plateforme.

Aucun des exemples précédents ne fonctionne sur toutes les plateformes. Habituellement, ils ne fonctionnent pas sous Windows car vous pouvez exécuter sans l'extension de fichier et que vous pouvez enregistrer une nouvelle extension. Par exemple sous Windows, si python est bien installé, il suffit d'exécuter 'file.py' et cela fonctionnera.

La seule solution valide et portable que j'avais était d'exécuter la commande et de voir le code d'erreur. Tout exécutable décent devrait avoir un ensemble de paramètres d'appel qui ne feront rien.

Utilisation de la bibliothèque de tissus python:

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