Kiểm tra nếu thực thi tồn tại trong Python?

Trong Python, có một cách di động và đơn giản để kiểm tra nếu một chương trình thực thi tồn tại?

Nói một cách đơn giản, ý tôi là thứ gì đó giống như whichlệnh sẽ hoàn hảo. Tôi không muốn tìm kiếm PATH một cách thủ công hoặc một cái gì đó liên quan đến việc cố gắng thực hiện nó với Popen& al và xem nếu nó thất bại (đó là những gì tôi đang làm bây giờ, nhưng hãy tưởng tượng nó launchmissiles)

Cách dễ nhất tôi có thể nghĩ ra:

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

Chỉnh sửa : Mẫu mã được cập nhật để bao gồm logic để xử lý trường hợp trong đó đối số được cung cấp đã là đường dẫn đầy đủ đến tệp thực thi, tức là "which / bin / ls". Điều này bắt chước hành vi của lệnh 'which' UNIX.

Chỉnh sửa : Đã cập nhật để sử dụng os.path.isfile () thay vì os.path.exists () cho mỗi bình luận.

Chỉnh sửa : path.strip('"')có vẻ như điều sai trái để làm ở đây. Cả Windows và POSIX đều không xuất hiện để khuyến khích các mục PATH được trích dẫn.

Tôi biết đây là một câu hỏi cổ xưa, nhưng bạn có thể sử dụng distutils.spawn.find_executable. Điều này đã được ghi nhận từ python 2.4 và đã tồn tại từ python 1.6.

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

Ngoài ra, Python 3.3 hiện cung cấp shutil.which().

Python 3.3 hiện cung cấp shutil.which () .

Đối với python 3.2 trở về trước:

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

Đây là một trong những câu trả lời của Jay , cũng ở đây với tư cách là một lambda func:

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

Hoặc cuối cùng, thụt lề như một chức năng:

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

Đối với python 3.3 trở lên:

import shutil

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

Là một phần của Jan-Philip Gehrcke Trả lời :

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

Như một khuyết điểm:

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

Chỉ cần nhớ để xác định phần mở rộng tập tin trên windows. Mặt khác, bạn phải viết một phức tạp is_execho các cửa sổ bằng cách sử dụng PATHEXTbiến môi trường. Bạn có thể chỉ muốn sử dụng FindPath .

OTOH, tại sao bạn thậm chí còn bận tâm để tìm kiếm thực thi? Hệ điều hành sẽ thực hiện điều đó cho bạn như một phần của popencuộc gọi & sẽ đưa ra một ngoại lệ nếu không tìm thấy tệp thực thi. Tất cả những gì bạn cần làm là nắm bắt ngoại lệ chính xác cho HĐH đã cho. Lưu ý rằng trên Windows, subprocess.Popen(exe, shell=True)sẽ thất bại âm thầm nếu exekhông được tìm thấy.

Kết hợp PATHEXTvới việc thực hiện ở trên which(trong câu trả lời của 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

Dành cho nền tảng * nix (Linux và OS X)

Điều này dường như đang làm việc cho tôi:

Được chỉnh sửa để hoạt động trên Linux, nhờ Mestreion

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

Những gì chúng ta đang làm ở đây là sử dụng lệnh dựng sẵn typevà kiểm tra mã thoát. Nếu không có lệnh như vậy, typesẽ thoát bằng 1 (hoặc mã trạng thái khác không).

Một chút về thiết bị xuất chuẩn và thiết bị xuất chuẩn chỉ là để tắt đầu ra của typelệnh, vì chúng ta chỉ quan tâm đến mã trạng thái thoát.

Ví dụ sử dụng:

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

Xem mô-đun os.path để biết một số chức năng hữu ích trên tên đường dẫn. Để kiểm tra xem một tệp hiện có có thể thực thi được hay không, hãy sử dụng os.access (đường dẫn, chế độ) , với chế độ os.X_OK.

os.X_OK

Giá trị bao gồm trong tham số chế độ của access () để xác định xem đường dẫn có thể được thực thi hay không.

EDIT: Việc which()triển khai được đề xuất thiếu một đầu mối - sử dụng os.path.join()để xây dựng tên tệp đầy đủ.

Trên cơ sở, việc xin tha thứ dễ dàng hơn sự cho phép, tôi chỉ cố gắng sử dụng và bắt lỗi (OSError trong trường hợp này - Tôi đã kiểm tra tệp không tồn tại và tệp không thể thực thi được và cả hai đều cho OSError).

Nó giúp nếu thực thi có một cái gì đó giống như một --versionlá cờ là một no-op nhanh chóng.

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

Đây không phải là một giải pháp chung, nhưng sẽ là cách dễ nhất cho nhiều trường hợp sử dụng - những trường hợp mã cần tìm một tệp thực thi nổi tiếng duy nhất.

Tôi biết rằng tôi là một người cần thiết ở đây, nhưng tôi tình cờ thấy câu hỏi này và giải pháp được chấp nhận không phù hợp với tôi trong mọi trường hợp. Dù sao đi nữa, nó cũng có thể hữu ích. Cụ thể, phát hiện chế độ "thực thi" và yêu cầu cung cấp phần mở rộng tệp. Hơn nữa, cả python3.3 shutil.which(sử dụng PATHEXT) và python2.4 + distutils.spawn.find_executable(chỉ cố gắng thêm '.exe') chỉ hoạt động trong một tập hợp con của các trường hợp.

Vì vậy, tôi đã viết một phiên bản "siêu" (dựa trên câu trả lời được chấp nhận và PATHEXTgợi ý từ Suraj). Phiên bản whichnày thực hiện nhiệm vụ kỹ lưỡng hơn một chút và thử một loạt các kỹ thuật đầu tiên "broadphase", và cuối cùng thử các tìm kiếm chi tiết hơn trên PATHkhông gian:

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

Cách sử dụng trông như thế này:

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

Các giải pháp được chấp nhận không làm việc cho tôi trong trường hợp này, vì đã có các file thích meld.1, meld.ico, meld.doap, vv cũng trong thư mục, một trong số đó đã được trả lời thay vì (có lẽ kể từ thứ tự từ điển đầu tiên) vì kiểm tra thực thi trong câu trả lời được chấp nhận là không đầy đủ và đưa ra dương tính giả.

Ví dụ tốt nhất phải là mô-đun bulit-in python shutil.which () trong Python 3. Liên kết là https://hg.python.org/cpython/file/default/Lib/shutil.py

Tôi đã tìm thấy một cái gì đó trong StackOverflow đã giải quyết vấn đề cho tôi. Công việc này được cung cấp thực thi có một tùy chọn (như --help hoặc --version) để xuất ra một cái gì đó và trả về trạng thái thoát bằng không. Xem đầu ra Suppress trong các lệnh gọi Python tới các tệp thực thi - "kết quả" ở cuối đoạn mã trong câu trả lời này sẽ bằng 0 nếu tệp thực thi nằm trong đường dẫn, nếu không thì rất có thể là 1.

Điều này có vẻ đủ đơn giản và hoạt động cả trong python 2 và 3

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

Một câu hỏi quan trọng là " Tại sao bạn cần kiểm tra nếu thực thi tồn tại?" Có lẽ bạn không? ;-)

Gần đây tôi cần chức năng này để khởi chạy trình xem cho tệp PNG. Tôi muốn lặp lại một số người xem được xác định trước và chạy cái đầu tiên tồn tại. May mắn thay, tôi đã đi qua os.startfile. Đó là điều tốt hơn nhiều! Đơn giản, di động và sử dụng trình xem mặc định trên hệ thống:

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

Cập nhật: Tôi đã sai về os.startfileviệc di động ... Chỉ có Windows. Trên Mac bạn phải chạy openlệnh. Và xdg_opentrên Unix. Có một vấn đề Python về việc thêm hỗ trợ Mac và Unix cho os.startfile.

Bạn có thể thử lib bên ngoài được gọi là "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

Đã thêm hỗ trợ 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

bạn có thể biết nếu một tập tin tồn tại với mô-đun os. một thực thi cụ thể có vẻ khá không thể xem xét khi xem xét rất nhiều thứ có thể thực thi được trên nix không có trên windows và ngược lại.

Có vẻ như sự lựa chọn rõ ràng là "cái", phân tích kết quả qua popen, nhưng bạn có thể mô phỏng nó bằng cách sử dụng lớp os. Trong pseudopython, nó sẽ trông như thế này:

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

Vì vậy, về cơ bản, bạn muốn tìm một tệp trong hệ thống tệp được gắn (không nhất thiết chỉ trong các thư mục PATH) và kiểm tra xem nó có thể thực thi được không. Điều này có nghĩa là kế hoạch sau đây:

• liệt kê tất cả các tệp trong hệ thống tệp được gắn cục bộ
• kết quả khớp với mẫu tên
• cho mỗi tập tin tìm thấy kiểm tra nếu nó là thực thi

Tôi muốn nói, làm điều này theo cách di động sẽ đòi hỏi nhiều sức mạnh và thời gian tính toán. Có thực sự là những gì bạn cần?

Có một tập lệnh which.txt trong bản phân phối Python chuẩn (ví dụ: trên Windows'\PythonXX\Tools\Scripts\which.py' ).

EDIT: which.pyphụ thuộc vào lsdo đó nó không phải là đa nền tảng.

Không có ví dụ nào trước đây hoạt động trên tất cả các nền tảng. Thông thường, chúng không hoạt động trên Windows vì bạn có thể thực thi mà không có phần mở rộng tệp và bạn có thể đăng ký tiện ích mở rộng mới. Ví dụ: trên Windows nếu python được cài đặt tốt, nó đủ để thực thi 'file.py' và nó sẽ hoạt động.

Giải pháp hợp lệ và di động duy nhất tôi có là thực thi lệnh và xem mã lỗi. Bất kỳ thực thi tốt nên có một bộ các tham số gọi sẽ không làm gì.

Sử dụng thư viện vải 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