Testar se existe executável em Python?

No Python, existe uma maneira portátil e simples de testar se existe um programa executável?

Por simples, quero dizer algo como o whichcomando que seria perfeito. Eu não quero procurar PATH manualmente ou algo que envolva tentar executá-lo com Popen& al e ver se ele falha (é o que estou fazendo agora, mas imagine que seja launchmissiles)

A maneira mais fácil de pensar:

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

Editar : amostra de código atualizada para incluir lógica para lidar com o caso em que o argumento fornecido já é um caminho completo para o executável, ou seja, "what / bin / ls". Isso imita o comportamento do comando UNIX 'what'.

Editar : atualizado para usar os.path.isfile () em vez de os.path.exists () por comentários.

Edit : path.strip('"')parece que a coisa errada a fazer aqui. Nem o Windows nem o POSIX parecem incentivar os itens PATH citados.

Eu sei que esta é uma pergunta antiga, mas você pode usar distutils.spawn.find_executable. Isso foi documentado desde o python 2.4 e existe desde o python 1.6.

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

Além disso, o Python 3.3 agora oferece shutil.which().

O Python 3.3 agora oferece shutil.which () .

Para python 3.2 e versões anteriores:

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

Esta é uma linha da resposta de Jay , também aqui como uma função 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, por último, recuado como uma função:

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)
    )

Para python 3.3 e posterior:

import shutil

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

Como uma linha de resposta de Jan-Philip Gehrcke :

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

Como um def:

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

Lembre-se de especificar a extensão do arquivo no Windows. Caso contrário, você precisará escrever um tópico muito complicado is_exepara o Windows usando PATHEXTa variável de ambiente. Você pode apenas querer usar o FindPath .

OTOH, por que você está se preocupando em procurar o executável? O sistema operacional fará isso por você como parte da popenchamada e gerará uma exceção se o executável não for encontrado. Tudo o que você precisa fazer é capturar a exceção correta para o SO fornecido. Observe que, no Windows, subprocess.Popen(exe, shell=True)falhará silenciosamente se exenão for encontrado.

Incorporando PATHEXTna implementação acima de which(na resposta 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

Para plataformas * nix (Linux e OS X)

Isso parece estar funcionando para mim:

Editado para funcionar no Linux, graças a Mestreion

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

O que estamos fazendo aqui é usar o comando embutido typee verificar o código de saída. Se não houver esse comando, typesairá com 1 (ou um código de status diferente de zero).

A parte sobre stdout e stderr é apenas para silenciar a saída do typecomando, pois estamos interessados ​​apenas no código de status de saída.

Exemplo de uso:

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

Veja o módulo os.path para algumas funções úteis nos nomes de caminho. Para verificar se um arquivo existente é executável, use os.access (caminho, modo) , com o modo os.X_OK.

os.X_OK

Valor a incluir no parâmetro mode de access () para determinar se o caminho pode ser executado.

Edição: As which()implementações sugeridas estão faltando uma pista - usando os.path.join()para criar nomes de arquivos completos.

Com base em que é mais fácil pedir perdão do que permissão, eu apenas tentaria usá-lo e capturar o erro (neste caso, OSError - verifiquei se o arquivo não existe e o arquivo não é executável e ambos fornecem o OSError).

Ajuda se o executável tem algo como um --versionsinalizador que é um rápido não funcionamento.

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

Essa não é uma solução geral, mas será a maneira mais fácil para muitos casos de uso - aqueles em que o código precisa procurar um único executável conhecido.

Sei que estou sendo um pouco necromante aqui, mas me deparei com essa pergunta e a solução aceita não funcionou para mim em todos os casos. Achei que seria útil enviar de qualquer maneira. Em particular, a detecção do modo "executável" e o requisito de fornecer a extensão do arquivo. Além disso, o python3.3 shutil.which(usa PATHEXT) e o python2.4 + distutils.spawn.find_executable(apenas tenta adicionar '.exe') funcionam apenas em um subconjunto de casos.

Então, escrevi uma versão "super" (com base na resposta aceita e na PATHEXTsugestão de Suraj). Esta versão whichfaz a tarefa um pouco mais detalhadamente e tenta primeiro uma série de técnicas de "fase larga" em primeiro lugar e, eventualmente, tenta pesquisas mais refinadas no PATHespaço:

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

O uso fica assim:

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

A solução aceita não funcionou para mim neste caso, uma vez que havia arquivos como meld.1, meld.ico, meld.doap, etc, também no diretório, um dos quais foram devolvidos em vez (presumivelmente desde lexicographically primeiro) porque o teste executável na resposta aceita foi incompleta e dando falso-positivo.

O melhor exemplo deve ser o módulo bulit-in python shutil.which () no Python 3. O link é https://hg.python.org/cpython/file/default/Lib/shutil.py

Encontrei algo no StackOverflow que resolveu o problema para mim. Isso funciona desde que o executável tenha uma opção (como --help ou --version) que produz algo e retorna um status de saída igual a zero. Consulte Suprimir saída em chamadas do Python para executáveis - o "resultado" no final do trecho de código nesta resposta será zero se o executável estiver no caminho, caso contrário, é mais provável que seja 1.

Isso parece bastante simples e funciona tanto em python 2 quanto em 3

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

Uma pergunta importante é " Por que você precisa testar se existe um executável?" Talvez você não? ;-)

Recentemente, eu precisava dessa funcionalidade para iniciar o visualizador de arquivos PNG. Eu queria interagir com alguns espectadores predefinidos e executar o primeiro que existe. Felizmente, me deparei os.startfile. É muito melhor! Simples, portátil e usa o visualizador padrão no sistema:

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

Atualização: Eu estava errado em os.startfileser portátil ... É apenas o Windows. No Mac, você deve executar o opencomando. E xdg_openno Unix. Há um problema de Python ao adicionar suporte para Mac e Unix os.startfile.

Você pode tentar a biblioteca externa chamada "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

Adicionado suporte ao 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

você pode dizer se existe um arquivo com o módulo os. um executável em particular parece bastante portável, considerando que muitas coisas são executáveis ​​no nix que não estão no Windows e vice-versa.

Parece que a escolha óbvia é "what", analisando os resultados via popen, mas você pode simular isso usando a classe os. No pseudopython, ficaria assim:

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

Então, basicamente, você deseja encontrar um arquivo no sistema de arquivos montado (não necessariamente nos diretórios PATH) e verificar se é executável. Isso se traduz no seguinte plano:

• enumere todos os arquivos em sistemas de arquivos montados localmente
• corresponder resultados com padrão de nome
• para cada arquivo encontrado, verifique se é executável

Eu diria que fazer isso de maneira portátil exigirá muito poder e tempo de computação. É realmente o que você precisa?

Existe um script what.py em uma distribuição padrão do Python (por exemplo, no Windows '\PythonXX\Tools\Scripts\which.py').

EDIT: which.pydepende, lsportanto, não é multiplataforma.

Nenhum dos exemplos anteriores funciona em todas as plataformas. Geralmente eles não funcionam no Windows, porque você pode executar sem a extensão do arquivo e registrar uma nova extensão. Por exemplo, no Windows, se o python estiver bem instalado, basta executar 'file.py' e ele funcionará.

A única solução válida e portátil que eu tinha era executar o comando e ver o código de erro. Qualquer executável decente deve ter um conjunto de parâmetros de chamada que não farão nada.

Usando a biblioteca de malhas 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