¿Cómo iniciar un proceso en segundo plano en Python?

Estoy tratando de portar un script de shell a la versión de Python mucho más legible. El script de shell original inicia varios procesos (utilidades, monitores, etc.) en segundo plano con "&". ¿Cómo puedo lograr el mismo efecto en Python? Me gustaría que estos procesos no mueran cuando se completen los scripts de Python. Estoy seguro de que está relacionado con el concepto de demonio de alguna manera, pero no pude encontrar cómo hacerlo fácilmente.

Nota : esta respuesta es menos actual que cuando se publicó en 2009. subprocessAhora se recomienda usar el módulo que se muestra en otras respuestas en los documentos

(Tenga en cuenta que el módulo de subproceso proporciona recursos más potentes para generar nuevos procesos y recuperar sus resultados; es preferible usar ese módulo que usar estas funciones).

Si desea que su proceso comience en segundo plano, puede usarlo system()y llamarlo de la misma manera que lo hizo su script de shell, o puede spawnhacerlo:

import os
os.spawnl(os.P_DETACH, 'some_long_running_command')

(o, alternativamente, puede probar la os.P_NOWAITbandera menos portátil ).

Vea la documentación aquí .

Si bien la solución de jkp funciona, la forma más nueva de hacer las cosas (y la forma en que lo recomienda la documentación) es usar el subprocessmódulo. Para comandos simples es equivalente, pero ofrece más opciones si desea hacer algo complicado.

Ejemplo para su caso:

import subprocess
subprocess.Popen(["rm","-r","some.file"])

Esto se ejecutará rm -r some.fileen segundo plano. Tenga en cuenta que invocar .communicate()el objeto devuelto desde Popense bloqueará hasta que se complete, así que no lo haga si desea que se ejecute en segundo plano:

import subprocess
ls_output=subprocess.Popen(["sleep", "30"])
ls_output.communicate()  # Will block for 30 seconds

Mira la documentación aquí .

Además, un punto de aclaración: "Fondo" tal como lo usa aquí es puramente un concepto de shell; técnicamente, lo que quieres decir es que quieres generar un proceso sin bloquear mientras esperas a que se complete. Sin embargo, he usado "fondo" aquí para referirme al comportamiento similar a un fondo de shell.

Probablemente desee la respuesta a "Cómo llamar a un comando externo en Python" .

El enfoque más simple es usar la os.systemfunción, por ejemplo:

import os
os.system("some_command &")

Básicamente, lo que pase a la systemfunción se ejecutará de la misma manera que si lo hubiera pasado al shell en un script.

Encontré esto aquí :

En Windows (win xp), el proceso padre no finalizará hasta que longtask.pyhaya finalizado 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 el DETACHED_PROCESS Indicador de creación de proceso a la CreateProcessfunción subyacente en win API. 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

Úselo subprocess.Popen()con el close_fds=Trueparámetro, que permitirá que el subproceso generado se separe del proceso de Python y continúe ejecutándose incluso después de que Python salga.

https://gist.github.com/yinjimmy/d6ad0742d03d54518e9f

import os, time, sys, subprocess

if len(sys.argv) == 2:
    time.sleep(5)
    print 'track end'
    if sys.platform == 'darwin':
        subprocess.Popen(['say', 'hello'])
else:
    print 'main begin'
    subprocess.Popen(['python', os.path.realpath(__file__), '0'], close_fds=True)
    print 'main end'

Probablemente quiera comenzar a investigar el módulo os para bifurcar diferentes hilos (abriendo una sesión interactiva y emitiendo ayuda (os)). Las funciones relevantes son fork y cualquiera de las ejecutivas. Para darle una idea de cómo comenzar, coloque algo como esto en una función que realice la bifurcación (la función debe tomar una lista o tupla 'args' como argumento que contiene el nombre del programa y sus parámetros; también puede querer para definir stdin, out y err para el nuevo hilo):

try:
    pid = os.fork()
except OSError, e:
    ## some debug output
    sys.exit(1)
if pid == 0:
    ## eventually use os.putenv(..) to set environment variables
    ## os.execv strips of args[0] for the arguments
    os.execv(args[0], args)

Ambos capturan la salida y se ejecutan en segundo plano con threading

Como se menciona en esta respuesta , si captura la salida con stdout=y luego intenta hacerlo read(), el proceso se bloquea.

Sin embargo, hay casos en los que necesita esto. Por ejemplo, quería lanzar dos procesos que hablan sobre un puerto entre ellos y guardar su stdout en un archivo de registro y stdout.

El threadingmódulo nos permite hacer eso.

Primero, eche un vistazo a cómo hacer la parte de redirección de salida solo en esta pregunta: Python Popen: escriba en stdout y archivo de registro simultáneamente

Luego:

main.py

#!/usr/bin/env python3

import os
import subprocess
import sys
import threading

def output_reader(proc, file):
    while True:
        byte = proc.stdout.read(1)
        if byte:
            sys.stdout.buffer.write(byte)
            sys.stdout.flush()
            file.buffer.write(byte)
        else:
            break

with subprocess.Popen(['./sleep.py', '0'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc1, \
     subprocess.Popen(['./sleep.py', '10'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc2, \
     open('log1.log', 'w') as file1, \
     open('log2.log', 'w') as file2:
    t1 = threading.Thread(target=output_reader, args=(proc1, file1))
    t2 = threading.Thread(target=output_reader, args=(proc2, file2))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

sleep.py

#!/usr/bin/env python3

import sys
import time

for i in range(4):
    print(i + int(sys.argv[1]))
    sys.stdout.flush()
    time.sleep(0.5)

Despues de correr:

./main.py

stdout se actualiza cada 0.5 segundos por cada dos líneas que contienen:

0
10
1
11
2
12
3
13

y cada archivo de registro contiene el registro respectivo para un proceso determinado.

Inspirado por: https://eli.thegreenplace.net/2017/interacting-with-a-long-running-child-process-in-python/

Probado en Ubuntu 18.04, Python 3.6.7.