Python'da yürütülebilir olup olmadığını test ettiniz mi?

Python'da yürütülebilir bir program olup olmadığını test etmenin taşınabilir ve basit bir yolu var mı?

Basitçe söylemek gerekirse, whichsadece mükemmel olacak komut gibi bir şey demek istiyorum . PATH'yi manuel olarak veya Popen& al ile yürütmeyi denemek ve başarısız olup olmadığını görmek isteyen bir şey istemiyorum (şimdi yaptığım şey bu, ama hayal edin launchmissiles)

Düşünebileceğim en kolay yol:

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

Düzenleme : Sağlanan bağımsız değişken zaten çalıştırılabilir, yani "hangi / bin / ls" tam bir yol olduğu durumda işleme için mantık içerecek şekilde kod örneği güncelleştirildi. Bu UNIX 'hangi' komutunun davranışını taklit eder.

Düzenleme : Yorumlar başına os.path.exists () yerine os.path.isfile () kullanılacak şekilde güncellendi.

Düzenleme : path.strip('"')burada yapmak yanlış bir şey gibi görünüyor. Ne Windows ne de POSIX, alıntı yapılan PATH öğelerini teşvik etmemektedir.

Bunun eski bir soru olduğunu biliyorum, ama kullanabilirsiniz distutils.spawn.find_executable. Bu, python 2.4'ten beri belgelenmiştir ve python 1.6'dan beri mevcuttur.

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

Ayrıca, Python 3.3 şimdi sunuyor shutil.which().

Python 3.3 şimdi shutil.which () işlevini sunuyor .

Python 3.2 ve öncesi için:

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

Bu Jay'in cevabının bir astarı , ayrıca burada bir lambda fonk olarak:

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

Veya son olarak, bir işlev olarak girintili:

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

Python 3.3 ve üstü için:

import shutil

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

Jan-Philip Gehrcke'nin tek çizgisi olarak Cevap :

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

Bir def olarak:

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

Windows'ta dosya uzantısını belirtmeyi unutmayın. Aksi takdirde, ortam değişkenini is_exekullanarak pencereler için çok karmaşık yazmanız gerekir PATHEXT. Sadece FindPath'i kullanmak isteyebilirsiniz .

OTOH, çalıştırılabilir dosyayı aramak için neden uğraşıyorsun? İşletim sistemi, popençağrının bir parçası olarak bunu sizin için yapar ve yürütülebilir dosya bulunamazsa bir istisna oluşturur. Tek yapmanız gereken verilen işletim sistemi için doğru istisnayı yakalamak. Windows'da bulunmazsa subprocess.Popen(exe, shell=True)sessizce başarısız olacağını unutmayın exe.

Birleştirilerek PATHEXTyukarıdaki uygulamaya which(Jay'in yanıtında):

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

* Nix platformları için (Linux ve OS X)

Bu benim için çalışıyor gibi görünüyor:

Mestreion sayesinde Linux üzerinde çalışmak üzere düzenlendi

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

Burada yaptığımız şey yerleşik komutu kullanmak typeve çıkış kodunu kontrol etmektir. Böyle bir komut yoksa, type1'den (veya yine de sıfır olmayan bir durum kodundan) çıkar.

Stdout ve stderr ile ilgili bit sadece typekomutun çıktısını susturmaktır , çünkü sadece çıkış durum kodu ile ilgileniyoruz.

Örnek kullanım:

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

Yol adlarıyla ilgili bazı yararlı işlevler için os.path modülüne bakın . Varolan bir dosyanın yürütülebilir olup olmadığını kontrol etmek için os.X_OK moduyla os.access (yol, mod) kullanın .

os.X_OK

Yolun yürütülüp yürütülemeyeceğini belirlemek için access () mod parametresine dahil edilecek değer.

DÜZENLEME: Önerilen which()uygulamalarda os.path.join()tam dosya adları oluşturmak için bir ipucu eksik .

Bağışlama izni daha kolay istemek temelinde ben sadece onu kullanmak ve hatayı yakalamak denemek istiyorum (bu durumda OSError - Ben dosya yok ve dosya çalıştırılamaz ve her ikisi de OSError verir).

Yürütülebilir dosya --versionhızlı bir işlem olmayan bir bayrak gibi bir şey varsa yardımcı olur .

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

Bu genel bir çözüm değildir, ancak birçok kullanım durumu için en kolay yol olacaktır - kodun iyi bilinen tek bir yürütülebilir dosyayı araması gereken durumlar.

Burada biraz büyücü olduğumu biliyorum, ama bu soruya rastladım ve kabul edilen çözüm tüm durumlar için işe yaramadı Yine de göndermenin yararlı olabileceğini düşündüm. Özellikle, "yürütülebilir" mod algılama ve dosya uzantısının sağlanması gereksinimi. Ayrıca, hem python3.3 'ler shutil.which(kullanımları PATHEXT) hem de python2.4 +' lar distutils.spawn.find_executable(sadece eklemeye çalışır '.exe') yalnızca vakaların bir alt kümesinde çalışır .

Bu yüzden "süper" bir versiyon yazdım (kabul edilen cevap ve PATHEXTSuraj'ın önerisine dayanarak ). Bu sürümü which, görevi biraz daha ayrıntılı bir şekilde yapar ve önce bir dizi "geniş faz" önce genişlik tekniklerini dener ve sonunda PATHalan üzerinde daha ayrıntılı aramaları dener :

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

Kullanım şöyle görünür:

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

Kabul edilen çözüm dosyaları gibi vardı çünkü, bu durumda benim için iş vermedi meld.1, meld.ico, meld.doapvb da kabul yanıtında çalıştırılabilir testi eksik ve verme çünkü (sözlük sırasında ilk beri muhtemelen) yerine iade edildi, bunlardan biri dizininde yanlış pozitifler.

En iyi örnek Python 3'teki shutil.which () python bulit-in modülü olmalıdır. Bağlantı https://hg.python.org/cpython/file/default/Lib/shutil.py

StackOverflow'da sorunu benim için çözen bir şey buldum. Yürütülebilir dosyanın bir şey çıktısı veren ve çıkış durumunu sıfır döndüren bir seçeneği (--help veya --version gibi) olması koşuluyla çalışır. Bkz . Yürütülebilir dosyalara Python çağrılarında çıktıyı bastırma - çalıştırılabilir yoldaysa, bu pasajın kod pasajının sonundaki "sonuç" sıfır olacaktır, aksi takdirde büyük olasılıkla 1 olacaktır.

Bu yeterince basit görünüyor ve hem python 2 hem de 3'te çalışıyor

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

Önemli bir soru " Yürütülebilir dosya olup olmadığını neden test etmeniz gerekiyor?" Belki de bilmiyorsun? ;-)

Son zamanlarda PNG dosyası için görüntüleyiciyi başlatmak için bu işlevselliğe ihtiyacım vardı. Önceden tanımlanmış bazı izleyicileri yinelemek ve var olan ilkini çalıştırmak istedim. Neyse ki karşılaştım os.startfile. Bu daha iyi! Basit, taşınabilir ve sistemdeki varsayılan görüntüleyiciyi kullanır :

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

Güncelleme:os.startfile Taşınabilir olma konusunda yanılmışım ... Sadece Windows. Mac'te openkomutu çalıştırmanız gerekir . Ve xdg_openUnix'te. Mac ve Unix desteği eklerken bir Python sorunu var os.startfile.

"Sh" ( http://amoffat.github.io/sh/ ) adlı harici lib'i deneyebilirsiniz .

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

Windows desteği eklendi

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

os modülünde bir dosya olup olmadığını anlayabilirsiniz. Özellikle bir yürütülebilir dosya nix üzerinde windows üzerinde olmayan ve tersi çok şey göz önüne alındığında oldukça mantıklı görünmüyor.

Belli bir seçim "hangisi" gibi görünüyor, sonuçları popen ile ayrıştırıyor, ancak os sınıfını kullanarak bunu simüle edebilirsiniz. Pseudopython'da şöyle görünecektir:

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

Temel olarak, bağlı dosya sistemindeki bir dosyayı (yalnızca PATH dizinlerinde olması gerekmez) bulmak ve yürütülebilir olup olmadığını kontrol etmek istersiniz. Bu, aşağıdaki plan anlamına gelir:

• yerel olarak monte edilmiş dosya sistemlerindeki tüm dosyaları numaralandırma
• sonuçları isim modeliyle eşleştir
• bulunan her dosya için yürütülebilir olup olmadığını kontrol edin

Bunu taşınabilir bir şekilde yapmak, çok fazla bilgi işlem gücü ve zaman gerektireceğini söyleyebilirim. Gerçekten ihtiyacınız olan şey mi?

Bir yoktur which.py standart Python dağılımındaki komut (örneğin Windows üzerinde '\PythonXX\Tools\Scripts\which.py').

EDIT: which.pybağlıdır, lsbu nedenle çapraz platform değildir.

Önceki örneklerin hiçbiri tüm platformlarda çalışmaz. Genellikle dosya uzantısı olmadan yürütebileceğiniz ve yeni uzantı kaydedebileceğiniz için Windows'ta çalışmazlar . Örneğin Windows'da python iyi yüklenmişse, 'file.py' dosyasını çalıştırmak yeterlidir ve çalışır.

Sahip olduğum tek geçerli ve taşınabilir çözüm, komutu yürütmek ve hata kodunu görmekti. İyi bir yürütülebilir dosya, hiçbir şey yapmayacak bir dizi arama parametresine sahip olmalıdır.

Python kumaş kitaplığını kullanma:

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