Uji apakah executable ada di Python?

Dalam Python, apakah ada cara portabel dan sederhana untuk menguji apakah ada program yang dapat dieksekusi?

Secara sederhana saya maksudkan sesuatu seperti whichperintah yang akan sempurna. Saya tidak ingin mencari PATH secara manual atau sesuatu yang melibatkan mencoba untuk mengeksekusinya dengan Popen& al dan melihat apakah itu gagal (itulah yang saya lakukan sekarang, tetapi bayangkan itu launchmissiles)

Cara termudah yang bisa saya pikirkan:

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

Sunting : Sampel kode yang diperbarui untuk memasukkan logika untuk menangani kasus di mana argumen yang disediakan sudah path lengkap ke executable, yaitu "yang / bin / ls". Ini meniru perilaku perintah 'yang' UNIX.

Sunting : Diperbarui untuk menggunakan os.path.isfile () alih-alih os.path.exists () per komentar.

Sunting : path.strip('"')sepertinya hal yang salah untuk dilakukan di sini. Baik Windows maupun POSIX tidak muncul untuk mendorong item PATH yang dikutip.

Saya tahu ini adalah pertanyaan kuno, tetapi Anda dapat menggunakannya distutils.spawn.find_executable. Ini telah didokumentasikan sejak python 2.4 dan telah ada sejak python 1.6.

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

Juga, Python 3.3 sekarang menawarkan shutil.which().

Python 3.3 sekarang menawarkan shutil.which () .

Untuk python 3.2 dan sebelumnya:

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

Ini adalah satu-baris Jawaban Jay , Juga di sini sebagai fungsi 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')

Atau terakhir, indentasi sebagai fungsi:

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

Untuk python 3.3 dan yang lebih baru:

import shutil

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

Sebagai pelaut Jan-Philip Gehrcke Jawaban :

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

Sebagai def:

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

Hanya ingat untuk menentukan ekstensi file di windows. Kalau tidak, Anda harus menulis banyak rumit is_exeuntuk windows menggunakan PATHEXTvariabel lingkungan. Anda mungkin hanya ingin menggunakan FindPath .

OTOH, mengapa Anda repot-repot mencari yang dapat dieksekusi? Sistem operasi akan melakukannya untuk Anda sebagai bagian dari popenpanggilan & akan memunculkan pengecualian jika executable tidak ditemukan. Yang perlu Anda lakukan adalah menangkap pengecualian yang benar untuk OS yang diberikan. Perhatikan bahwa pada Windows, subprocess.Popen(exe, shell=True)akan gagal secara diam-diam jika exetidak ditemukan.

Menggabungkan PATHEXTke dalam implementasi di atas which(dalam jawaban 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

Untuk platform * nix (Linux dan OS X)

Ini sepertinya bekerja untuk saya:

Diedit untuk bekerja di Linux, terima kasih kepada Mestreion

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

Apa yang kami lakukan di sini adalah menggunakan perintah builtin typedan memeriksa kode keluar. Jika tidak ada perintah seperti itu, typeakan keluar dengan 1 (atau kode status bukan nol).

Bit tentang stdout dan stderr hanya untuk membungkam output dari typeperintah, karena kami hanya tertarik pada kode status keluar.

Contoh penggunaan:

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

Lihat modul os.path untuk mengetahui beberapa fungsi berguna pada nama path. Untuk memeriksa apakah file yang ada dapat dieksekusi, gunakan os.access (path, mode) , dengan mode os.X_OK.

os.X_OK

Nilai untuk dimasukkan dalam parameter mode akses () untuk menentukan apakah jalur dapat dieksekusi.

EDIT:which() Implementasi yang disarankan tidak memiliki satu petunjuk - gunakan os.path.join()untuk membangun nama file lengkap.

Atas dasar itu lebih mudah untuk meminta maaf daripada izin saya hanya akan mencoba menggunakannya dan menangkap kesalahan (OSError dalam hal ini - saya memeriksa file tidak ada dan file tidak dapat dieksekusi dan mereka berdua memberikan OSError).

Ini membantu jika executable memiliki sesuatu seperti --versionflag yang merupakan no-op cepat.

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

Ini bukan solusi umum, tetapi akan menjadi cara termudah untuk banyak kasus penggunaan - kasus di mana kode perlu mencari satu executable terkenal.

Saya tahu bahwa saya menjadi sedikit ahli nujum di sini, tetapi saya menemukan pertanyaan ini dan solusi yang diterima tidak bekerja untuk saya untuk semua kasus. Secara khusus, deteksi mode "executable", dan persyaratan untuk memasok ekstensi file. Lebih jauh lagi, baik python3.3's shutil.which(uses PATHEXT) dan python2.4 + distutils.spawn.find_executable(hanya mencoba menambahkan '.exe') hanya berfungsi dalam subset kasus.

Jadi saya menulis versi "super" (berdasarkan jawaban yang diterima, dan PATHEXTsaran dari Suraj). Versi whichtugas ini sedikit lebih teliti, dan mencoba serangkaian teknik "luas-lebar" pertama, dan akhirnya mencoba pencarian yang lebih baik atas PATHruang:

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

Penggunaannya terlihat seperti ini:

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

Solusi yang diterima tidak bekerja untuk saya dalam kasus ini, karena ada file seperti meld.1, meld.ico, meld.doap, dll juga di direktori, salah satunya dikembalikan bukan (mungkin karena leksikografi pertama) karena tes dieksekusi dalam jawaban yang diterima tidak lengkap dan memberikan positif palsu.

Contoh terbaik adalah modul python bulit-in shutil.which () dengan Python 3. Tautannya adalah https://hg.python.org/cpython/file/default/Lib/shutil.py

Saya menemukan sesuatu di StackOverflow yang memecahkan masalah bagi saya. Ini berfungsi asalkan executable memiliki opsi (seperti --help atau --version) yang menampilkan sesuatu dan mengembalikan status keluar nol. Lihat Menekan keluaran dalam panggilan Python ke executable - "hasil" di akhir cuplikan kode dalam jawaban ini akan menjadi nol jika dieksekusi di jalur, kalau tidak kemungkinan besar adalah 1.

Ini tampaknya cukup sederhana dan berfungsi baik di python 2 dan 3

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

Sebuah pertanyaan penting adalah " Mengapa Anda perlu menguji apakah executable ada?" Mungkin tidak? ;-)

Baru-baru ini saya membutuhkan fungsi ini untuk meluncurkan viewer untuk file PNG. Saya ingin mengulangi beberapa pemirsa yang telah ditentukan dan menjalankan yang pertama yang ada. Untungnya, saya menemukan os.startfile. Jauh lebih baik! Sederhana, portabel dan menggunakan penampil default pada sistem:

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

Pembaruan: Saya salah tentang os.startfilemenjadi portabel ... Ini hanya Windows. Di Mac Anda harus menjalankan openperintah. Dan xdg_opendi Unix. Ada masalah Python tentang menambahkan dukungan Mac dan Unix untuk os.startfile.

Anda dapat mencoba lib eksternal yang disebut "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

Dukungan windows ditambahkan

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

Anda dapat mengetahui apakah ada file dengan modul os. executable pada khususnya tampaknya cukup tidak dapat dipercaya mengingat banyak hal yang dapat dieksekusi pada nix yang tidak ada di windows dan sebaliknya.

Tampaknya pilihan yang jelas adalah "yang", mem-parsing hasil melalui popen, tetapi Anda bisa mensimulasikannya menggunakan kelas os. Dalam pseudopython, akan terlihat seperti ini:

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

Jadi pada dasarnya Anda ingin menemukan file dalam sistem file yang terpasang (tidak harus hanya di direktori PATH saja) dan periksa apakah itu dapat dieksekusi. Ini berarti rencana berikut:

• menghitung semua file dalam sistem file yang dipasang secara lokal
• mencocokkan hasil dengan pola nama
• untuk setiap file yang ditemukan periksa apakah itu dapat dieksekusi

Menurut saya, melakukan ini dengan cara yang portabel akan membutuhkan banyak daya komputasi dan waktu. Benarkah itu yang Anda butuhkan?

Ada skrip which.py dalam distribusi Python standar (misalnya pada Windows'\PythonXX\Tools\Scripts\which.py' ).

EDIT: which.pytergantung pada lskarena itu bukan cross-platform.

Tidak ada contoh sebelumnya yang berfungsi pada semua platform. Biasanya mereka gagal bekerja di Windows karena Anda dapat mengeksekusi tanpa ekstensi file dan Anda dapat mendaftarkan ekstensi baru. Sebagai contoh pada Windows jika python terinstal dengan baik, itu cukup untuk menjalankan 'file.py' dan itu akan bekerja

Satu-satunya solusi yang valid dan portabel yang saya miliki adalah menjalankan perintah dan melihat kode kesalahan. Setiap executable yang layak harus memiliki seperangkat parameter panggilan yang tidak akan melakukan apa pun.

Menggunakan pustaka kain 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