¿Cómo ejecutar el programa Python para siempre?

Necesito ejecutar mi programa Python para siempre en un bucle infinito.

Actualmente lo estoy ejecutando así:

#!/usr/bin/python

import time

# some python code that I want 
# to keep on running


# Is this the right way to run the python program forever?
# And do I even need this time.sleep call?
while True:
    time.sleep(5)

¿Hay alguna forma mejor de hacerlo? ¿O incluso necesito time.sleepllamar? ¿Alguna idea?

Sí, puede utilizar un while True:bucle que nunca se interrumpa para ejecutar código Python de forma continua.

Sin embargo, deberá colocar el código que desea ejecutar continuamente dentro del ciclo:

#!/usr/bin/python

while True:
    # some python code that I want 
    # to keep on running

Además, time.sleepse utiliza para suspender el funcionamiento de un script durante un período de tiempo. Entonces, dado que desea que el suyo se ejecute continuamente, no veo por qué lo usaría.

¿Que tal este?

import signal
signal.pause()

Esto permitirá que su programa duerma hasta que reciba una señal de algún otro proceso (o de sí mismo, en otro hilo), haciéndole saber que es hora de hacer algo.

dormir es una buena manera de evitar la sobrecarga en la CPU

No estoy seguro de si es realmente inteligente, pero suelo usar

while(not sleep(5)):
    #code to execute

El método sleep siempre devuelve None.

Sé que este es un hilo demasiado antiguo, pero ¿por qué nadie mencionó esto?

#!/usr/bin/python3
import asyncio 

loop = asyncio.get_event_loop()
try:
    loop.run_forever()
finally:
    loop.close()

para sistemas operativos que admiten select:

import select

# your code

select.select([], [], [])

Aquí está la sintaxis completa,

#!/usr/bin/python3

import time 

def your_function():
    print("Hello, World")

while True:
    your_function()
    time.sleep(10) #make function to sleep for 10 seconds

Tengo un pequeño script interruptableloop.py que ejecuta el código en un intervalo (predeterminado 1 segundo), envía un mensaje a la pantalla mientras se está ejecutando y captura una señal de interrupción que puede enviar con CTL-C:

#!/usr/bin/python3
from interruptableLoop import InterruptableLoop

loop=InterruptableLoop(intervalSecs=1) # redundant argument
while loop.ShouldContinue():
   # some python code that I want 
   # to keep on running
   pass

Cuando ejecuta el script y luego lo interrumpe, verá esta salida (los puntos se bombean en cada paso del ciclo):

[py36]$ ./interruptexample.py
CTL-C to stop   (or $kill -s SIGINT pid)
......^C
Exiting at  2018-07-28 14:58:40.359331

interruptableLoop.py :

"""
    Use to create a permanent loop that can be stopped ...

    ... from same terminal where process was started and is running in foreground: 
        CTL-C

    ... from same user account but through a different terminal 
        $ kill -2 <pid> 
        or $ kill -s SIGINT <pid>

"""
import signal
import time
from datetime import datetime as dtt
__all__=["InterruptableLoop",]
class InterruptableLoop:
    def __init__(self,intervalSecs=1,printStatus=True):
        self.intervalSecs=intervalSecs
        self.shouldContinue=True
        self.printStatus=printStatus
        self.interrupted=False
        if self.printStatus:
            print ("CTL-C to stop\t(or $kill -s SIGINT pid)")
        signal.signal(signal.SIGINT, self._StopRunning)
        signal.signal(signal.SIGQUIT, self._Abort)
        signal.signal(signal.SIGTERM, self._Abort)

    def _StopRunning(self, signal, frame):
        self.shouldContinue = False

    def _Abort(self, signal, frame):
        raise 

    def ShouldContinue(self):
        time.sleep(self.intervalSecs)
        if self.shouldContinue and self.printStatus: 
            print( ".",end="",flush=True)
        elif not self.shouldContinue and self.printStatus:
            print ("Exiting at ",dtt.now())
        return self.shouldContinue