Запуск команды оболочки и захват вывода

Во всех официально поддерживаемых версиях Python самым простым подходом является использование subprocess.check_output < / a> функция:

>>> subprocess.check_output(['ls', '-l'])
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Если вы используете Python 3.5+ и вам не нужна обратная совместимость, новая run функция рекомендована официальной документацией для большинства задач. Он предоставляет общий высокоуровневый API для модуля subprocess. Чтобы захватить вывод программы, передайте флаг subprocess.PIPE аргументу ключевого слова stdout. Затем обратитесь к атрибуту stdout возвращенного объекта CompletedProcess:

>>> import subprocess
>>> result = subprocess.run(['ls', '-l'], stdout=subprocess.PIPE)
>>> result.stdout
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Возвращаемое значение - объект bytes, поэтому, если вам нужна правильная строка, вам нужно decode ее. Предполагая, что вызываемый процесс возвращает строку в кодировке UTF-8:

>>> result.stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

При желании все это можно сжать до однострочного:

>>> subprocess.run(['ls', '-l'], stdout=subprocess.PIPE).stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Если вы хотите передать ввод в stdin процесса, вы можете передать объект bytes в аргумент ключевого слова input:

>>> cmd = ['awk', 'length($0) > 5']
>>> ip = 'foo\nfoofoo\n'.encode('utf-8')
>>> result = subprocess.run(cmd, stdout=subprocess.PIPE, input=ip)
>>> result.stdout.decode('utf-8')
'foofoo\n'

Вы можете фиксировать ошибки, передавая stderr=subprocess.PIPE (захват в result.stderr) или stderr=subprocess.STDOUT (захват в result.stdout вместе с обычным выводом). Если вы хотите, чтобы run генерировал исключение, когда процесс возвращает ненулевой код выхода, вы можете передать check=True. (Или вы можете проверить атрибут returncode в result выше.) Если безопасность не является проблемой, вы также можете запускать более сложные команды оболочки, передавая shell=True, как описано в конце этого ответа.

Более поздние версии Python оптимизируют вышесказанное. В Python 3.7+ приведенный выше однострочный текст можно записать так:

>>> subprocess.run(['ls', '-l'], capture_output=True, text=True).stdout
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Использование run таким способом добавляет немного сложности по сравнению со старым способом работы. Но теперь вы можете делать почти все, что вам нужно, только с помощью функции run.

Старые версии Python (3-3.4): подробнее о check_output

Если вы используете старую версию Python или вам нужна умеренная обратная совместимость, вы можете использовать функцию check_output, как кратко описано выше. Он доступен начиная с Python 2.7.

subprocess.check_output(*popenargs, **kwargs)  

Он принимает те же аргументы, что и Popen (см. Ниже), и возвращает строку, содержащую вывод программы. В начале этого ответа есть более подробный пример использования. В Python 3.5+ check_output эквивалентно выполнению run с check=True и stdout=PIPE и возврату только атрибута stdout.

Вы можете передать stderr=subprocess.STDOUT, чтобы гарантировать включение сообщений об ошибках в возвращаемый результат. Когда безопасность не важна, вы также можете запускать более сложные команды оболочки, передав shell=True, как описано в конце этого ответа.

Если вам нужно передать по конвейеру от stderr или передать ввод процессу, check_output не справится с этой задачей. В этом случае см. Popen примеры ниже.

Сложные приложения и устаревшие версии Python (2.6 и ниже): Popen

Если вам нужна глубокая обратная совместимость или если вам нужна более сложная функциональность, чем предоставляют check_output или run, вам придется работать напрямую с Popen объектами, которые инкапсулируют низкоуровневый API для подпроцессов.

Конструктор Popen принимает либо одну команду без аргументов, либо список, содержащий команду в качестве первого элемента, за которым следует любое количество аргументов, каждый как отдельный элемент в список. shlex.split может помочь преобразовать строки в списки с соответствующим форматом. Popen объекты также принимают множество различных аргументов для управления вводом-выводом процесса. и низкоуровневая конфигурация.

Для отправки ввода и вывода вывода почти всегда предпочтительным методом является communicate. Как в:

output = subprocess.Popen(["mycmd", "myarg"], 
                          stdout=subprocess.PIPE).communicate()[0]

Or

>>> import subprocess
>>> p = subprocess.Popen(['ls', '-a'], stdout=subprocess.PIPE, 
...                                    stderr=subprocess.PIPE)
>>> out, err = p.communicate()
>>> print out
.
..
foo

Если вы установите stdin=PIPE, communicate также позволяет передавать данные процессу через stdin:

>>> cmd = ['awk', 'length($0) > 5']
>>> p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
...                           stderr=subprocess.PIPE,
...                           stdin=subprocess.PIPE)
>>> out, err = p.communicate('foo\nfoofoo\n')
>>> print out
foofoo

Обратите внимание на ответ Аарона Холла, в котором указано, что в некоторых системах вам может потребоваться установить stdout, stderr и stdin все на PIPE (или DEVNULL), чтобы communicate вообще заработал.

В некоторых редких случаях может потребоваться сложный захват вывода в реальном времени. Ответ Vartec предлагает путь вперед, но методы, отличные от communicate, подвержены тупиковым ситуациям, если их не использовать осторожно.

Как и в случае со всеми вышеупомянутыми функциями, когда безопасность не является проблемой, вы можете запускать более сложные команды оболочки, передавая shell=True.

Примечания

1. Запуск команд оболочки: аргумент shell=True

Обычно каждый вызов конструктора run, check_output или Popen выполняет отдельную программу. Это означает отсутствие причудливых каналов в стиле bash. Если вы хотите запускать сложные команды оболочки, вы можете передать shell=True, который поддерживают все три функции. Например:

>>> subprocess.check_output('cat books/* | wc', shell=True, text=True)
' 1299377 17005208 101299376\n'

Однако при этом возникают проблемы безопасности. Если вы делаете что-то большее, чем сценарии освещения, вам может быть лучше вызывать каждый процесс отдельно и передавать вывод каждого в качестве ввода следующему через

run(cmd, [stdout=etc...], input=other_output)

Or

Popen(cmd, [stdout=etc...]).communicate(other_output)

Соблазн напрямую соединить трубы велик; сопротивляться этому. В противном случае вы, скорее всего, столкнетесь с тупиками или вам придется делать такие хакерские вещи, как this.

Это намного проще, но работает только в Unix (включая Cygwin) и Python2.7.

import commands
print commands.getstatusoutput('wc -l file')

Он возвращает кортеж с (return_value, output).

Для решения, которое работает как в Python2, так и в Python3, используйте вместо этого модуль subprocess:

from subprocess import Popen, PIPE
output = Popen(["date"],stdout=PIPE)
response = output.communicate()
print response

Что-то подобное:

def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    while(True):
        # returns None while subprocess is running
        retcode = p.poll() 
        line = p.stdout.readline()
        yield line
        if retcode is not None:
            break

Обратите внимание, что я перенаправляю stderr на stdout, это может быть не совсем то, что вам нужно, но мне также нужны сообщения об ошибках.

Эта функция выдает построчно по мере поступления (обычно вам нужно дождаться завершения подпроцесса, чтобы получить результат в целом).

В вашем случае использование будет следующим:

for line in runProcess('mysqladmin create test -uroot -pmysqladmin12'.split()):
    print line,

У меня была такая же проблема, но я понял очень простой способ сделать это:

import subprocess
output = subprocess.getoutput("ls -l")
print(output)

Надеюсь, это поможет

Примечание. Это решение специфично для Python3, поскольку subprocess.getoutput() не работает в Python2.

Ответ Vartec не читает все строки, поэтому я сделал версию, которая читала:

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

Использование такое же, как и в принятом ответе:

command = 'mysqladmin create test -uroot -pmysqladmin12'.split()
for line in run_command(command):
    print(line)

Это сложное, но сверхпростое решение, которое работает во многих ситуациях:

import os
os.system('sample_cmd > tmp')
print(open('tmp', 'r').read())

Временный файл (здесь tmp) создается с выводом команды, и вы можете прочитать из него желаемый результат.

Дополнительное примечание из комментариев: вы можете удалить файл tmp в случае одноразовой работы. Если вам нужно сделать это несколько раз, нет необходимости удалять tmp.

os.remove('tmp')

Вы можете использовать следующие команды для запуска любой команды оболочки. Я использовал их на Ubuntu.

import os
os.popen('your command here').read()

Примечание. Это устарело, начиная с python 2.6. Теперь вы должны использовать subprocess.Popen. Ниже приведен пример

import subprocess

p = subprocess.Popen("Your command", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")

Ваш пробег может отличаться, я попытался использовать @senderle для решения Vartec в Windows на Python 2.6.5, но я получал ошибки, и никакие другие решения не работали. Моя ошибка была: WindowsError: [Error 6] The handle is invalid.

Я обнаружил, что мне пришлось назначить PIPE каждому дескриптору, чтобы заставить его возвращать ожидаемый результат - у меня сработало следующее.

import subprocess

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    return subprocess.Popen(cmd, 
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE).communicate()

и вызовите это так ([0] получает первый элемент кортежа, stdout):

run_command('tracert 11.1.0.1')[0]

Узнав больше, я считаю, что мне нужны эти аргументы канала, потому что я работаю над настраиваемой системой, которая использует разные дескрипторы, поэтому мне пришлось напрямую контролировать все std.

Чтобы остановить всплывающие окна консоли (в Windows), сделайте следующее:

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    # instantiate a startupinfo obj:
    startupinfo = subprocess.STARTUPINFO()
    # set the use show window flag, might make conditional on being in Windows:
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    # pass as the startupinfo keyword argument:
    return subprocess.Popen(cmd,
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE, 
                            startupinfo=startupinfo).communicate()

run_command('tracert 11.1.0.1')

У меня была немного другая разновидность той же проблемы со следующими требованиями:

1. Capture and return STDOUT messages as they accumulate in the STDOUT buffer (i.e. in realtime).
   • @vartec solved this Pythonically with his use of generators and the 'yield'
     keyword above
2. Распечатать все строки STDOUT (даже если процесс завершится до того, как буфер STDOUT будет полностью прочитан)
3. Не тратьте зря циклы процессора, опрашивая процесс на высокой частоте
4. Проверить код возврата подпроцесса
5. Выведите STDERR (отдельно от STDOUT), если мы получим ненулевой код возврата ошибки.

Я объединил и изменил предыдущие ответы, чтобы получить следующее:

import subprocess
from time import sleep

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=True)
    # Read stdout from subprocess until the buffer is empty !
    for line in iter(p.stdout.readline, b''):
        if line: # Don't print blank lines
            yield line
    # This ensures the process has completed, AND sets the 'returncode' attr
    while p.poll() is None:                                                                                                                                        
        sleep(.1) #Don't waste CPU-cycles
    # Empty STDERR buffer
    err = p.stderr.read()
    if p.returncode != 0:
       # The run_command() function is responsible for logging STDERR 
       print("Error: " + str(err))

Этот код будет выполнен так же, как и предыдущие ответы:

for line in run_command(cmd):
    print(line)

Разделение начальной команды для subprocess может быть непростым и громоздким.

Используйте shlex.split(), чтобы помочь себе.

Пример команды

git log -n 5 --since "5 years ago" --until "2 year ago"

Код

from subprocess import check_output
from shlex import split

res = check_output(split('git log -n 5 --since "5 years ago" --until "2 year ago"'))
print(res)
>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61a\nAuthor: Artur Barseghyan...'

Без shlex.split() код выглядел бы следующим образом

res = check_output([
    'git', 
    'log', 
    '-n', 
    '5', 
    '--since', 
    '5 years ago', 
    '--until', 
    '2 year ago'
])
print(res)
>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61a\nAuthor: Artur Barseghyan...'

Вот решение, работающее, если вы хотите распечатать вывод во время работы процесса или нет.

Я также добавил текущий рабочий каталог, он мне пригодился не раз.

Надеясь, что решение кому-то поможет :).

import subprocess

def run_command(cmd_and_args, print_constantly=False, cwd=None):
"""Runs a system command.

:param cmd_and_args: the command to run with or without a Pipe (|).
:param print_constantly: If True then the output is logged in continuous until the command ended.
:param cwd: the current working directory (the directory from which you will like to execute the command)
:return: - a tuple containing the return code, the stdout and the stderr of the command
"""
output = []

process = subprocess.Popen(cmd_and_args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)

while True:
    next_line = process.stdout.readline()
    if next_line:
        output.append(str(next_line))
        if print_constantly:
            print(next_line)
    elif not process.poll():
        break

error = process.communicate()[1]

return process.returncode, '\n'.join(output), error

Если вам нужно запустить команду оболочки для нескольких файлов, это помогло мне.

import os
import subprocess

# Define a function for running commands and capturing stdout line by line
# (Modified from Vartec's solution because it wasn't printing all lines)
def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

# Get all filenames in working directory
for filename in os.listdir('./'):
    # This command will be run on each file
    cmd = 'nm ' + filename

    # Run the command and capture the output line by line.
    for line in runProcess(cmd.split()):
        # Eliminate leading and trailing whitespace
        line.strip()
        # Split the output 
        output = line.split()

        # Filter the output and print relevant lines
        if len(output) > 2:
            if ((output[2] == 'set_program_name')):
                print filename
                print line

Изменить: только что увидел решение Макса Перссона с предложением Дж. Ф. Себастьяна. Пошел вперед и включил это.

Согласно @senderle, если вы используете python3.6, как я:

def sh(cmd, input=""):
    rst = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, input=input.encode("utf-8"))
    assert rst.returncode == 0, rst.stderr.decode("utf-8")
    return rst.stdout.decode("utf-8")

sh("ls -a")

Будет действовать точно так же, как вы запускаете команду в bash

Если вы используете модуль subprocess python, вы можете обрабатывать STDOUT, STDERR и код возврата команды отдельно. Вы можете увидеть пример полной реализации вызывающей команды. Конечно, вы можете расширить его с помощью try..except, если хотите.

Приведенная ниже функция возвращает STDOUT, STDERR и код возврата, чтобы вы могли обработать их в другом скрипте.

import subprocess

def command_caller(command=None)
    sp = subprocess.Popen(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=False)
    out, err = sp.communicate()
    if sp.returncode:
        print(
            "Return code: %(ret_code)s Error message: %(err_msg)s"
            % {"ret_code": sp.returncode, "err_msg": err}
            )
    return sp.returncode, out, err

Я хотел бы предложить simppl в качестве варианта для рассмотрения. Это модуль, доступный через pypi: pip install simppl и работающий на python3.

simppl позволяет пользователю запускать команды оболочки и читать вывод с экрана.

Разработчики предлагают три варианта использования:

1. Самое простое использование будет выглядеть так:

    from simppl.simple_pipeline import SimplePipeline
    sp = SimplePipeline(start=0, end=100):
    sp.print_and_run('<YOUR_FIRST_OS_COMMAND>')
    sp.print_and_run('<YOUR_SECOND_OS_COMMAND>') ```

2. Для одновременного запуска нескольких команд используйте:

    commands = ['<YOUR_FIRST_OS_COMMAND>', '<YOUR_SECOND_OS_COMMAND>']
    max_number_of_processes = 4
    sp.run_parallel(commands, max_number_of_processes) ```

3. Наконец, если ваш проект использует модуль cli, вы можете напрямую запустить другой command_line_tool как часть конвейера. Другой инструмент будет запущен из того же процесса, но он будет отображаться в журналах как другая команда в конвейере. Это обеспечивает более плавную отладку и рефакторинг инструментов, вызывающих другие инструменты.

    from example_module import example_tool
    sp.print_and_run_clt(example_tool.run, ['first_number', 'second_nmber'], 
                                 {'-key1': 'val1', '-key2': 'val2'},
                                 {'--flag'}) ```

Обратите внимание, что печать в STDOUT / STDERR осуществляется через модуль logging python.

Вот полный код, показывающий, как работает simppl:

import logging
from logging.config import dictConfig

logging_config = dict(
    version = 1,
    formatters = {
        'f': {'format':
              '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'}
        },
    handlers = {
        'h': {'class': 'logging.StreamHandler',
              'formatter': 'f',
              'level': logging.DEBUG}
        },
    root = {
        'handlers': ['h'],
        'level': logging.DEBUG,
        },
)
dictConfig(logging_config)

from simppl.simple_pipeline import SimplePipeline
sp = SimplePipeline(0, 100)
sp.print_and_run('ls')

В Python 3.7+ используйте _1 _ и передайте capture_output=True:

import subprocess
result = subprocess.run(['echo', 'hello', 'world'], capture_output=True)
print(repr(result.stdout))

Это вернет байты:

b'hello world\n'

Если вы хотите преобразовать байты в строку, добавьте text=True:

result = subprocess.run(['echo', 'hello', 'world'], capture_output=True, text=True)
print(repr(result.stdout))

Это будет читать байты с использованием кодировки по умолчанию:

'hello world\n'

Если вам нужно вручную указать другую кодировку, используйте encoding="your encoding" вместо text=True:

result = subprocess.run(['echo', 'hello', 'world'], capture_output=True, encoding="utf8")
print(repr(result.stdout))

например, execute ('ls -ahl') различает три / четыре возможных возврата и платформы ОС:

1. нет вывода, но работает успешно
2. вывести пустую строку, запустить успешно
3. запустить не удалось
4. вывести что-то, запустить успешно

функция ниже

def execute(cmd, output=True, DEBUG_MODE=False):
"""Executes a bash command.
(cmd, output=True)
output: whether print shell output to screen, only affects screen display, does not affect returned values
return: ...regardless of output=True/False...
        returns shell output as a list with each elment is a line of string (whitespace stripped both sides) from output
        could be 
        [], ie, len()=0 --> no output;    
        [''] --> output empty line;     
        None --> error occured, see below

        if error ocurs, returns None (ie, is None), print out the error message to screen
"""
if not DEBUG_MODE:
    print "Command: " + cmd

    # https://stackoverflow.com/a/40139101/2292993
    def _execute_cmd(cmd):
        if os.name == 'nt' or platform.system() == 'Windows':
            # set stdin, out, err all to PIPE to get results (other than None) after run the Popen() instance
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        else:
            # Use bash; the default is sh
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, executable="/bin/bash")

        # the Popen() instance starts running once instantiated (??)
        # additionally, communicate(), or poll() and wait process to terminate
        # communicate() accepts optional input as stdin to the pipe (requires setting stdin=subprocess.PIPE above), return out, err as tuple
        # if communicate(), the results are buffered in memory

        # Read stdout from subprocess until the buffer is empty !
        # if error occurs, the stdout is '', which means the below loop is essentially skipped
        # A prefix of 'b' or 'B' is ignored in Python 2; 
        # it indicates that the literal should become a bytes literal in Python 3 
        # (e.g. when code is automatically converted with 2to3).
        # return iter(p.stdout.readline, b'')
        for line in iter(p.stdout.readline, b''):
            # # Windows has \r\n, Unix has \n, Old mac has \r
            # if line not in ['','\n','\r','\r\n']: # Don't print blank lines
                yield line
        while p.poll() is None:                                                                                                                                        
            sleep(.1) #Don't waste CPU-cycles
        # Empty STDERR buffer
        err = p.stderr.read()
        if p.returncode != 0:
            # responsible for logging STDERR 
            print("Error: " + str(err))
            yield None

    out = []
    for line in _execute_cmd(cmd):
        # error did not occur earlier
        if line is not None:
            # trailing comma to avoid a newline (by print itself) being printed
            if output: print line,
            out.append(line.strip())
        else:
            # error occured earlier
            out = None
    return out
else:
    print "Simulation! The command is " + cmd
    print ""

Вывод можно перенаправить в текстовый файл, а затем прочитать его.

import subprocess
import os
import tempfile

def execute_to_file(command):
    """
    This function execute the command
    and pass its output to a tempfile then read it back
    It is usefull for process that deploy child process
    """
    temp_file = tempfile.NamedTemporaryFile(delete=False)
    temp_file.close()
    path = temp_file.name
    command = command + " > " + path
    proc = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    if proc.stderr:
        # if command failed return
        os.unlink(path)
        return
    with open(path, 'r') as f:
        data = f.read()
    os.unlink(path)
    return data

if __name__ == "__main__":
    path = "Somepath"
    command = 'ecls.exe /files ' + path
    print(execute(command))

просто написал небольшой сценарий bash, чтобы сделать это с помощью curl

https://gist.github.com/harish2704/bfb8abece94893c53ce344548ead8ba5

#!/usr/bin/env bash

# Usage: gdrive_dl.sh <url>

urlBase='https://drive.google.com'
fCookie=tmpcookies

curl="curl -L -b $fCookie -c $fCookie"
confirm(){
    $curl "$1" | grep jfk-button-action | sed -e 's/.*jfk-button-action" href="\(\S*\)".*/\1/' -e 's/\&amp;/\&/g'
}

$curl -O -J "${urlBase}$(confirm $1)"