x 초마다 함수를 반복적으로 실행하는 가장 좋은 방법은 무엇입니까?

파이썬에서 60 초마다 반복적으로 함수를 반복하고 싶습니다 ( Objective C 의 NSTimer 와 마찬가지로 ). 이 코드는 데몬으로 실행되며 크론을 사용하여 매분마다 파이썬 스크립트를 호출하는 것과 비슷하지만 사용자가 설정하지 않아도됩니다.

에서 파이썬으로 구현 된 크론에 대한이 질문에 솔루션을 효과적으로 단지에 나타나는 수면 () 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))

Reactor Pattern 을 구현하는 Python 네트워킹 라이브러리 인 Twisted 를 고려할 수 있습니다 .

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 : sleep (60)"은 아마도 작동하지만 Twisted는 아마도 여러분이 궁극적으로 필요로하는 많은 기능 (bobince가 지적한 데몬 처리, 로깅 또는 예외 처리)을 이미 구현하고 있으며보다 강력한 솔루션 일 것입니다

무한 루프를 차단하는 대신 비 차단 방식으로 주기적으로 함수를 실행하려면 스레드 타이머를 사용합니다. 이렇게하면 코드가 계속 실행되고 다른 작업을 수행 할 수 있으며 n 초마다 함수를 호출 할 수 있습니다. 이 기술은 긴 CPU / 디스크 / 네트워크 집약적 작업에 대한 진행 정보를 인쇄하는 데 많이 사용됩니다.

다음은 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 초 동안 기다린 다음 다시 실행, 대기, 실행 등을 복잡하게 할 필요가 없습니다.

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()가 훨씬 강력합니다.
• 표류 없음 : 내 솔루션은 실행 예정 시간을 정확하게 추적합니다. 실행 시간에 따라 다른 많은 솔루션 에서처럼 드리프트가 없습니다.
• 건너 뛰기 : 한 번의 실행에 너무 많은 시간이 걸리면 솔루션이 작업을 건너 뜁니다 (예 : 5 초마다 X를 수행하지만 X는 6 초가 걸렸습니다). 이것은 표준 크론 동작입니다. 다른 많은 솔루션은 지연없이 작업을 여러 번 연속해서 실행합니다. 대부분의 경우 (예 : 정리 작업) 이것은 바람직하지 않습니다. 이 경우 되고 싶다고, 단순히 사용하는 next_time += delay대신.

다음은 시간이 지남에 따라 드리핑을 피하는 MestreLion의 코드 업데이트입니다.

여기서 RepeatedTimer 클래스는 OP에서 요청한대로 "간격"초마다 지정된 함수를 호출합니다. 스케줄은 함수를 실행하는 데 걸리는 시간에 의존하지 않습니다. 외부 라이브러리 종속성이 없기 때문에이 솔루션을 좋아합니다. 이것은 순수한 파이썬입니다.

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

그와 cron의 주요 차이점은 예외로 인해 데몬이 정상적으로 종료된다는 것입니다. 예외 캐처 및 로거로 랩핑 할 수 있습니다.

가능한 답변 :

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 () 메소드를 사용하는데, "게임을 훔치지"않는 ( 앞서 제시 한 sched 모듈 과 같이 ) 다른 것들을 병렬로 실행할 수 있습니다.

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 개의 항목이 추가되는 경우 문제가 발생할 수 있습니다. 드리프트를 설명하지 않으면 이동 평균과 같은 2 차 표시가 데이터를 너무 깊게 고려하여 출력이 잘못 될 수 있습니다.

예 : 현재 현지 시간 표시

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