Iniciando un subproceso en Python

Es posible que esté creando una aplicación y necesite ejecutar otra aplicación. Por ejemplo, es posible que deba abrir el Bloc de notas de Microsoft en Windows por algún motivo o, si está en Linux, es mejor ejecutarlo. grep.

Recomendado: framework para python

Soporte para Python mediante el lanzamiento de aplicaciones externas. subprocess módulo.

Este subprocess  ha sido parte de Python desde Python 2.4.

¡Empecemos!

Conozcamos subprocess.run()

Este método run() que fue añadida en Python 3.5 son la forma recomendada de usar subprocess.

A menudo es útil mirar la definición de una función y comprender mejor cómo funciona.

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

No necesitas saber para qué sirven todos estos parámetros run() En efecto. De hecho, en la mayoría de los casos puede estar satisfecho con saber cuál es la primera configuración y si está habilitada. shell.. el resto de parámetros son útiles para casos de uso muy específicos.

Recomendado: Bibliotecas python recomendadas para machine learning

Ejecutemos algunos comandos comunes de Linux/Mac. ls.. este ls Este comando se usa para listar los archivos en un directorio. De forma predeterminada, se enumeran los archivos del directorio actual.

Ejemplo:

>>> import subprocess
>>> subprocess.run(['ls'])
filename
CompletedProcess(args=['ls'], returncode=0)

también se puede configurar shell=True, ejecute el comando a través del propio shell. En la mayoría de los casos, no necesita hacer esto, pero sí necesita más control sobre el proceso, lo cual es útil para acceder a shellpipes y comodines.

Pero, ¿qué sucede si desea conservar la salida del comando para su uso posterior? ¡Ahora veamos cómo!

Obtener una salida

A menudo necesita obtener el resultado de un proceso externo y usar esos datos para hacer algo. Con run() puedes configurar capture_output el parámetro es verdadero:

>>> subprocess.run(['ls', '-l'], capture_output=True)
CompletedProcess(args=['ls', '-l'], returncode=0, 
    stdout=b'total 40n-rw-r--r--@ 1 michael  staff  17083 Apr 15 13:17 some_filen', 
    stderr=b'')

No es muy útil porque no estoy guardando la salida devuelta en una variable. Continúe y actualice el código para que sea accesible con stdout.

Clase subprocess.Popen()

Este subprocess.Popen() La clase ha existido durante subprocess  en sí ha sido agregado. Se ha actualizado varias veces en Python 3. Si desea obtener más información sobre algunos de estos cambios, puede leerlos aquí.

tu puedes pensar Popen en versión de bajo nivel run()..si tiene un caso de uso raro run() Si no puedes manejarlo, debes usar Popen Al lugar.

Ahora veamos cómo ejecutar el comando de la sección anterior. Popen:

>>> import subprocess
>>> subprocess.Popen(['ls', '-l'])
<subprocess.Popen object at 0x10f88bdf0>
>>> total 40
-rw-r--r--@ 1 michael  staff  17083 Apr 15 13:17 some_file

>>>

La sintaxis es casi la misma, solo la usas. Popen excluir eso run()..

Aquí se explica cómo obtener el código de retorno de un proceso externo:

>>> process = subprocess.Popen(['ls', '-l'])
>>> total 40
-rw-r--r--@ 1 michael  staff  17083 Apr 15 13:17 some_file

>>> return_code = process.wait()
>>> return_code
0
>>>

Una especie de return_code de 0 Esto significa que el programa terminó normalmente. Si abre el programa con una interfaz de usuario como el Bloc de notas de Microsoft, deberá volver a la sesión REPL o IDLE para agregarlo. process.wait() Cable. Esto se debe a que el Bloc de notas aparece en la parte superior del programa.

si no agregar process.wait() Al llamar a un script, no puede capturar el código de retorno después de cerrar manualmente un programa de interfaz de usuario que ya se haya iniciado. subprocess..

puedes usar tu process Manejar el ID del proceso de acceso pid Modalidad. También puede llamarlo para matar el proceso (SIGKILL) process.kill() o salir con (SIGTERM) process.terminate()..

Método subprocess.Popen.communicate()

Es posible que necesite comunicarse con el proceso generado. Puede usar Popen.communicate() es una forma de enviar datos a un proceso y extraerlos.

En esta sección usaremos communicate() para extraer datos, communicate() para obtener información ifconfig. Se puede usar para obtener información de la tarjeta de red de la computadora en Linux o Mac. en Windows ipconfig tenga en cuenta que este comando varía según el sistema operativo en un carácter.

El código se muestra a continuación:

>>> import subprocess
>>> cmd = ['ifconfig']
>>> process = subprocess.Popen(cmd, 
                               stdout=subprocess.PIPE,
                               encoding='utf-8')
>>> data = process.communicate()
>>> print(data[0])
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
    options=1203<RXCSUM,TXCSUM,TXSTATUS,SW_TIMESTAMP>
    inet 127.0.0.1 netmask 0xff000000 
    inet6 ::1 prefixlen 128 
    inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 
    nd6 options=201<PERFORMNUD,DAD>
gif0: flags=8010<POINTOPOINT,MULTICAST> mtu 1280
stf0: flags=0<> mtu 1280
XHC20: flags=0<> mtu 0
# -------- truncated -------

Leer y escribir stdin cuando stdout

Suponga que la tarea de hoy es examinar los procesos que se ejecutan en un servidor Linux y crear un programa de Python para generar los procesos que se ejecutan en Python.

Se puede utilizar para obtener una lista de procesos en ejecución ps -ef usualmente usas este comando para «canalizar». Otra utilidad de línea de comandos de Linux para buscar archivos de cadenas(grep).

Los comandos completos de Linux que puede usar incluyen:

ps -ef | grep python

Sin embargo, debe convertir este comando a Python usando subprocess módulo.

Aquí hay una manera de hacerlo:

import subprocess

cmd = ['ps', '-ef']
ps = subprocess.Popen(cmd, stdout=subprocess.PIPE)

cmd = ['grep', 'python']
grep = subprocess.Popen(cmd, stdin=ps.stdout, stdout=subprocess.PIPE,
                        encoding='utf-8')

ps.stdout.close()
output, _ = grep.communicate()
python_processes = output.split('n')
print(python_processes)

Palabras finales

Los módulos(subprocess) son muy genéricos y proporcionan una rica interfaz para manipular procesos externos.

En este artículo, aprendiste:

  • subprocess.run()
  • subprocess.Popen()
  • subprocess.Popen.communicate()
  • Leer y escribir stdin cuando stdout

Subprocess python

El módulo subprocess en Python es una biblioteca incorporada que permite iniciar y controlar procesos secundarios desde un programa principal. Proporciona una forma sencilla de interactuar con comandos de consola o ejecutar otros programas dentro de un script de Python. Esto es especialmente útil cuando se necesita ejecutar comandos externos o realizar tareas que no se pueden realizar directamente en Python.

Una de las características más destacadas de subprocess es la capacidad de capturar la salida de un proceso secundario y redirigirla al programa principal. Esto permite obtener información relevante generada por el proceso secundario y utilizarla dentro del script de Python. Además, también es posible pasar argumentos al proceso secundario y recibir su salida como texto o como un objeto de tipo bytes.

Otra ventaja de utilizar subprocess es que proporciona un mayor control sobre el proceso secundario en comparación con otras formas de ejecutar comandos de consola en Python, como el módulo os. Esto incluye la capacidad de esperar a que el proceso secundario termine antes de continuar con la ejecución del programa principal y la posibilidad de enviar señales al proceso secundario para controlar su comportamiento.

Es importante mencionar que subprocess también ofrece mecanismos para manejar errores y excepciones que pueden ocurrir durante la ejecución del proceso secundario. Esto permite detectar y manejar posibles fallas, como comandos incorrectos o problemas de comunicación con el proceso secundario. Además, el módulo también proporciona funciones para trabajar con tuberías (pipes) y redireccionar la entrada y salida estándar del proceso secundario.

Python subprocess

Python subprocess es un módulo que permite iniciar y controlar subprocesos desde un programa de Python. Con este módulo, es posible ejecutar comandos en la línea de comandos y obtener su salida o enviarles entrada a través de tuberías. Esta funcionalidad es especialmente útil cuando se necesita interactuar con programas externos desde un script de Python.

Una de las principales ventajas de utilizar subprocess en Python es que permite ejecutar comandos externos de manera segura, evitando vulnerabilidades como la ejecución de comandos arbitrarios o la inyección de código malicioso. Además, ofrece una interfaz más sencilla y completa que otras opciones disponibles en el lenguaje.

Para iniciar un subproceso en Python, se utiliza la función subprocess.run(), la cual recibe como argumento una lista que contiene el comando y sus argumentos. Por ejemplo, para ejecutar el comando «ls -l» en un sistema Unix, se puede utilizar el siguiente código:

import subprocess

resultado = subprocess.run([«ls», «-l»], capture_output=True, text=True)

En este ejemplo, la función subprocess.run() ejecuta el comando «ls -l» y guarda el resultado en la variable «resultado». El parámetro capture_output=True indica que se debe capturar la salida del comando, mientras que text=True especifica que se debe devolver la salida como una cadena de texto en lugar de bytes.

Una vez ejecutado el subproceso, se puede acceder a su salida estándar, salida de error y código de salida a través de los atributos stdout, stderr y returncode respectivamente. Por ejemplo, para obtener la salida estándar del comando ejecutado anteriormente, se puede utilizar la siguiente línea de código:

salida = resultado.stdout

Con el módulo subprocess, es posible iniciar subprocesos de forma sencilla y segura, interactuar con ellos y obtener sus resultados de manera eficiente. Esto hace que sea una herramienta muy útil para automatizar tareas que requieren ejecutar comandos externos desde un programa de Python.

Python subprocess run

Python proporciona un módulo llamado subprocess que nos permite iniciar y controlar subprocesos desde nuestro código. Una de las funciones más utilizadas es run(), que nos permite ejecutar un comando en la terminal y obtener su salida.

Para utilizar subprocess.run(), simplemente debemos pasarle como argumento una cadena con el comando que queremos ejecutar. Por ejemplo, si queremos ejecutar el comando «ls» en Linux, podemos hacerlo de la siguiente manera:

resultado = subprocess.run(«ls», capture_output=True, text=True)

En este caso, el argumento capture_output=True nos permite capturar la salida del comando, y el argumento text=True nos asegura que la salida se devuelve como una cadena de texto.

Una vez que hemos ejecutado el comando, podemos acceder a la salida utilizando el atributo stdout del objeto resultado. Por ejemplo, si queremos imprimir la salida en la consola, podemos hacerlo de la siguiente manera:

print(resultado.stdout)

Popen ia

El módulo popen ia en Python es una herramienta poderosa para iniciar un subproceso desde un programa Python. Este módulo nos permite ejecutar comandos externos y obtener la salida resultante en nuestra aplicación. Con popen ia, podemos automatizar tareas que requieren la ejecución de comandos en la línea de comandos, como la manipulación de archivos, el procesamiento de datos o la interacción con otros programas.

Una de las ventajas de utilizar popen ia es que nos permite comunicarnos con el subproceso de manera bidireccional, lo que significa que podemos enviarle datos y recibir la salida resultante. Esto nos da un mayor control sobre el proceso y nos permite manejar cualquier error o excepción que pueda ocurrir durante la ejecución. Además, popen ia nos permite redirigir la entrada y salida estándar del subproceso, lo que nos brinda flexibilidad para interactuar con otros programas.

Para utilizar popen ia, primero debemos importar el módulo subprocess. A continuación, podemos usar la función popen para iniciar un subproceso y obtener un objeto de tipo Popen. Luego, podemos utilizar los métodos y atributos de este objeto para interactuar con el subproceso. Por ejemplo, podemos usar el método communicate() para enviar datos al subproceso y esperar a que termine su ejecución.

En resumen, el módulo popen ia en Python es una herramienta esencial para iniciar subprocesos y ejecutar comandos externos desde nuestra aplicación. Nos brinda control y flexibilidad en la comunicación con el subproceso, permitiéndonos automatizar tareas complejas y mejorar la eficiencia de nuestro programa. Si necesitas ejecutar comandos externos en Python, popen ia es una opción confiable y poderosa.

Subprocess popen

En Python, subprocess.Popen es una función que se utiliza para iniciar un subproceso y comunicarse con él desde el programa principal. Permite ejecutar comandos en la línea de comandos y obtener su salida o enviarles entrada desde el programa en Python.

La función subprocess.Popen crea un objeto Popen que representa el subproceso en ejecución. Puedes especificar el comando que deseas ejecutar como argumento de la función, ya sea como una cadena o una lista de cadenas. Además, puedes proporcionar argumentos adicionales para configurar el comportamiento del subproceso.

Una vez que tienes el objeto Popen, puedes usar sus métodos para interactuar con el subproceso. Por ejemplo, puedes utilizar el método communicate() para enviar y recibir datos desde el subproceso. Este método devuelve una tupla con la salida estándar y la salida de error del subproceso.

Es importante destacar que subprocess.Popen ofrece una forma segura y flexible de ejecutar comandos externos desde Python. Además de ejecutar comandos simples, también es posible redirigir la entrada y salida estándar del subproceso, así como gestionar los errores y excepciones que puedan ocurrir durante la ejecución.

Subprocess run

El módulo «subprocess run» es una herramienta poderosa en Python que permite iniciar y controlar subprocesos en un programa. Subprocess run ofrece una interfaz sencilla y flexible para ejecutar comandos externos y comunicarse con ellos desde el programa principal.

Una de las características más destacadas de subprocess run es su capacidad para ejecutar comandos en paralelo y esperar a que terminen. Esto significa que podemos iniciar múltiples subprocesos al mismo tiempo y continuar la ejecución del programa principal sin bloquearlo. Además, subprocess run proporciona una forma conveniente de capturar y gestionar la salida de los subprocesos, permitiéndonos procesarla o mostrarla en tiempo real.

Otra ventaja de subprocess run es su capacidad para manejar errores y excepciones de manera eficiente. Si un subproceso lanza una excepción, podemos capturarla y manejarla adecuadamente en nuestro programa principal, evitando que cause interrupciones o errores inesperados.

Además de ejecutar comandos externos, subprocess run también ofrece la posibilidad de interactuar con ellos enviándoles datos de entrada y leyendo su salida. Esto es especialmente útil cuando necesitamos automatizar tareas que requieren interacción con programas externos.

Py subprocess

Py subprocess es una biblioteca de Python que permite ejecutar y controlar subprocesos en el sistema operativo. Esto significa que podemos ejecutar programas externos desde nuestro script de Python y comunicarnos con ellos.

Una de las ventajas de utilizar py subprocess es que nos brinda la capacidad de ejecutar comandos de la línea de comandos y capturar su salida. Esto es útil cuando necesitamos automatizar tareas que normalmente se realizarían manualmente en la terminal.

Otra característica interesante de py subprocess es que nos permite interactuar con el subproceso en tiempo real. Podemos enviar datos de entrada al subproceso, recibir su salida y también controlar su ejecución. Esto es especialmente útil cuando necesitamos trabajar con programas que requieren interacción, como por ejemplo, una aplicación de línea de comandos.

Además de ejecutar comandos de la línea de comandos, py subprocess también nos permite ejecutar programas externos, pasando argumentos y opciones. Esto significa que podemos llamar a otros scripts de Python o ejecutables de diferentes lenguajes de programación y manipular sus resultados dentro de nuestro script principal.

En resumen, py subprocess es una herramienta poderosa que nos brinda la capacidad de ejecutar y controlar subprocesos en Python. Su flexibilidad y facilidad de uso la convierten en una elección popular para tareas de automatización y comunicación con programas externos.

Python popen

Comando Descripción
popen(cmd, mode=’r’, buffering=-1) Abre un nuevo subproceso y devuelve un objeto de tipo Popen que permite el control del proceso y la comunicación con él.
popen.communicate(input=None) Interactúa con el proceso abierto, enviando datos de entrada y recopilando la salida y los errores. Devuelve una tupla con la salida y los errores.
popen.wait() Espera a que el proceso termine y devuelve el código de salida del proceso.
popen.terminate() Termina el proceso abierto.

Popen python

Método Descripción
popen(command, mode=0, buffering=-1) Abre un nuevo subproceso y devuelve un objeto de tipo Popen que representa la comunicación con dicho subproceso.
Popen.communicate(input=None) Envía datos al subproceso y recibe su salida. Si se proporciona el parámetro «input», se enviará al subproceso como entrada. Devuelve una tupla con la salida y el error estándar del subproceso.
Popen.wait() Espera a que el subproceso termine. Devuelve el código de salida del subproceso.
Popen.terminate() Termina el subproceso de forma abrupta.
Popen.kill() Envía una señal de terminación al subproceso.

Python subprocess popen

Método Descripción
popen(args, …, *, stdin, stdout, stderr, …) Abre un nuevo subproceso con los argumentos especificados y devuelve un objeto Popen.
communicate(input=None, timeout=None) Interactúa con el subproceso: envía datos de entrada, recibe la salida y el error, y espera a que el subproceso termine.
wait(timeout=None) Espera a que el subproceso termine y devuelve el código de salida.
poll() Comprueba si el subproceso ha terminado. Devuelve el código de salida si el subproceso ha finalizado, o None si no.
terminate() Termina el subproceso.
kill() Envía una señal SIGKILL al subproceso, terminándolo abruptamente.
stdin El flujo de entrada del subproceso.
stdout El flujo de salida del subproceso.
stderr El flujo de error del subproceso.

Subprocess run python

Método Descripción
subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None) Ejecuta el comando especificado en el argumento «args» como un subproceso. Devuelve un objeto CompletedProcess con información sobre la ejecución del subproceso.
args Una cadena o una secuencia de cadenas que representa el comando a ejecutar y sus argumentos.
stdin Especifica la entrada del subproceso. Puede ser un objeto de archivo abierto o uno de los valores especiales: subprocess.PIPE, subprocess.DEVNULL o subprocess.DEFINED_STDIN.
input Especifica la entrada del subproceso como una cadena de texto. Si se proporciona, reemplaza a «stdin».
stdout Especifica la salida estándar del subproceso. Puede ser un objeto de archivo abierto o uno de los valores especiales: subprocess.PIPE, subprocess.DEVNULL o subprocess.DEFINED_STDOUT.
stderr Especifica la salida de error estándar del subproceso. Puede ser un objeto de archivo abierto o uno de los valores especiales: subprocess.PIPE, subprocess.DEVNULL o subprocess.DEFINED_STDERR.
capture_output Si se establece en True, redirige tanto la salida estándar como la salida de error estándar al atributo «stdout» de la instancia CompletedProcess.
shell Especifica si el comando debe ejecutarse a través de una shell. Si se establece en True, el comando se pasa a una shell para su ejecución.
cwd Establece el directorio de trabajo actual para el subproceso.
timeout Especifica el tiempo máximo de ejecución permitido para el subproceso en segundos.
check Si se establece en True, lanza una excepción CalledProcessError si el subproceso devuelve un código de salida distinto de cero.
encoding Especifica la codificación a utilizar para decodificar la salida del subproceso.
errors Especifica cómo manejar errores de codificación al decodificar la salida del subproceso.
text Si se establece en True, la salida del subproceso se devuelve como una cadena de texto en lugar de bytes.
env Un diccionario que contiene variables de entorno adicionales a establecer para el subproceso.
universal_newlines Si se establece en True, las entradas y salidas del subproceso se tratan como cadenas de texto con saltos de línea universales.

Subprocess.run python

Comando Descripción
args Lista o cadena que contiene el comando y los argumentos a ejecutar
stdin Entrada estándar que se proporciona al subproceso
stdout Salida estándar generada por el subproceso
stderr Salida de error generada por el subproceso
shell Indica si se debe ejecutar el comando a través de la shell del sistema operativo
check Si es True, lanza una excepción si la llamada al subproceso devuelve un código de salida distinto de cero
input Cadena que se proporciona como entrada al subproceso
encoding Especifica la codificación de caracteres a utilizar en la entrada y salida del subproceso
timeout Indica el tiempo máximo en segundos que el subproceso puede ejecutarse antes de ser terminado

Python subprocess.run

Método Descripción
subprocess.run(command, args, stdin, stdout, stderr, capture_output, shell) Ejecuta un comando en un subproceso.
command El comando que se va a ejecutar.
args Argumentos adicionales para el comando.
stdin Redirige la entrada estándar del subproceso.
stdout Redirige la salida estándar del subproceso.
stderr Redirige la salida de error estándar del subproceso.
capture_output Captura la salida estándar y de error en variables separadas.
shell Indica si se debe ejecutar el comando a través de una shell.

Python subprocess example

Ejemplo de subproceso en Python
Descripción

Este ejemplo muestra cómo iniciar un subproceso en Python utilizando el módulo subprocess.

Código

import subprocess

# Iniciar un subproceso y capturar su salida

resultado = subprocess.run(["ls", "-l"], capture_output=True, text=True)

# Imprimir la salida del subproceso

print(resultado.stdout)

Explicación

En este ejemplo, utilizamos la función run() del módulo subprocess para iniciar un subproceso. Le pasamos como argumento una lista que representa el comando y sus argumentos, en este caso «ls» y «-l». También especificamos los argumentos capture_output=True y text=True para capturar la salida del subproceso y decodificarla como texto.

El resultado del subproceso se almacena en la variable resultado. Podemos acceder a la salida del subproceso utilizando resultado.stdout.

Run subprocess python

Título Descripción
Introducción a subprocess en Python Aprenda qué es subprocess y cómo puede ser utilizado para ejecutar comandos externos desde Python.
Ejecutando un comando básico Aprenda cómo utilizar la función run() de subprocess para ejecutar un comando básico y obtener su salida.
Manejo de argumentos y opciones Aprenda cómo pasar argumentos y opciones a un comando ejecutado con subprocess.
Redireccionamiento de entrada y salida Descubra cómo redirigir la entrada y salida de un comando ejecutado con subprocess.
Capturando la salida y el código de retorno Aprenda cómo capturar la salida y el código de retorno de un comando ejecutado con subprocess.
Esperando la finalización del subproceso Aprenda cómo esperar a que un subproceso finalice su ejecución antes de continuar con el programa principal.
Controlando el entorno del subproceso Descubra cómo controlar el entorno en el que se ejecuta un subproceso utilizando subprocess.
Manejo de errores y excepciones Aprenda cómo manejar errores y excepciones al utilizar subprocess en Python.
Mejores prácticas y consideraciones de seguridad Explore algunas mejores prácticas y consideraciones de seguridad al utilizar subprocess en Python.

Python subprocess ejemplos

Ejemplo Descripción
Ejemplo 1 Inicio de un subproceso y obtención de la salida estándar.
Ejemplo 2 Inicio de un subproceso y redirección de la entrada y salida estándar.
Ejemplo 3 Inicio de un subproceso y espera a que termine su ejecución.
Ejemplo 4 Inicio de un subproceso y manejo de errores.
Ejemplo 5 Inicio de un subproceso y comunicación mediante tuberías.

5 comentarios en «Iniciando un subproceso en Python»

  1. ¿Cuál es mejor: subprocess.run() o subprocess.Popen()? ¡Opiniones, por favor! 🤔🔥

  2. ¡Creo que subprocess.run() simplifica la vida! ¿Pero y la Popen()? 🤔

    • ¡Totalmente de acuerdo contigo! ¡subprocess.run() es mucho más fácil de usar que Popen! Menos lío y más eficiencia. ¡Adiós a los dolores de cabeza innecesarios! ¡Subprocess.run() for the win! 🙌

  3. ¿Es realmente subprocess.run() más fácil de usar que subprocess.Popen()? ¡Opiniones! 🤔

  4. ¿Subprocess.run() o subprocess.Popen()? ¡Dinos cuál prefieres y por qué! 🤔🔥

Los comentarios están cerrados.