Bestimmten Code alle n Sekunden ausführen

Question

Gibt es eine Möglichkeit, z. B. zu drucken Hello World! alle n Sekunden? Zum Beispiel würde das Programm jeden Code durchlaufen, den ich habe, und dann, wenn 5 Sekunden vergangen sind (mit time.sleep() ) würde er diesen Code ausführen. Ich würde damit allerdings eine Datei aktualisieren und nicht Hello World drucken.

Zum Beispiel:

startrepeat("print('Hello World')", .01) # Repeats print('Hello World') ever .01 seconds

for i in range(5):
    print(i)

>> Hello World!
>> 0
>> 1
>> 2
>> Hello World!
>> 3
>> Hello World!
>> 4

Answer 1

import threading

def printit():
  threading.Timer(5.0, printit).start()
  print "Hello, World!"

printit()

# continue with the rest of your code

https://docs.python.org/3/library/threading.html#timer-objects

Answer 2

Meine bescheidene Meinung zu diesem Thema, eine Verallgemeinerung der Antwort von Alex Martelli, mit start() und stop() Kontrolle:

from threading import Timer

class RepeatedTimer(object):
    def __init__(self, interval, function, *args, **kwargs):
        self._timer     = None
        self.interval   = interval
        self.function   = function
        self.args       = args
        self.kwargs     = kwargs
        self.is_running = False
        self.start()

    def _run(self):
        self.is_running = False
        self.start()
        self.function(*self.args, **self.kwargs)

    def start(self):
        if not self.is_running:
            self._timer = Timer(self.interval, self._run)
            self._timer.start()
            self.is_running = True

    def stop(self):
        self._timer.cancel()
        self.is_running = False

Verwendung:

from time import sleep

def hello(name):
    print "Hello %s!" % name

print "starting..."
rt = RepeatedTimer(1, hello, "World") # it auto-starts, no need of rt.start()
try:
    sleep(5) # your long-running job goes here...
finally:
    rt.stop() # better in a try/finally block to make sure the program ends!

Merkmale:

• Nur Standardbibliothek, keine externen Abhängigkeiten
• start() y stop() sicher mehrfach aufgerufen werden können, auch wenn der Timer bereits gestartet/gestoppt wurde
• die aufzurufende Funktion kann positionale und benannte Argumente haben
• Sie können ändern interval jederzeit, sie wird nach dem nächsten Lauf wirksam. Dasselbe gilt für args , kwargs und sogar function !

Answer 3

Ersparen Sie sich eine schizophrene Episode und verwenden Sie den Advanced Python Schedu http://pythonhosted.org/APScheduler

Der Code ist so einfach:

from apscheduler.scheduler import Scheduler

sched = Scheduler()
sched.start()

def some_job():
    print "Every 10 seconds"

sched.add_interval_job(some_job, seconds = 10)

....
sched.shutdown()

Answer 4

def update():
    import time
    while True:
        print 'Hello World!'
        time.sleep(5)

Das wird als Funktion ausgeführt. Die while True: lässt es ewig laufen. Sie können sie bei Bedarf jederzeit aus der Funktion herausnehmen.

Answer 5

Hier ist ein einfaches Beispiel, das mit APScheduler 3.00+ :

# note that there are many other schedulers available
from apscheduler.schedulers.background import BackgroundScheduler

sched = BackgroundScheduler()

def some_job():
    print('Every 10 seconds')

# seconds can be replaced with minutes, hours, or days
sched.add_job(some_job, 'interval', seconds=10)
sched.start()

...

sched.shutdown()

Alternativ können Sie auch Folgendes verwenden. Anders als viele der Alternativen führt dieser Timer den gewünschten Code jedes Mal aus n Sekunden genau (unabhängig von der Zeit, die für die Ausführung des Codes benötigt wird). Dies ist also eine gute Option, wenn Sie sich keinen Drift leisten können.

import time
from threading import Event, Thread

class RepeatedTimer:

    """Repeat `function` every `interval` seconds."""

    def __init__(self, interval, function, *args, **kwargs):
        self.interval = interval
        self.function = function
        self.args = args
        self.kwargs = kwargs
        self.start = time.time()
        self.event = Event()
        self.thread = Thread(target=self._target)
        self.thread.start()

    def _target(self):
        while not self.event.wait(self._time):
            self.function(*self.args, **self.kwargs)

    @property
    def _time(self):
        return self.interval - ((time.time() - self.start) % self.interval)

    def stop(self):
        self.event.set()
        self.thread.join()

# start timer
timer = RepeatedTimer(10, print, 'Hello world')

# stop timer
timer.stop()