Algunas sugerencias para separar el proceso hijo del que llama (iniciar el proceso hijo en segundo plano).

Suponga que desea comenzar una tarea larga desde un script CGI. Es decir, el proceso secundario debería vivir más tiempo que el proceso de ejecución del script CGI.

El ejemplo clásico de la documentación del módulo de subproceso es:

import subprocess
import sys

# Some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # Call subprocess

# Some more code here
 

La idea aquí es que no desea esperar en la línea 'llamar subproceso' hasta que finalice longtask.py. Pero no está claro qué sucede después de la línea 'más código aquí' del ejemplo.

Mi plataforma de destino era FreeBSD, pero el desarrollo estaba en Windows, así que enfrenté el problema en Windows primero.

En Windows (Windows XP), el proceso padre no finalizará hasta que longtask.py haya finalizado su trabajo. No es lo que quieres en un script CGI. El problema no es específico de Python; en la comunidad PHP los problemas son los mismos.

La solución es pasar DETACHED_PROCESS Indicador de creación de proceso a la función CreateProcess subyacente en la API de Windows. Si tiene instalado pywin32, puede importar el indicador desde el módulo de proceso win32, de lo contrario, debe definirlo usted mismo:

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid
 

/ * UPD 2015.10.27 @eryksun en un comentario debajo de las notas, que el indicador semánticamente correcto es CREATE_NEW_CONSOLE (0x00000010) * /

En FreeBSD tenemos otro problema: cuando el proceso padre finaliza, también finaliza el proceso hijo. Y eso tampoco es lo que quieres en un script CGI. Algunos experimentos mostraron que el problema parecía estar en compartir sys.stdout. Y la solución de trabajo fue la siguiente:

pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
 

No he verificado el código en otras plataformas y no sé las razones del comportamiento en FreeBSD. Si alguien lo sabe, por favor comparta sus ideas. Buscar en Google al iniciar procesos en segundo plano en Python todavía no arroja ninguna luz.

Compruebe también la biblioteca Python "pexpect".

Permite el control interactivo de programas / comandos externos, incluso ssh, ftp, telnet, etc. Puede escribir algo como:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')
 

subprocess.check_call es conveniente si no desea probar los valores de retorno. Lanza una excepción en cualquier error.

Si necesita la salida del comando que está llamando, entonces puede usar subprocess.check_output (Python 2.7+).

>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
 

También tenga en cuenta el parámetro shell .

Si el shell es True , el comando especificado se ejecutará a través del shell. Esto puede ser útil si está utilizando Python principalmente para el flujo de control mejorado que ofrece sobre la mayoría de los shells del sistema y aún desea un acceso conveniente a otras características de shell, como tuberías de shell, comodines de nombre de archivo, expansión de variable de entorno y expansión de ~ a la página de inicio de un usuario directorio. Sin embargo, tenga en cuenta que Python ofrece implementaciones de muchas características similares a las de shell (en particular, glob , fnmatch , os.walk() , os.path.expandvars() , os.path.expanduser() y shutil ).

Siempre uso fabric para estas cosas como:

from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )
 

Pero esta parece ser una buena herramienta: sh (interfaz de subproceso de Python) .

Mira un ejemplo:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)
 

os.system no le permite almacenar resultados, por lo que si desea almacenar los resultados en alguna lista o algo, un subprocess.call funciona.

Puede usar Popen, y luego puede verificar el estado del procedimiento:

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()
 

Consulte subprocess.Popen .

La forma más sencilla de ejecutar cualquier comando y recuperar el resultado:

from commands import getstatusoutput

try:
    return getstatusoutput("ls -ltr")
except Exception, e:
    return None
 

Me gusta bastante shell_command por su simplicidad. Está construido sobre el módulo de subproceso.

Aquí hay un ejemplo de la documentación:

>>> from shell_command import shell_call
>>> shell_call("ls *.py")
setup.py  shell_command.py  test_shell_command.py
0
>>> shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan  391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_shell_command.py
0
 

Así es como ejecuto mis comandos. Este código tiene todo lo que necesitas prácticamente

from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()
 

Actualización:

subprocess.run es el enfoque recomendado a partir de Python 3.5 si su código no necesita mantener la compatibilidad con versiones anteriores de Python. Es más consistente y ofrece una facilidad de uso similar a Envoy. (Sin embargo, las tuberías no son tan sencillas. Consulte esta pregunta sobre cómo .)

Aquí hay algunos ejemplos de la documentación .

Ejecute un proceso:

>>> subprocess.run(["ls", "-l"])  # Doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)
 

Aumento en ejecución fallida:

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
 

Salida de captura:

>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')
 

Respuesta original:

Recomiendo probar Envoy . Es un contenedor para subprocesos, que a su vez tiene como objetivo reemplazar los módulos más antiguos y funciones Enviado es un subproceso para los humanos.

Ejemplo de uso de the README :

>>> r = envoy.run('git config', data='data to pipe in', timeout=2)

>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''
 

Tubería alrededor también:

>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]
 

Con la biblioteca estándar

Utilice el módulo de subproceso (Python 3):

import subprocess
subprocess.run(['ls', '-l'])
 

Es la forma estándar recomendada. Sin embargo, las tareas más complicadas (canalizaciones, salida, entrada, etc.) pueden ser tediosas de construir y escribir.

Nota sobre la versión de Python: si todavía usa Python 2, subprocess.call funciona de manera similar.

ProTip: shlex.split puede ayudarlo a analizar el comando para run , call y otras funciones subprocess en caso de que no desee (o no pueda) proporcionarlas en forma de listas:

import shlex
import subprocess
subprocess.run(shlex.split('ls -l'))
 

Con dependencias externas

Si no le importan las dependencias externas, use plumbum :

from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())
 

Es el mejor contenedor subprocess . Es multiplataforma, es decir, funciona en sistemas Windows y Unix. Instalar por pip install plumbum .

Otra biblioteca popular es sh :

from sh import ifconfig
print(ifconfig('wlan0'))
 

Sin embargo, sh dejó de admitir Windows, por lo que ya no es tan impresionante como solía ser. Instalar por pip install sh .

Hay muchas formas diferentes de ejecutar comandos externos en Python, y todos ellos tienen sus propias ventajas e inconvenientes.

Mis colegas y yo hemos estado escribiendo herramientas de administración del sistema Python, por lo que necesitamos ejecutar muchos comandos externos y, a veces, desea que bloqueen o se ejecuten de forma asincrónica, tiempo de espera, actualización cada segundo, etc.

También hay diferentes formas de manejar el código de retorno y los errores, y es posible que desee analizar la salida y proporcionar una nueva entrada (en un esperar tipo de estilo ) O deberá redirigir stdin, stdout y stderr para que se ejecuten en un tty diferente (por ejemplo, cuando se usa la pantalla).

Entonces probablemente tendrá que escribir muchos contenedores alrededor del comando externo. Así que aquí hay un módulo de Python que hemos escrito que puede manejar casi cualquier cosa que desee, y si no, es muy flexible para que pueda extenderlo fácilmente:

https://github.com /hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py

actualización: no funciona de manera independiente y requiere algunas de nuestras otras herramientas, y obtuvo una gran cantidad de funcionalidades especializadas a lo largo de los años, por lo que puede que no sea una caída de reemplazo para usted, pero puede brindarle mucha información sobre cómo funcionan las partes internas de Python para ejecutar comandos y las ideas sobre cómo manejar ciertas situaciones.

Sin la salida del resultado:

import os
os.system("your command here")
 

Con salida del resultado:

import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")
 

El módulo de subproceso descrito anteriormente por Eli es muy poderoso, pero la sintaxis hacer una llamada de sistema estándar de pantano e inspeccionar su salida es innecesariamente prolijo.

La forma más fácil de hacer una llamada al sistema es con el módulo de comandos ( Solo Linux).

> import commands
> commands.getstatusoutput("grep matter alice-in-wonderland.txt")
(0, "'Then it doesn't matter which way you go,' said the Cat.")
 

El primer elemento de la tupla es el código de retorno del proceso. El segundo elemento es su salida estándar (y error estándar, combinado).

Los desarrolladores de Python han "desaprobado" el módulo de comandos, pero eso no significa que no debas usarlo. Solo que ya no lo están desarrollando, lo cual está bien, porque ya es perfecto (en su función pequeña pero importante).

Solo para agregar a la discusión, si incluye el uso de una consola Python, puede llamar a comandos externos desde IPython . Mientras está en el indicador de IPython, puede llamar a los comandos de shell con el prefijo '!'. También puede combinar el código Python con el shell y asignar la salida de los scripts del shell a las variables de Python.

Por ejemplo:

In [9]: mylist = !ls

In [10]: mylist
Out[10]:
['file1',
 'file2',
 'file3',]
 

Después de investigar un poco, tengo el siguiente código que me funciona muy bien. Básicamente imprime stdout y stderr en tiempo real.

stdout_result = 1
stderr_result = 1


def stdout_thread(pipe):
    global stdout_result
    while True:
        out = pipe.stdout.read(1)
        stdout_result = pipe.poll()
        if out == '' and stdout_result is not None:
            break

        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()


def stderr_thread(pipe):
    global stderr_result
    while True:
        err = pipe.stderr.read(1)
        stderr_result = pipe.poll()
        if err == '' and stderr_result is not None:
            break

        if err != '':
            sys.stdout.write(err)
            sys.stdout.flush()


def exec_command(command, cwd=None):
    if cwd is not None:
        print '[' + ' '.join(command) + '] in ' + cwd
    else:
        print '[' + ' '.join(command) + ']'

    p = subprocess.Popen(
        command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
    )

    out_thread = threading.Thread(name='stdout_thread', target=stdout_thread, args=(p,))
    err_thread = threading.Thread(name='stderr_thread', target=stderr_thread, args=(p,))

    err_thread.start()
    out_thread.start()

    out_thread.join()
    err_thread.join()

    return stdout_result + stderr_result
 

Utilice subprocess.call :

 from subprocess import call

# Using list
call(["echo", "Hello", "world"])

# Single string argument varies across platforms so better split it
call("echo Hello world".split(" "))
  

Tiendo a utilizar subproceso junto con shlex (para manejar el escape de cadenas entre comillas):

>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)
 

Plug descarado, escribí una biblioteca para esto: P https://github.com/houqp/shell.py

Es básicamente un contenedor para popen y shlex por ahora. También admite comandos de canalización para que pueda encadenar comandos más fácilmente en Python. Para que pueda hacer cosas como:

ex('echo hello shell.py') | "awk '{print $2}'"
 

Una forma sencilla es utilizar el módulo os :

import os
os.system('ls')
 

Alternativamente, también puede usar el módulo de subproceso:

import subprocess
subprocess.check_call('ls')
 

Si desea que el resultado se almacene en una variable, pruebe:

import subprocess
r = subprocess.check_output('ls')
 

También hay Plumbum

>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad()                                   # Notepad window pops up
u''                                             # Notepad window is closed by user, command returns
 

Uso:

import os

cmd = 'ls -al'

os.system(cmd)
 

os: este módulo proporciona una forma portátil de utilizar la funcionalidad dependiente del sistema operativo.

Para las funciones más os , aquí está la documentación.

Usar la función Popen del módulo Python subprocess es la forma más sencilla de ejecutar comandos de Linux. En eso, la función Popen.communicate() le dará salida a sus comandos. Por ejemplo

import subprocess

..
process = subprocess.Popen(..)   # Pass command and arguments to the function
stdout, stderr = process.communicate()   # Get command output and error
..
 

Aquí están mis dos centavos: en mi opinión, esta es la mejor práctica cuando se trata de comandos externos ...

Estos son los valores de retorno del método de ejecución ...

pass, stdout, stderr = execute(["ls","-la"],"/home/user/desktop")
 

Este es el método de ejecución ...

def execute(cmdArray,workingDir):

    stdout = ''
    stderr = ''

    try:
        try:
            process = subprocess.Popen(cmdArray,cwd=workingDir, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1)
        except OSError:
            return [False, '', 'ERROR : command(' + ' '.join(cmdArray) + ') could not get executed!']

        for line in iter(process.stdout.readline, b''):

            try:
                echoLine = line.decode("utf-8")
            except:
                echoLine = str(line)

            stdout += echoLine

        for line in iter(process.stderr.readline, b''):

            try:
                echoLine = line.decode("utf-8")
            except:
                echoLine = str(line)

            stderr += echoLine

    except (KeyboardInterrupt,SystemExit) as err:
        return [False,'',str(err)]

    process.stdout.close()

    returnCode = process.wait()
    if returnCode != 0 or stderr != '':
        return [False, stdout, stderr]
    else:
        return [True, stdout, stderr]
 

Para Python 3.5+ se recomienda que utilice la función de ejecución run desde el módulo de subproceso . Esto devuelve un objeto CompletedProcess , desde el cual puede obtener fácilmente la salida y el código de retorno.

from subprocess import PIPE, run

command = ['echo', 'hello']
result = run(command, stdout=PIPE, stderr=PIPE, universal_newlines=True)
print(result.returncode, result.stdout, result.stderr)
 

Recomendaría el siguiente método 'run' y nos ayudará a obtener STDOUT, STDERR y salir del estado como diccionario; La persona que llama puede leer el retorno del diccionario mediante el método 'ejecutar' para conocer el estado real del proceso.

  def run (cmd):
       print "+ DEBUG exec({0})".format(cmd)
       p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=True)
       (out, err) = p.communicate()
       ret        = p.wait()
       out        = filter(None, out.split('\n'))
       err        = filter(None, err.split('\n'))
       ret        = True if ret == 0 else False
       return dict({'output': out, 'error': err, 'status': ret})
  #end
 

En Windows puede importar el módulo subprocess y ejecutar comandos externos llamando a subprocess.Popen() , subprocess.Popen().communicate() y subprocess.Popen().wait() de la siguiente manera:

# Python script to run a command line
import subprocess

def execute(cmd):
    """
        Purpose  : To execute a command and return exit status
        Argument : cmd - command to execute
        Return   : exit_code
    """
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    (result, error) = process.communicate()

    rc = process.wait()

    if rc != 0:
        print "Error: failed to execute command:", cmd
        print error
    return result
# def

command = "tasklist | grep python"
print "This process detail: \n", execute(command)
 

Salida:

This process detail:
python.exe                     604 RDP-Tcp#0                  4      5,660 K
 

Uso:

import subprocess

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

Da una salida agradable con la que es más fácil trabajar:

['Filesystem      Size  Used Avail Use% Mounted on',
 '/dev/sda6        32G   21G   11G  67% /',
 'none            4.0K     0  4.0K   0% /sys/fs/cgroup',
 'udev            1.9G  4.0K  1.9G   1% /dev',
 'tmpfs           387M  1.4M  386M   1% /run',
 'none            5.0M     0  5.0M   0% /run/lock',
 'none            1.9G   58M  1.9G   3% /run/shm',
 'none            100M   32K  100M   1% /run/user',
 '/dev/sda5       340G  222G  100G  69% /home',
 '']
 

Para obtener la identificación de red de OpenStack Neutron :

#!/usr/bin/python
import os
netid = "nova net-list | awk '/ External / { print $2 }'"
temp = os.popen(netid).read()  /* Here temp also contains new line (\n) */
networkId = temp.rstrip()
print(networkId)
 

Salida de nova net-list

+--------------------------------------+------------+------+
| ID                                   | Label      | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1      | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External   | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal   | None |
+--------------------------------------+------------+------+
 

Salida de print(networkId)

27a74fcd-37c0-4789-9414-9531b7e3f126
 

Hay muchas formas de llamar a un comando.

• Por ejemplo:

si and.exe necesita dos parámetros. En cmd podemos llamar a sample.exe use esto: and.exe 2 3 y muestra 5 en la pantalla.

Si usamos un script de Python para llamar a and.exe , deberíamos hacer como ...

1. os.system(cmd,...)

   • os.system(("and.exe" + " " + "2" + " " + "3"))

2. os.popen(cmd,...)

   • os.popen(("and.exe" + " " + "2" + " " + "3"))
3. subprocess.Popen(cmd,...)
   • subprocess.Popen(("and.exe" + " " + "2" + " " + "3"))

Es demasiado difícil, por lo que podemos unir cmd con un espacio:

import os
cmd = " ".join(exename,parameters)
os.popen(cmd)
 

Aquí se llama a un comando externo y se devuelve o imprime la salida del comando:

Python Subproceso check_output es bueno para

Ejecute el comando con argumentos y devuelva su salida como una cadena de bytes.

import subprocess
proc = subprocess.check_output('ipconfig /all')
print proc
 

En Linux, en caso de que desee llamar a un comando externo que se ejecutará de forma independiente (seguirá ejecutándose después de que finalice el script de Python), puede usar una cola simple como cola de tareas o el en comando

Un ejemplo con la cola de tareas:

import os
os.system('ts <your-command>')
 

Notas sobre la cola de tareas (ts ):

1. Puede establecer el número de procesos concurrentes que se ejecutarán ("slots") con:

   ts -S <number-of-slots>

2. La instalación de ts no requiere privilegios de administrador. Puede descargarlo y compilarlo desde la fuente con un simple make , agregarlo a su ruta y listo.

He escrito un contenedor para manejar errores y redirigir la salida y otras cosas.

import shlex
import psutil
import subprocess

def call_cmd(cmd, stdout=sys.stdout, quiet=False, shell=False, raise_exceptions=True, use_shlex=True, timeout=None):
    """Exec command by command line like 'ln -ls "/var/log"'
    """
    if not quiet:
        print("Run %s", str(cmd))
    if use_shlex and isinstance(cmd, (str, unicode)):
        cmd = shlex.split(cmd)
    if timeout is None:
        process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, shell=shell)
        retcode = process.wait()
    else:
        process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, shell=shell)
        p = psutil.Process(process.pid)
        finish, alive = psutil.wait_procs([p], timeout)
        if len(alive) > 0:
            ps = p.children()
            ps.insert(0, p)
            print('waiting for timeout again due to child process check')
            finish, alive = psutil.wait_procs(ps, 0)
        if len(alive) > 0:
            print('process {} will be killed'.format([p.pid for p in alive]))
            for p in alive:
                p.kill()
            if raise_exceptions:
                print('External program timeout at {} {}'.format(timeout, cmd))
                raise CalledProcessTimeout(1, cmd)
        retcode = process.wait()
    if retcode and raise_exceptions:
        print("External program failed %s", str(cmd))
        raise subprocess.CalledProcessError(retcode, cmd)
 

Puedes llamarlo así:

cmd = 'ln -ls "/var/log"'
stdout = 'out.txt'
call_cmd(cmd, stdout)
 

Como ejemplo (en Linux):

import subprocess
subprocess.run('mkdir test.dir', shell=True)
 

Esto crea test.dir en el directorio actual. Tenga en cuenta que esto también funciona:

import subprocess
subprocess.call('mkdir test.dir', shell=True)
 

El código equivalente que usa os.system es:

import os
os.system('mkdir test.dir')
 

La mejor práctica sería utilizar subprocesos en lugar de os, con .run como favorito sobre .call. Todo lo que necesita saber sobre el subproceso es aquí . Además, tenga en cuenta que toda la documentación de Python se puede descargar de aquí . Descargué el PDF empaquetado como .zip. Menciono esto porque hay una buena descripción del módulo os en tutorial.pdf (página 81). Además, es un recurso autorizado para los codificadores de Python.

A menudo, uso la siguiente función para comandos externos, y esto es especialmente útil para procesos de larga ejecución . El siguiente método sigue la salida del proceso mientras se está ejecutando y devuelve la salida, genera una excepción si el proceso falla.

Sale si el proceso se realiza utilizando el método poll () en el proceso .

import subprocess,sys

def exec_long_running_proc(command, args):
    cmd = "{} {}".format(command, " ".join(str(arg) if ' ' not in arg else arg.replace(' ','\ ') for arg in args))
    print(cmd)
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    # Poll process for new output until finished
    while True:
        nextline = process.stdout.readline().decode('UTF-8')
        if nextline == '' and process.poll() is not None:
            break
        sys.stdout.write(nextline)
        sys.stdout.flush()

    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise Exception(command, exitCode, output)
 

Puede invocarlo así:

exec_long_running_proc(command = "hive", args=["-f", hql_path])
 

Llamar a un comando externo en Python

Una forma sencilla de llamar a un comando externo es usar os.system(...) . Y esta función devuelve el valor de salida del comando. Pero el inconveniente es que no obtendremos stdout y stderr.

ret = os.system('some_cmd.sh')
if ret != 0 :
    print 'some_cmd.sh execution returned failure'
 

Llamar a un comando externo en Python en segundo plano

subprocess.Popen proporciona más flexibilidad para ejecutar un comando externo en lugar de usar os.system . Podemos iniciar un comando en segundo plano y esperar a que termine. Y después de eso podemos obtener stdout y stderr.

proc = subprocess.Popen(["./some_cmd.sh"], stdout=subprocess.PIPE)
print 'waiting for ' + str(proc.pid)
proc.wait()
print 'some_cmd.sh execution finished'
(out, err) = proc.communicate()
print 'some_cmd.sh output : ' + out
 

Llamar a un comando externo de larga ejecución en Python en segundo plano y detenerse después de un tiempo

Incluso podemos comenzar un proceso de larga ejecución en segundo plano usando subprocess.Popen y matarlo después de algún tiempo una vez que se complete su tarea.

proc = subprocess.Popen(["./some_long_run_cmd.sh"], stdout=subprocess.PIPE)
# Do something else
# Now some_long_run_cmd.sh exeuction is no longer needed, so kill it
os.system('kill -15 ' + str(proc.pid))
print 'Output : ' proc.communicate()[0]
 

Puede ser así de simple:

import os
cmd = "your command"
os.system(cmd)
 

Si necesita llamar a un comando de shell desde un cuaderno de Python (como Jupyter , Zeppelin, Databricks o Google Cloud Datalab) solo puede usar el prefijo ! .

Por ejemplo,

!ls -ilF
 

Utilice el módulo os :

import os
os.system("your command")
 

Por ejemplo,

import os
os.system("ifconfig")
 

Invoke es una herramienta de ejecución de tareas Python (2.7 y 3.4+) y biblioteca. Proporciona una API limpia y de alto nivel para ejecutar comandos de shell

>>> from invoke import run
>>> cmd = "pip install -r requirements.txt"
>>> result = run(cmd, hide=True, warn=True)
>>> print(result.ok)
True
>>> print(result.stdout.splitlines()[-1])
Successfully installed invocations-0.13.0 pep8-1.5.7 spec-1.3.1
 

Escribí una pequeña biblioteca para ayudar con este caso de uso:

https://pypi.org/project/citizenshell/

Se puede instalar usando

pip install citizenshell
 

Y luego se usa de la siguiente manera:

from citizenshell import sh
assert sh("echo Hello World") == "Hello World"
 

Puede separar stdout de stderr y extraer el código de salida de la siguiente manera:

result = sh(">&2 echo error && echo output && exit 13")
assert result.stdout() == ["output"]
assert result.stderr() == ["error"]
assert result.exit_code() == 13
 

Y lo bueno es que no tiene que esperar a que salga el shell subyacente antes de comenzar a procesar la salida:

for line in sh("for i in 1 2 3 4; do echo -n 'It is '; date +%H:%M:%S; sleep 1; done", wait=False)
    print ">>>", line + "!"
 

imprimirá las líneas a medida que estén disponibles gracias a wait = False

>>> It is 14:24:52!
>>> It is 14:24:53!
>>> It is 14:24:54!
>>> It is 14:24:55!
 

Se pueden encontrar más ejemplos en https://github.com/meuter/citizenshell

Como algunas de las respuestas estaban relacionadas con las versiones anteriores de Python o estaban usando el módulo os.system , publico esta respuesta para personas como yo que tienen la intención de usar subprocess en Python 3.5 +. Lo siguiente me ayudó en Linux:

import subprocess

# subprocess.run() returns a completed process object that can be inspected
c = subprocess.run(["ls", "-ltrh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
print(c.stdout.decode('utf-8'))
 

Como se menciona en la documentación , PIPE Los valores son secuencias de bytes y, para mostrarlos correctamente, debe considerarse la decodificación. Para versiones posteriores de Python, text=True y encoding='utf-8' se agregan a kwargs de subprocess.run() .

La salida del código mencionado anteriormente es:

total 113M
-rwxr-xr-x  1 farzad farzad  307 Jan 15  2018 vpnscript
-rwxrwxr-x  1 farzad farzad  204 Jan 15  2018 ex
drwxrwxr-x  4 farzad farzad 4.0K Jan 22  2018 scripts
.... # Some other lines
 

Hay dos formas destacadas en las que uno puede ejecutar comandos de shell utilizando Python. Los dos ejemplos mencionados a continuación muestran cómo se puede obtener el nombre del directorio de trabajo actual (pwd ) usando Python. Puede usar cualquier otro comando de Unix en lugar de pwd .

1.> 1er método: se puede usar el os de Python, y system () funciona desde allí para ejecutar comandos de shell en Python.

import os
os.system('pwd')
 

/Users/siddharth
 

1.> Segundo método: Otra forma es usar el módulo de subproceso y función call () .

import subprocess
subprocess.call('pwd')
 

Salida:

/Users/siddharth
 

Si no usa la entrada del usuario en los comandos, puede usar esto:

from os import getcwd
from subprocess import check_output
from shlex import quote

def sh(command):
    return check_output(quote(command), shell=True, cwd=getcwd(), universal_newlines=True).strip()
 

Y úsalo como

branch = sh('git rev-parse --abbrev-ref HEAD')
 

shell=True generará un shell, por lo que puede usar tubería y esas cosas sh('ps aux | grep python') . Esto es muy muy útil para ejecutar comandos codificados y procesar su salida. El universal_lines=True asegura que la salida se devuelva en una cadena en lugar de binaria.

cwd=getcwd() se asegurará de que el comando se ejecute con el mismo directorio de trabajo que el intérprete. Esto es útil para que los comandos de Git funcionen como el ejemplo de nombre de rama de Git anterior.

Algunas recetas

• memoria libre en megabytes: sh('free -m').split('\n')[1].split()[1]
• espacio libre en / en porcentaje sh('df -m /').split('\n')[1].split()[4][0:-1]
• Carga de CPU sum(map(float, sh('ps -ef -o pcpu').split('\n')[1:])

Pero esto no es seguro para la entrada del usuario, de la documentación:

Consideraciones de seguridad

A diferencia de otras funciones de popen, esta implementación nunca llama implícitamente a un shell del sistema. Esto significa que todos los personajes, incluidos los metacaracteres de shell, se pueden pasar de forma segura al niño procesos. Si el shell se invoca explícitamente, a través de shell = True, es la responsabilidad de la aplicación de garantizar que todos los espacios en blanco y los metacaracteres se citan apropiadamente para evitar la inyección de shell vulnerabilidades.

Cuando se usa shell = True, la función shlex.quote () se puede usar para escapar adecuadamente los espacios en blanco y metacaracteres de shell en cadenas que se utilizarán para construir comandos de shell.

Incluso usando el shlex.quote() , es bueno mantenerse un poco paranoico cuando se usan entradas de usuario en comandos de shell. Una opción es usar un comando codificado para tomar algunos resultados genéricos y filtrar por entrada del usuario. De todos modos, el uso de shell=False se asegurará de que solo se ejecute el proceso exacto que desea ejecutar o obtendrá un error de No such file or directory .

También hay un impacto en el rendimiento de shell=True , de mis pruebas parece un 20% más lento que shell=False (el valor predeterminado).

In [50]: timeit("check_output('ls -l'.split(), universal_newlines=True)", number=1000, globals=globals())
Out[50]: 2.6801227919995654

In [51]: timeit("check_output('ls -l', universal_newlines=True, shell=True)", number=1000, globals=globals())
Out[51]: 3.243950183999914
 

Sultan es un paquete reciente para este propósito. Proporciona algunas ventajas sobre la administración de privilegios de usuario y la adición de mensajes de error útiles.

 from sultan.api import Sultan

with Sultan.load(sudo=True, hostname="myserver.com") as sultan:
  sultan.yum("install -y tree").run()
  

También puede usar subprocess.getoutput() y subprocess.getstatusutput() , que son Funciones de invocación de shell heredado del módulo commands en desuso, es decir:

subprocess.getstatusoutput(cmd)

Retorno (exitcode , output ) de ejecutar cmd en un shell.

subprocess.getoutput(cmd)

Devuelve la salida (stdout y stderr ) de ejecutar cmd en un shell.

Si está escribiendo un script de shell Python y tiene IPython instalado en su sistema, puedes usar la magia de explosión para ejecutar un comando dentro de IPython:

!ls
filelist = !ls
 

Python 3.5+

 import subprocess

p = subprocess.run(["ls", "-ltr"], capture_output=True)
print(p.stdout.decode(), p.stderr.decode())
  

Pruebe en línea

 import subprocess

p = subprocess.run(["ls", "-ltr"], capture_output=True)
print(p.stdout.decode(), p.stderr.decode())
  

Pruebe en línea

os.popen() es la forma más fácil y segura de ejecutar un comando. Puede ejecutar cualquier comando que ejecute en la línea de comando. Además, también podrá capturar la salida del comando utilizando os.popen().read()

Puedes hacerlo así:

import os
output = os.popen('Your Command Here').read()
print (output)
 

Un ejemplo en el que enumera todos los archivos en el directorio actual:

import os
output = os.popen('ls').read()
print (output)
# Outputs list of files in the directory
 

LA MAYORÍA DE LOS CASOS:

Para la mayoría de los casos, un pequeño fragmento de código como este es todo lo que necesitará :

 import subprocess
import shlex

source = "test.txt"
destination = "test_copy.txt"

base = "cp {source} {destination}'"
cmd = base.format(source=source, destination=destination)
subprocess.check_call(shlex.split(cmd))
  

Es limpio y simple .

subprocess.check_call ejecutar comando con argumentos y esperar comando para completar.

shlex.split divide el cmd de la cadena utilizando una sintaxis similar a la del shell

RESTO DE LOS CASOS:

Si esto no funciona para algún comando específico, lo más probable es que tenga un problema con intérpretes de línea de comandos . El sistema operativo eligió el predeterminado que no es adecuado para su tipo de programa o no pudo encontrar uno adecuado en la ruta ejecutable del sistema.

Ejemplo :

Uso del operador de redirección en un sistema Unix

 input_1 = "input_1.txt"
input_2 = "input_2.txt"
output = "merged.txt"
base_command = "/bin/bash -c 'cat {input} > {output}'"

base_command.format(input_1, output=output_1)
subprocess.check_call(shlex.split(base_command))

base_command.format(input_1, output=output_2)
subprocess.check_call(shlex.split(base_command))
  

Como se indica en El zen de Python : Explícito es mejor que implícito

Entonces, si usa una función Python> = 3.6, se vería así:

 import subprocess
import shlex

def run_command(cmd_interpreter: str, command: str) -> None:
    base_command = f"{cmd_interpreter} -c '{command}'"
    subprocess.check_call(shlex.split(base_command)

  

import os
os.system('testing')
 

os es una biblioteca de python, por lo que es muy importante importar al hacer cualquier prueba.