Llamar a un comando externo en Python

Question

¿Cómo puedo llamar a un comando externo (como si lo hubiera escrito en el shell de Unix o en el símbolo del sistema de Windows) desde dentro de un Python ¿guion?

Answer 1

Mira el módulo de subproceso en la biblioteca estándar:

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

La ventaja de subproceso vs. sistema es que es más flexible (puede obtener stdout, stderr, el código de estado "real", mejor manejo de errores, etc...).

El documentación oficial recomienda el subproceso módulo sobre la alternativa os.system():

El subproceso El módulo proporciona funciones más potentes para generar nuevos procesos y recuperar sus resultados;usar ese módulo es preferible a usar esta función [os.system()].

El "Reemplazo de funciones anteriores con el módulo de subproceso"sección en el subproceso La documentación puede tener algunas recetas útiles.

Las versiones anteriores de Python usan la llamada:

import subprocess
subprocess.call(["ls", "-l"])

Answer 2

A continuación se muestra un resumen de las formas de llamar a programas externos y las ventajas y desventajas de cada una:

1. os.system("some_command with args") pasa el comando y los argumentos al shell de su sistema.Esto es bueno porque de esta manera puedes ejecutar múltiples comandos a la vez y configurar canalizaciones y redirección de entrada/salida.Por ejemplo:

   os.system("some_command < input_file | another_command > output_file")  
   

   Sin embargo, si bien esto es conveniente, debe manejar manualmente el escape de caracteres del shell como espacios, etc.Por otro lado, esto también le permite ejecutar comandos que son simplemente comandos de shell y no programas externos.Ver la documentación.

2. stream = os.popen("some_command with args") hará lo mismo que os.system excepto que le brinda un objeto similar a un archivo que puede usar para acceder a la entrada/salida estándar para ese proceso.Hay otras 3 variantes de popen que manejan la E/S de forma ligeramente diferente.Si pasa todo como una cadena, entonces su comando se pasa al shell;si los pasa como una lista, no tendrá que preocuparse por escapar de nada.Ver la documentación.

3. El Popen clase de la subprocess módulo.Esto está pensado como un reemplazo para os.popen pero tiene la desventaja de ser un poco más complicado por ser tan completo.Por ejemplo, dirías:

   print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
   

   en lugar de:

   print os.popen("echo Hello World").read()
   

   pero es bueno tener todas las opciones en una clase unificada en lugar de 4 funciones popen diferentes.Ver la documentación.

4. El call función de la subprocess módulo.Esto es básicamente como el Popen clase y toma todos los mismos argumentos, pero simplemente espera hasta que el comando se complete y le proporcione el código de retorno.Por ejemplo:

   return_code = subprocess.call("echo Hello World", shell=True)  
   

   Ver la documentación.

5. Si estás en Python 3.5 o posterior, puedes usar el nuevo subprocess.run función, que es muy parecida a la anterior pero aún más flexible y devuelve un CompletedProcess objeto cuando el comando termina de ejecutarse.

6. El módulo del sistema operativo también tiene todas las funciones fork/exec/spawn que tendría en un programa C, pero no recomiendo usarlas directamente.

El subprocess El módulo probablemente debería ser lo que usas.

Finalmente, tenga en cuenta que para todos los métodos en los que pasa el comando final para que el shell lo ejecute como una cadena, usted es responsable de escapar de él. Hay graves implicaciones de seguridad. si no se puede confiar plenamente en alguna parte de la cadena que pasa.Por ejemplo, si un usuario ingresa alguna parte de la cadena.Si no está seguro, utilice estos métodos únicamente con constantes.Para darle una idea de las implicaciones, considere este código:

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

e imagine que el usuario ingresa algo "mi mamá no me amaba && rm -rf /" que podría borrar todo el sistema de archivos.

Answer 3

Normalmente uso:

import subprocess

p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
    print line,
retval = p.wait()

Eres libre de hacer lo que quieras con el stdout datos en la tubería.De hecho, puedes simplemente omitir esos parámetros (stdout= y stderr=) y se comportará como os.system().

Answer 4

Algunos consejos sobre cómo separar el proceso hijo del que llama (iniciar el proceso hijo en segundo plano).

Supongamos que desea iniciar una tarea larga desde un script CGI, es decir, el proceso hijo debería durar más que el proceso de ejecución del script CGI.

El ejemplo clásico de los documentos 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 al subproceso' hasta que finalice longtask.py.Pero no está claro qué sucede después de la línea "algo más de código aquí" del ejemplo.

Mi plataforma de destino era freebsd, pero el desarrollo se realizó en Windows, por lo que primero enfrenté el problema en Windows.

En Windows (win xp), el proceso principal no finalizará hasta que longtask.py haya terminado su trabajo.No es lo que quieres en el 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 Bandera de creación de proceso a la función CreateProcess subyacente en Win API.Si tiene instalado pywin32, puede importar la bandera desde el módulo de proceso win32; de lo contrario, debe definirla usted mismo:

DETACHED_PROCESS = 0x00000008

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

/* ACTUALIZACIÓN 2015.10.27 @eryksun en un comentario a continuación señala que el indicador semánticamente correcto es CREATE_NEW_CONSOLE (0x00000010) */

En freebsd tenemos otro problema:cuando finaliza el proceso principal, también finaliza los procesos secundarios.Y eso tampoco es lo que quieres en el script CGI.Algunos experimentos demostraron 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é los motivos del comportamiento en freebsd.Si alguien lo sabe, por favor comparta sus ideas.Buscar en Google sobre cómo iniciar procesos en segundo plano en Python aún no arroja ninguna luz.

Answer 5

Recomendaría usar el módulo de subproceso en lugar de os.system porque hace que el shell se escape y, por lo tanto, es mucho más seguro: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

Answer 6

import os
cmd = 'ls -al'
os.system(cmd)

Si desea devolver los resultados del comando, puede usar os.popen.Sin embargo, esto está en desuso desde la versión 2.6 a favor de la módulo de subproceso, que otras respuestas han cubierto bien.

Answer 7

import os
os.system("your command")

Tenga en cuenta que esto es peligroso, ya que el comando no se limpia.Dejo que usted busque en Google la documentación relevante sobre los módulos 'os' y 'sys'.Hay un montón de funciones (exec* y spawn*) que harán cosas similares.

Answer 8

Hay muchas bibliotecas diferentes que le permiten llamar comandos externos con Python.Para cada biblioteca, proporcioné una descripción y mostré un ejemplo de cómo llamar a un comando externo.El comando que utilicé como ejemplo es ls -l (enumere todos los archivos).Si desea obtener más información sobre cualquiera de las bibliotecas, he enumerado y vinculado la documentación de cada una de ellas.

Fuentes:

• subproceso: https://docs.python.org/3.5/library/subprocess.html
• shlex: https://docs.python.org/3/library/shlex.html
• sistema operativo: https://docs.python.org/3.5/library/os.html
• sh: https://amoffat.github.io/sh/
• plomo: https://plumbum.readthedocs.io/en/latest/
• esperar: https://pexpect.readthedocs.io/en/stable/
• tela: http://www.fabfile.org/
• enviado: https://github.com/kennethreitz/envoy
• comandos: https://docs.python.org/2/library/commands.html

Estas son todas las bibliotecas:

Con suerte, esto te ayudará a tomar una decisión sobre qué biblioteca usar :)

subproceso

El subproceso le permite llamar comandos externos y conectarlos a sus canales de entrada/salida/error (stdin, stdout y stderr).El subproceso es la opción predeterminada para ejecutar comandos, pero a veces otros módulos son mejores.

subprocess.run(["ls", "-l"]) # Run command
subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output
subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command

sistema operativo

os se utiliza para "funcionalidad dependiente del sistema operativo".También se puede utilizar para llamar comandos externos con os.system y os.popen (Nota:También hay un subproceso.popen).os siempre ejecutará el shell y es una alternativa simple para las personas que no lo necesitan o no saben cómo usarlo. subprocess.run.

os.system("ls -l") # run command
os.popen("ls -l").read() # This will run the command and return any output

sh

sh es una interfaz de subproceso que le permite llamar programas como si fueran funciones.Esto es útil si desea ejecutar un comando varias veces.

sh.ls("-l") # Run command normally
ls_cmd = sh.Command("ls") # Save command as a variable
ls_cmd() # Run command as if it were a function

plomo

plumbum es una biblioteca para programas Python "tipo script".Puede llamar a programas como funciones como en sh.Plumbum es útil si desea ejecutar una canalización sin el shell.

ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run command

esperar

pexpect le permite generar aplicaciones secundarias, controlarlas y encontrar patrones en su salida.Esta es una mejor alternativa al subproceso para comandos que esperan un tty en Unix.

pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo user@example.com:.') # Spawns child application
child.expect('Password:') # When this is the output
child.sendline('mypassword')

tela

fabric es una biblioteca de Python 2.5 y 2.7.Le permite ejecutar comandos de shell locales y remotos.Fabric es una alternativa sencilla para ejecutar comandos en un shell seguro (SSH)

fabric.operations.local('ls -l') # Run command as normal
fabric.operations.local('ls -l', capture = True) # Run command and receive output

enviado

enviado se conoce como "subproceso para humanos".Se utiliza como envoltorio práctico alrededor del subprocess módulo.

r = envoy.run("ls -l") # Run command
r.std_out # get output

comandos

commands contiene funciones contenedoras para os.popen, pero se ha eliminado de Python 3 desde subprocess es una mejor alternativa.

La edición se basó en J.F.El comentario de Sebastián.

Answer 9

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

Answer 10

Consulte también la biblioteca Python "pexpect".

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

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

Answer 11

Si necesita la salida del comando que está llamando, puede usar subproceso.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'

Tenga en cuenta también el caparazón parámetro.

Si el caparazón 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 en la mayoría de los shells del sistema y aún desea un acceso conveniente a otras características del shell, como canalizaciones de shell, comodines de nombres de archivos, expansión de variables de entorno y expansión de ~ al inicio de un usuario. directorio.Sin embargo, tenga en cuenta que el propio Python ofrece implementaciones de muchas características similares a las de un shell (en particular, glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), y shutil).

Answer 12

Con biblioteca estándar

El uso 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 (tuberías, salidas, entradas, etc.) pueden resultar tediosas de construir y escribir.

Nota sobre la versión de Python:Si todavía estás usando Python 2, subproceso.llamada funciona de manera similar.

Consejo profesional: shlex.split puede ayudarle a analizar el comando para run, call, y otra subprocess funciones en caso de que no quieras (¡o no puedas!) 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, utilice plomo:

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

Es lo mejor subprocess envoltura.Es multiplataforma, es decir.Funciona tanto en sistemas Windows como Unix.Instalar por pip install plumbum.

Otra biblioteca popular es sh:

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

Sin embargo, sh dejó de ser compatible con Windows, por lo que no es tan fantástico como solía ser.Instalar por pip install sh.

Answer 13

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

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

Answer 14

Actualizar:

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, la tubería no es tan sencilla.Ver esta pregunta de como.)

He aquí algunos ejemplos de los documentos.

Ejecute un proceso:

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

Aumentar 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 intentarlo Enviado.Es un contenedor para el subproceso, que a su vez tiene como objetivo reemplazar los módulos y funciones más antiguos.Envoy es un subproceso para humanos.

Uso de ejemplo de el archivo Léame:

>>> 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 cosas también:

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

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

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

Answer 15

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

Answer 16

https://docs.python.org/2/library/subprocess.html

...o para un comando muy simple:

import os
os.system('cat testfile')

Answer 17

También hay Plomo

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

Answer 18

os.system Está bien, pero un poco anticuado.Tampoco es muy seguro.En lugar de eso, intenta subprocess. subprocess no llama a sh directamente y por lo tanto es más seguro que os.system.

Obtener mas informacion aquí.

Answer 19

Llamar a un comando externo en Python

Sencillo, uso subprocess.run, que devuelve un CompletedProcess objeto:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

¿Por qué?

A partir de Python 3.5, la documentación recomienda subproceso.ejecutar:

El enfoque recomendado para invocar subprocesos es utilizar la función run() para todos los casos de uso que pueda manejar.Para casos de uso más avanzados, la interfaz Popen subyacente se puede utilizar directamente.

Aquí hay un ejemplo del uso más simple posible, y hace exactamente lo que se le pide:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

run espera a que el comando finalice correctamente y luego devuelve un CompletedProcess objeto.En cambio, puede aumentar TimeoutExpired (si le das un timeout= argumento) o CalledProcessError (si falla y pasas check=True).

Como se puede inferir del ejemplo anterior, stdout y stderr se canalizan a su propio stdout y stderr de forma predeterminada.

Podemos inspeccionar el objeto devuelto y ver el comando que se dio y el código de retorno:

>>> completed_process.args
'python --version'
>>> completed_process.returncode
0

Capturando resultados

Si desea capturar la salida, puede pasar subprocess.PIPE al apropiado stderr o stdout:

>>> cp = subprocess.run('python --version', 
                        stderr=subprocess.PIPE, 
                        stdout=subprocess.PIPE)
>>> cp.stderr
b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n'
>>> cp.stdout
b''

(Me parece interesante y un poco contradictorio que la información de la versión se coloque en stderr en lugar de stdout).

Pasar una lista de comandos

Se podría pasar fácilmente de proporcionar manualmente una cadena de comando (como sugiere la pregunta) a proporcionar una cadena creada mediante programación. No cree cadenas mediante programación. Este es un posible problema de seguridad.Es mejor asumir que no confías en la información.

>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = subprocess.run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\r\n  This is indented.\r\n'

Nota, sólo args debe pasarse posicionalmente.

Firma completa

Aquí está la firma real en la fuente y como se muestra en help(run):

def run(*popenargs, input=None, timeout=None, check=False, **kwargs):

El popenargs y kwargs se dan a la Popen constructor. input puede ser una cadena de bytes (o Unicode, si se especifica codificación o universal_newlines=True) que se canalizará a la entrada estándar del subproceso.

La documentación describe timeout= y check=True mejor de lo que podría:

El argumento del tiempo de espera se pasa a Popen.communicate().Si el tiempo de espera expira, el proceso infantil será asesinado y esperado.La excepción del tiempo de espera se volverá a hacer después de que el proceso infantil haya terminado.

Si el cheque es verdadero, y el proceso sale con un código de salida no distinto de cero, se planteará una excepción llamada ProcessError.Los atributos de esa excepción contienen los argumentos, el código de salida y Stdout y Stderr si fueron capturados.

y este ejemplo para check=True es mejor que uno que se me ocurrió:

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

Firma ampliada

Aquí hay una firma ampliada, como figura en la documentación:

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, 
shell=False, cwd=None, timeout=None, check=False, encoding=None, 
errors=None)

Tenga en cuenta que esto indica que solo la lista de argumentos debe pasarse posicionalmente.Así que pase los argumentos restantes como argumentos de palabras clave.

popen

cuando uso Popen ¿en cambio?Me costaría encontrar un caso de uso basado únicamente en los argumentos.uso directo de Popen Sin embargo, le daría acceso a sus métodos, incluidos poll, 'enviar_señal', 'terminar' y 'esperar'.

Aquí esta la Popen firma como figura en la fuente.Creo que esta es la encapsulación más precisa de la información (a diferencia de help(Popen)):

def __init__(self, args, bufsize=-1, executable=None,
             stdin=None, stdout=None, stderr=None,
             preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
             shell=False, cwd=None, env=None, universal_newlines=False,
             startupinfo=None, creationflags=0,
             restore_signals=True, start_new_session=False,
             pass_fds=(), *, encoding=None, errors=None):

Pero más informativo es el Popen documentación:

subprocess.Popen(args, bufsize=-1, executable=None, stdin=None,
                 stdout=None, stderr=None, preexec_fn=None, close_fds=True,
                 shell=False, cwd=None, env=None, universal_newlines=False,
                 startupinfo=None, creationflags=0, restore_signals=True,
                 start_new_session=False, pass_fds=(), *, encoding=None, errors=None)

Ejecutar un programa hijo en un nuevo proceso.En Posix, la clase usa OS.Execvp (), como comportamiento para ejecutar el programa infantil.En Windows, la clase usa la función Windows CreateProcess ().Los argumentos a Popen son los siguientes.

Comprender la documentación restante sobre Popen quedará como ejercicio para el lector.

Answer 20

Usar:

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 los más os funciones, aquí es la documentación.

Answer 21

Puede ser así de simple:

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

Answer 22

utilizar el módulo del sistema operativo

import os
os.system("your command")

p.ej

import os
os.system("ifconfig")

Answer 23

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

Answer 24

tiendo a usar subproceso Juntos 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)

Answer 25

Aquí hay otra diferencia que no se mencionó anteriormente.

subprocess.Popen ejecuta el <comando> como un subproceso.En mi caso, necesito ejecutar el archivo <a> que necesita comunicarse con otro programa, <b>.

Probé el subproceso y la ejecución fue exitosa.Sin embargo, <b> no pudo comunicarse con <a>.Todo es normal cuando ejecuto ambos desde la terminal.

Uno mas:(NOTA:kwrite se comporta de manera diferente a otras aplicaciones.Si prueba lo siguiente con Firefox, los resultados no serán los mismos).

Si intentas os.system("kwrite"), el flujo del programa se congela hasta que el usuario cierra kwrite.Para superar eso lo intenté en su lugar os.system(konsole -e kwrite).Esta vez el programa continuó fluyendo, pero kwrite se convirtió en el subproceso de la consola.

Cualquiera ejecuta kwrite sin ser un subproceso (es decir,en el monitor del sistema debe aparecer en el borde más izquierdo del árbol).

Answer 26

os.system no le permite almacenar resultados, por lo que si desea almacenar resultados en alguna lista o algo así subprocess.call obras.

Answer 27

me gusta bastante comando_shell por su sencillez.Está construido sobre el módulo de subproceso.

Aquí hay un ejemplo de los documentos:

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

Answer 28

Enchufe descarado, escribí una biblioteca para esto: Phttps://github.com/houqp/shell.py

Por ahora es básicamente un envoltorio para popen y shlex.También admite comandos de canalización para que puedas encadenar comandos más fácilmente en Python.Entonces puedes hacer cosas como:

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

Answer 29

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 dominio

Un ejemplo con cola de tareas:

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

Notas sobre la cola de tareas (ts):

1. Puede establecer la cantidad de procesos simultáneos que se ejecutarán ("ranuras") con:

   ts -S <number-of-slots>

2. Instalación ts No requiere privilegios de administrador.Puedes descargarlo y compilarlo desde el código fuente con un simple make, agrégalo a tu ruta y listo.

Answer 30

Puedes usar Popen y luego podrás verificar el estado del trámite:

from subprocess import Popen

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

Verificar subproceso.Popen.