Bir işlevi her x saniyede bir art arda yürütmenin en iyi yolu nedir?

Her 20 saniyede bir Python'da sürekli olarak bir işlev yürütmek istiyorum (tıpkı bir NSTimer gibi) olarak Objective C ). Bu kod bir daemon olarak çalışır ve etkili bir şekilde bir cron kullanarak her dakika python betiğini çağırmaya benzer, ancak bunun kullanıcı tarafından ayarlanmasını gerektirmez.

In Python uygulanan bir cron hakkında bu soruya , solüsyon etkili sadece görünen uyku () x saniye boyunca. Böyle gelişmiş bir işleve ihtiyacım yok, belki böyle bir şey işe yarayabilir

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

Bu kodla ilgili öngörülebilir sorunlar var mı?

Programınızda zaten bir olay döngüsü yoksa , genel amaçlı bir olay zamanlayıcı uygulayan sched modülünü kullanın .

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()

Zaten böyle bir olay döngü kitaplığı kullanıyorsanız asyncio, trio, tkinter, PyQt5, gobject, kivy, ve diğerleri - sadece yerine, mevcut olay döngü kütüphanenin yöntemleri kullanarak görev zamanlama.

Zaman döngünüzü sistem saatine şu şekilde kilitleyin:

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

Reaktör Kalıbını uygulayan bir Python ağ kütüphanesi olan Twisted'ı düşünebilirsiniz .

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()

"While True: sleep (60)" muhtemelen işe yarayacak olsa da Twisted muhtemelen sonunda ihtiyaç duyacağınız özelliklerin çoğunu (bobince'nin işaret ettiği gibi daemonization, günlüğe kaydetme veya istisna işleme) uygular ve muhtemelen daha sağlam bir çözüm olacaktır.

Fonksiyonunuzu periyodik olarak yürütmenin engellenmeyen bir yolunu istiyorsanız, sonsuz döngüyü engelleme yerine, dişli bir zamanlayıcı kullanırım. Bu şekilde kodunuz çalışmaya devam edebilir ve diğer görevleri gerçekleştirebilir ve yine de her n saniyede bir işlev çağrılır. Uzun, CPU / Disk / Ağ yoğun görevlerde ilerleme bilgisini yazdırmak için bu tekniği çok kullanıyorum.

Start () ve stop () kontrolü ile benzer bir soruda gönderdiğim kod:

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

Kullanımı:

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!

Özellikleri:

• Yalnızca standart kitaplık, harici bağımlılık yok
• start()ve stop()zamanlayıcı zaten başlamış / durmuş olsa bile birden çok kez aramak güvenlidir
• çağrılacak fonksiyonun konumsal ve adlandırılmış argümanları olabilir
• İstediğiniz zaman değiştirebilirsiniz interval, bir sonraki çalıştırmadan sonra etkili olacaktır. Aynı için args, kwargsve hatta function!

Daha kolay olduğuna inanıyorum:

import time

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

while True:
    executeSomething()

Bu şekilde kodunuz yürütülür, sonra 60 saniye bekler, sonra tekrar yürütür, bekler, yürütür, vb ... İşleri karmaşıklaştırmaya gerek yok: 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)

Kalan kodunuzu engellemeden bunu yapmak istiyorsanız, bunu kendi iş parçacığında çalışmasına izin vermek için kullanabilirsiniz:

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

Bu çözüm, diğer çözümlerde nadiren bulunan çeşitli özellikleri birleştirir:

• İstisna yönetimi: Bu seviyede mümkün olduğunca istisnalar uygun şekilde ele alınır, yani programımızı iptal etmeden hata ayıklama amacıyla günlüğe kaydedilir.
• Zincirleme yok: Birçok cevapta bulduğunuz ortak zincir benzeri uygulama (bir sonraki olayı planlamak için), programlama mekanizması ( threading.Timerveya herhangi bir şey) içinde bir şey ters giderse , bu zinciri sonlandıracak şekilde kırılgandır . Sorunun nedeni önceden belirlenmiş olsa bile, başka yürütme olmayacaktır. Basit bir döngü ve basitle beklemek sleep()kıyaslandığında çok daha sağlamdır.
• Kayma yok: Çözümüm, kaç kez çalışacağını tam olarak takip ediyor. Yürütme süresine bağlı olarak sürüklenme olmaz (diğer birçok çözümde olduğu gibi).
• Atlama: Bir yürütme çok fazla zaman alırsa çözümüm görevleri atlayacaktır (örneğin her beş saniyede bir X yapın, ancak X 6 saniye sürdü). Bu standart cron davranışıdır (ve iyi bir nedenden dolayı). Diğer birçok çözüm daha sonra görevi üst üste birkaç kez herhangi bir gecikme olmadan yürütür. Çoğu durumda (örn. Temizleme görevleri) bu istenmez. O takdirde edilir diledi, sadece kullanım next_time += delayyerine.

İşte MestreLion'un kodunda zaman içinde sürüklenmeyi önleyen bir güncelleme.

Buradaki RepeatedTimer sınıfı, OP tarafından istendiği gibi verilen her "aralık" saniyede bir işlevi çağırır; zamanlama, işlevin yürütülmesi için geçen süreye bağlı değildir. Harici kütüphane bağımlılıkları olmadığı için bu çözümü seviyorum; bu sadece saf bir piton.

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

Örnek kullanım (MestreLion'un cevabından kopyalandı):

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!

Bir süre önce benzer bir sorunla karşılaştım. Olabilir http://cronus.readthedocs.org yardımcı olabilecek?

V0.2 için aşağıdaki snippet çalışır

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

Bu ve cron arasındaki temel fark, bir istisnanın cini iyi için öldürecek olmasıdır. Bir istisna yakalayıcı ve kaydedici ile sarmak isteyebilirsiniz.

Bir olası cevap:

import time
t=time.time()

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

Ben kullanarak sona erdi zamanlama modülü. API güzel.

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)

Ben "oyunu çalmak" ( daha önce sunulan zamanlama modülü gibi) değil Tkinter after () yöntemini kullanın , yani diğer şeylerin paralel olarak çalışmasına izin verir:

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()ve do_something2()paralel ve herhangi bir aralık hızında çalışabilir. Burada, ikincisi iki kat daha hızlı yürütülecektir.Ayrıca, her iki işlevi sonlandırmak için bir koşul olarak basit bir sayaç kullandığımı da unutmayın. Program sona erene kadar çalıştırılacak bir işlev varsa (örneğin bir saat) istediğiniz başka herhangi bir kongreyi kullanabilirsiniz.

İşte MestreLion koduna uyarlanmış bir versiyon. Orijinal işleve ek olarak, bu kod:

1) zamanlayıcıyı belirli bir zamanda tetiklemek için kullanılan first_interval ekleyin (arayan ilk_interval değerini hesaplamalı ve içeri aktarmalıdır)

2) Bir yarış koşulunu orijinal kodda çözer. Orijinal kodda, kontrol iş parçacığı çalışan zamanlayıcıyı iptal edemediyse ("Zamanlayıcıyı durdurun ve zamanlayıcının işleminin yürütülmesini iptal edin. Bu yalnızca zamanlayıcı hala bekleme aşamasındaysa çalışır." Https: // docs.python.org/2/library/threading.html ), zamanlayıcı sürekli olarak çalışır.

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

Bu, kabul edilen çözümden çok daha basit görünüyor - düşünmediğim eksiklikler var mı? Buraya bazı ölü basit kopya makarna arıyor geldi ve hayal kırıklığına uğradım.

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()

Hangi zaman uyumsuz çıktı.

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

Çalıştırılan görev kayda değer miktarda zaman alırsa, aralığın 2 saniye + görev süresi haline gelmesi anlamında sürüklenir, bu nedenle kesin zamanlamaya ihtiyacınız varsa bu sizin için değildir.

İşaretin, daemon=Truebu iş parçacığının uygulamanın kapanmasını engellemeyeceği anlamına geldiğini unutmayın . Örneğin, pytesttestlerin yürütüldükten sonra bu sonun durmasını beklerken süresiz olarak nerede duracağı sorunu vardı .

Bunu, tüm dakikalardan sonra aynı sayıda saniyede gerçekleşen çoğu olayla saatte 60 olaya neden olmak için kullanıyorum:

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()

Gerçek koşullara bağlı olarak uzunluk keneleri alabilirsiniz:

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

ama 60 dakikanın sonunda 60 keneniz olacak; ve çoğu tercih ettiğiniz dakikaya kadar doğru ofsette gerçekleşir.

Sistemimde düzeltme ihtiyacı ortaya çıkana kadar saniyenin 1 / 20'sinden az sapması oluyor.

Bu yöntemin avantajı, saat kaymasının çözümlenmesidir; kene başına bir öğe eklemek gibi bir şey yapıyorsanız ve saat başına 60 öğe eklenmesini beklerseniz sorunlara neden olabilir. Kaymayı hesaba katmamak, hareketli ortalamalar gibi ikincil göstergelerin verileri geçmişin çok derinlerinde değerlendirmesine neden olarak hatalı çıktıya neden olabilir.

ör. Geçerli yerel saati göster

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()

İşte ekstra libaries kullanmadan başka bir çözüm.

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()