Який найкращий спосіб багаторазово виконувати функцію кожні х секунд?

Я хочу неодноразово виконувати функцію в Python кожні 60 секунд назавжди (як і NSTimer у Objective C). Цей код буде виконуватись як демон і фактично схожий на виклик сценарію python щохвилини за допомогою крона, але не вимагаючи, щоб його встановлював користувач.

У цьому питанні про хрон, реалізований у Python , з'являється рішення, що ефективно просто спати () протягом x секунд. Мені не потрібна така розширена функціональність, тому, можливо, щось подібне спрацювало б

while True:
    # Code executed here
    time.sleep(60)

Чи є передбачувані проблеми з цим кодом?

Якщо ваша програма не має цикл подій вже, використовуйте SCHED модуль, який реалізує планувальник подій загального призначення.

import sched, time
s = sched.scheduler(time.time, time.sleep)
def do_something(sc): 
    print("Doing stuff...")
    # do your stuff
    s.enter(60, 1, do_something, (sc,))

s.enter(60, 1, do_something, (s,))
s.run()

Якщо ви вже використовуєте бібліотеку циклу події , як asyncio, trio, tkinter, PyQt5, gobject, kivy, і багато інших - просто запланувати завдання з допомогою методів існуючої бібліотеки циклу обробки подій, замість.

Заблокуйте часовий цикл на системному годиннику так:

import time
starttime = time.time()
while True:
    print "tick"
    time.sleep(60.0 - ((time.time() - starttime) % 60.0))

Ви можете розглянути Twisted, який є мережевою бібліотекою Python, що реалізує шаблон реактора .

from twisted.internet import task, reactor

timeout = 60.0 # Sixty seconds

def doWork():
    #do work here
    pass

l = task.LoopingCall(doWork)
l.start(timeout) # call every sixty seconds

reactor.run()

Хоча "в той час як True: сон (60)", ймовірно, спрацює. Twisted, мабуть, вже реалізує багато функцій, які вам з часом знадобляться (демонізація, ведення журналів чи обробка винятків, як вказував bobince) і, ймовірно, буде більш надійним рішенням

Якщо ви хочете періодично виконувати свою функцію, замість блокування нескінченного циклу я б використовував різьбовий таймер. Таким чином ваш код може продовжувати працювати і виконувати інші завдання, і все ще виконувати вашу функцію називається кожні n секунд Я дуже часто використовую цю техніку для друку інформації про прогрес у довгих завданнях процесора / диска / мережі.

Ось код, який я опублікував у подібному питанні, з контролем start () та stop ():

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

Використання:

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!

Особливості:

• Лише стандартна бібліотека, ніяких зовнішніх залежностей
• start()і stop()безпечно дзвонити кілька разів, навіть якщо таймер уже запущений / зупинений
• Функція, яку потрібно викликати, може мати позиційні та іменні аргументи
• Ви можете змінити його intervalбудь-коли, це буде ефективно після наступного запуску. Те саме args, kwargsі навіть function!

Найпростіший спосіб я вважаю:

import time

def executeSomething():
    #code here
    time.sleep(60)

while True:
    executeSomething()

Таким чином ваш код виконується, потім він чекає 60 секунд, потім він знову виконується, чекає, виконує і т.д. ... Не потрібно ускладнювати речі: D

import time, traceback

def every(delay, task):
  next_time = time.time() + delay
  while True:
    time.sleep(max(0, next_time - time.time()))
    try:
      task()
    except Exception:
      traceback.print_exc()
      # in production code you might want to have this instead of course:
      # logger.exception("Problem while executing repetitive task.")
    # skip tasks if we are behind schedule:
    next_time += (time.time() - next_time) // delay * delay + delay

def foo():
  print("foo", time.time())

every(5, foo)

Якщо ви хочете зробити це, не блокуючи залишився код, ви можете скористатися цим, щоб він міг працювати у власній темі:

import threading
threading.Thread(target=lambda: every(5, foo)).start()

Це рішення поєднує кілька особливостей, які рідко зустрічаються в інших рішеннях:

• Поводження з винятками : Наскільки це можливо на цьому рівні, винятки обробляються належним чином, тобто отримують реєстрацію для цілей налагодження без припинення нашої програми.
• Ніякого ланцюжка: загальна ланцюгова реалізація (для планування наступної події), яку ви знайдете у багатьох відповідях, крихка в тому аспекті, що якщо щось піде не так у межах механізму планування ( threading.Timerабо будь-якого іншого), це припинить ланцюг. Подальші страти не відбудуться, навіть якщо причина проблеми вже виправлена. Простий цикл і очікування з простим sleep()набагато надійнішим порівняно.
• Без дрейфу: моє рішення відстежує точний час, у який він повинен працювати. Немає дрейфу залежно від часу виконання (як у багатьох інших рішень).
• Пропуск: Моє рішення пропустить завдання, якщо одне виконання зайняло занадто багато часу (наприклад, робити X кожні п’ять секунд, але на X потрібно 6 секунд). Це стандартна поведінка з крон (і з поважної причини). Багато інших рішень потім просто виконують завдання кілька разів поспіль без жодної затримки. У більшості випадків (наприклад, завдання з очищення) цього не хочеться. Якщо це буде завгодно, просто використовувати next_time += delayзамість цього.

Ось оновлення коду від MestreLion, що дозволяє уникнути дрейфування з часом.

Клас RepeatedTimer тут викликає задану функцію кожні "інтервали" секунд, як вимагає ОП; графік не залежить від того, скільки часу функція потребує виконання. Мені подобається це рішення, оскільки воно не має зовнішніх залежностей від бібліотеки; це просто чистий пітон.

import threading 
import time

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.next_call = time.time()
    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.next_call += self.interval
      self._timer = threading.Timer(self.next_call - time.time(), self._run)
      self._timer.start()
      self.is_running = True

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

Використання зразка (скопійовано з відповіді MestreLion):

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!

Я зіткнувся з подібною проблемою деякий час назад. Можливо, http://cronus.readthedocs.org може допомогти?

Для версії v0.2 працює наступний фрагмент

import cronus.beat as beat

beat.set_rate(2) # 2 Hz
while beat.true():
    # do some time consuming work here
    beat.sleep() # total loop duration would be 0.5 sec

Основна відмінність між цим і кроном полягає в тому, що виняток вб'є демона назавжди. Можливо, ви захочете скористатись виловлювачем та реєстратором винятків.

Одна можлива відповідь:

import time
t=time.time()

while True:
    if time.time()-t>10:
        #run your task here
        t=time.time()

Я закінчив користуватися модулем розкладу . API приємний.

import schedule
import time

def job():
    print("I'm working...")

schedule.every(10).minutes.do(job)
schedule.every().hour.do(job)
schedule.every().day.at("10:30").do(job)
schedule.every(5).to(10).minutes.do(job)
schedule.every().monday.do(job)
schedule.every().wednesday.at("13:15").do(job)
schedule.every().minute.at(":17").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

Я використовую метод Tkinter after (), який не «вкрадає гру» (як модуль планування, який був представлений раніше), тобто дозволяє іншим речам працювати паралельно:

import Tkinter

def do_something1():
  global n1
  n1 += 1
  if n1 == 6: # (Optional condition)
    print "* do_something1() is done *"; return
  # Do your stuff here
  # ...
  print "do_something1() "+str(n1)
  tk.after(1000, do_something1)

def do_something2(): 
  global n2
  n2 += 1
  if n2 == 6: # (Optional condition)
    print "* do_something2() is done *"; return
  # Do your stuff here
  # ...
  print "do_something2() "+str(n2)
  tk.after(500, do_something2)

tk = Tkinter.Tk(); 
n1 = 0; n2 = 0
do_something1()
do_something2()
tk.mainloop()

do_something1()і do_something2()може працювати паралельно та з будь-якою інтервальною швидкістю. Тут другий буде виконуватися вдвічі швидше. Зауважте також, що я використовував простий лічильник як умову для припинення будь-якої функції. Ви можете використовувати будь-яку іншу конфігурацію, яка вам подобається, або жодну, якщо функцію запускати до завершення програми (наприклад, годинник).

Ось адаптована версія до коду від MestreLion. Окрім оригінальної функції, цей код:

1) додати first_interval, який використовується для запуску таймера в певний час (абонент повинен обчислити first_interval і ввести)

2) вирішити умову перегонів у вихідному коді. У початковому коді, якщо керуюча нитка не змогла скасувати запущений таймер ("Зупиніть таймер та скасуйте виконання дії таймера. Це буде працювати лише в тому випадку, якщо таймер все ще знаходиться на етапі очікування". Цитується з https: // docs.python.org/2/library/threading.html ) таймер працюватиме нескінченно.

class RepeatedTimer(object):
def __init__(self, first_interval, interval, func, *args, **kwargs):
    self.timer      = None
    self.first_interval = first_interval
    self.interval   = interval
    self.func   = func
    self.args       = args
    self.kwargs     = kwargs
    self.running = False
    self.is_started = False

def first_start(self):
    try:
        # no race-condition here because only control thread will call this method
        # if already started will not start again
        if not self.is_started:
            self.is_started = True
            self.timer = Timer(self.first_interval, self.run)
            self.running = True
            self.timer.start()
    except Exception as e:
        log_print(syslog.LOG_ERR, "timer first_start failed %s %s"%(e.message, traceback.format_exc()))
        raise

def run(self):
    # if not stopped start again
    if self.running:
        self.timer = Timer(self.interval, self.run)
        self.timer.start()
    self.func(*self.args, **self.kwargs)

def stop(self):
    # cancel current timer in case failed it's still OK
    # if already stopped doesn't matter to stop again
    if self.timer:
        self.timer.cancel()
    self.running = False

Це здається набагато простішим, ніж прийняте рішення - чи є у нього недоліки, які я не розглядаю? Приїхав сюди, шукаючи якусь мертву-просту копію макаронних виробів і розчарувався.

import threading, time

def print_every_n_seconds(n=2):
    while True:
        print(time.ctime())
        time.sleep(n)

thread = threading.Thread(target=print_every_n_seconds, daemon=True)
thread.start()

Який асинхронно виводить.

#Tue Oct 16 17:29:40 2018
#Tue Oct 16 17:29:42 2018
#Tue Oct 16 17:29:44 2018

Це має відхилення в тому сенсі, що якщо виконання завдання займає значну кількість часу, то інтервал стає 2 секунди + час виконання завдання, тож якщо вам потрібно точне планування, це не для вас.

Зауважте, що daemon=Trueпрапор означає, що цей потік не блокує програму відключення. Наприклад, було pytestвипущено питання про те, де б висіти нескінченно після запуску тестів, очікуючи припинення цієї теди.

Я використовую це, щоб викликати 60 подій на годину, при цьому більшість подій відбувалися за ту ж кількість секунд після всієї хвилини:

import math
import time
import random

TICK = 60 # one minute tick size
TICK_TIMING = 59 # execute on 59th second of the tick
TICK_MINIMUM = 30 # minimum catch up tick size when lagging

def set_timing():

    now = time.time()
    elapsed = now - info['begin']
    minutes = math.floor(elapsed/TICK)
    tick_elapsed = now - info['completion_time']
    if (info['tick']+1) > minutes:
        wait = max(0,(TICK_TIMING-(time.time() % TICK)))
        print ('standard wait: %.2f' % wait)
        time.sleep(wait)
    elif tick_elapsed < TICK_MINIMUM:
        wait = TICK_MINIMUM-tick_elapsed
        print ('minimum wait: %.2f' % wait)
        time.sleep(wait)
    else:
        print ('skip set_timing(); no wait')
    drift = ((time.time() - info['begin']) - info['tick']*TICK -
        TICK_TIMING + info['begin']%TICK)
    print ('drift: %.6f' % drift)

info['tick'] = 0
info['begin'] = time.time()
info['completion_time'] = info['begin'] - TICK

while 1:

    set_timing()

    print('hello world')

    #random real world event
    time.sleep(random.random()*TICK_MINIMUM)

    info['tick'] += 1
    info['completion_time'] = time.time()

Залежно від реальних умов у вас можуть з’явитися кліщі довжини:

60,60,62,58,60,60,120,30,30,60,60,60,60,60...etc.

але наприкінці 60 хвилин у вас буде 60 кліщів; і більшість з них відбуватиметься при правильному зміщенні до тієї хвилини, яку ви віддаєте перевагу.

У моїй системі я отримую типовий дрейф <1/20 секунди, поки не з’явиться потреба в корекції.

Перевагою цього способу є дозвіл дрейфу годинника; що може спричинити проблеми, якщо ви робите такі речі, як додавання одного елемента за галочку, і ви очікуєте 60 доданих елементів на годину. Незрахунок дрейфу може спричинити, що вторинні ознаки, такі як ковзаючі середні, вважають дані занадто глибокими в минуле, що призводить до несправного виведення.

наприклад, Показувати поточний місцевий час

import datetime
import glib
import logger

def get_local_time():
    current_time = datetime.datetime.now().strftime("%H:%M")
    logger.info("get_local_time(): %s",current_time)
    return str(current_time)

def display_local_time():
    logger.info("Current time is: %s", get_local_time())
    return True

# call every minute
glib.timeout_add(60*1000, display_local_time)

    ''' tracking number of times it prints'''
import threading

global timeInterval
count=0
def printit():
  threading.Timer(timeInterval, printit).start()
  print( "Hello, World!")
  global count
  count=count+1
  print(count)
printit

if __name__ == "__main__":
    timeInterval= int(input('Enter Time in Seconds:'))
    printit()

Ось ще одне рішення без використання зайвих бібліотек.

def delay_until(condition_fn, interval_in_sec, timeout_in_sec):
    """Delay using a boolean callable function.

    `condition_fn` is invoked every `interval_in_sec` until `timeout_in_sec`.
    It can break early if condition is met.

    Args:
        condition_fn     - a callable boolean function
        interval_in_sec  - wait time between calling `condition_fn`
        timeout_in_sec   - maximum time to run

    Returns: None
    """
    start = last_call = time.time()
    while time.time() - start < timeout_in_sec:
        if (time.time() - last_call) > interval_in_sec:
            if condition_fn() is True:
                break
            last_call = time.time()