Cách tốt nhất để liên tục thực hiện một chức năng mỗi x giây là gì?

Tôi muốn liên tục thực thi một chức năng trong Python cứ sau 60 giây (giống như một NSTimer trong Mục tiêu C). Mã này sẽ chạy như một daemon và thực sự giống như gọi tập lệnh python mỗi phút bằng cron, nhưng không yêu cầu người dùng phải thiết lập nó.

Trong câu hỏi này về một cron được triển khai trong Python , giải pháp có vẻ như chỉ cần ngủ () trong x giây. Tôi không cần chức năng nâng cao như vậy nên có lẽ một cái gì đó như thế này sẽ hoạt động

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

Có bất kỳ vấn đề có thể thấy trước với mã này?

Nếu chương trình của bạn chưa có vòng lặp sự kiện, hãy sử dụng mô-đun lịch biểu , thực hiện bộ lập lịch sự kiện cho mục đích chung.

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

Nếu bạn đã sử dụng một thư viện vòng lặp sự kiện như asyncio, trio, tkinter, PyQt5, gobject, kivy, và nhiều người khác - chỉ cần sắp xếp công việc sử dụng phương pháp hiện có thư viện vòng lặp sự kiện của bạn, để thay thế.

Chỉ cần khóa vòng lặp thời gian của bạn để đồng hồ hệ thống. Dễ dàng.

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

Bạn có thể muốn xem Twisted là thư viện mạng Python thực hiện Mẫu Lò phản ứng .

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

Trong khi "while True: ngủ (60)" có thể sẽ hoạt động, Twisted có thể đã triển khai nhiều tính năng mà cuối cùng bạn sẽ cần (trình bày, ghi nhật ký hoặc xử lý ngoại lệ như được chỉ ra bởi bobince) và có thể sẽ là một giải pháp mạnh mẽ hơn

Nếu bạn muốn một cách không chặn để thực hiện chức năng của mình theo định kỳ, thay vì một vòng lặp vô hạn chặn, tôi sẽ sử dụng bộ đếm thời gian theo luồng. Bằng cách này, mã của bạn có thể tiếp tục chạy và thực hiện các tác vụ khác và vẫn có chức năng của bạn được gọi mỗi n giây. Tôi sử dụng kỹ thuật này rất nhiều để in thông tin tiến trình trên các tác vụ chuyên sâu về CPU / Đĩa / Mạng.

Đây là mã tôi đã đăng trong một câu hỏi tương tự, với điều khiển start () và 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

Sử dụng:

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!

Đặc trưng:

• Chỉ thư viện chuẩn, không phụ thuộc bên ngoài
• start()và stop()an toàn để gọi nhiều lần ngay cả khi bộ hẹn giờ đã bắt đầu / dừng
• Hàm được gọi có thể có các đối số vị trí và được đặt tên
• Bạn có thể thay đổi intervalbất cứ lúc nào, nó sẽ có hiệu lực sau lần chạy tiếp theo. Tương tự cho args, kwargsvà thậm chí function!

Cách dễ dàng hơn tôi tin là:

import time

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

while True:
    executeSomething()

Bằng cách này, mã của bạn được thực thi, sau đó nó đợi 60 giây rồi nó thực thi lại, chờ, thực thi, v.v ... Không cần phức tạp hóa mọi thứ: 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)

Nếu bạn muốn làm điều này mà không chặn mã còn lại của mình, bạn có thể sử dụng mã này để cho phép nó chạy trong luồng của chính nó:

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

Giải pháp này kết hợp một số tính năng hiếm khi được tìm thấy kết hợp trong các giải pháp khác:

• Xử lý ngoại lệ: Càng xa càng tốt ở cấp độ này, các ngoại lệ được xử lý đúng cách, tức là được ghi nhật ký cho mục đích gỡ lỗi mà không hủy bỏ chương trình của chúng tôi.
• Không có chuỗi: Việc triển khai giống như chuỗi chung (để lên lịch cho sự kiện tiếp theo) mà bạn tìm thấy trong nhiều câu trả lời là dễ vỡ ở khía cạnh nếu có bất cứ điều gì sai trong cơ chế lập lịch ( threading.Timerhoặc bất cứ điều gì), điều này sẽ chấm dứt chuỗi. Không có vụ xử tử nào nữa sẽ xảy ra sau đó, ngay cả khi lý do của vấn đề đã được khắc phục. Một vòng lặp đơn giản và chờ đợi với một đơn giản sleep()là mạnh mẽ hơn nhiều so với.
• Không trôi: Giải pháp của tôi theo dõi chính xác thời gian cần chạy. Không có trôi tùy thuộc vào thời gian thực hiện (như trong nhiều giải pháp khác).
• Bỏ qua: Giải pháp của tôi sẽ bỏ qua các tác vụ nếu một lần thực hiện mất quá nhiều thời gian (ví dụ: thực hiện X cứ sau 5 giây, nhưng X mất 6 giây). Đây là hành vi cron tiêu chuẩn (và vì một lý do tốt). Nhiều giải pháp khác sau đó chỉ cần thực hiện nhiệm vụ nhiều lần liên tiếp mà không có bất kỳ sự chậm trễ nào. Đối với hầu hết các trường hợp (ví dụ: nhiệm vụ dọn dẹp), điều này không được mong muốn. Nếu nó là mong muốn, chỉ cần sử dụng next_time += delaythay thế.

Đây là bản cập nhật mã từ MestreLion để tránh trôi dạt theo thời gian.

Lớp RepeatTimer ở ​​đây gọi hàm đã cho mỗi "giây" theo yêu cầu của OP; lịch trình không phụ thuộc vào thời gian thực hiện chức năng. Tôi thích giải pháp này vì nó không có phụ thuộc thư viện bên ngoài; Đây chỉ là con trăn thuần túy.

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

Sử dụng mẫu (được sao chép từ câu trả lời của 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!

Tôi đã phải đối mặt với một vấn đề tương tự một thời gian trở lại. Có thể http://cronus.readthedocs.org có thể giúp đỡ?

Đối với v0.2, đoạn mã sau hoạt động

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

Sự khác biệt chính giữa điều đó và cron là một ngoại lệ sẽ giết daemon mãi mãi. Bạn có thể muốn bọc với một công cụ bắt và ghi nhật ký ngoại lệ.

Một câu trả lời có thể có:

import time
t=time.time()

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

Tôi đã kết thúc bằng cách sử dụng các mô-đun lịch trình . API rất hay.

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)

Tôi sử dụng phương thức Tkinter after (), không "đánh cắp trò chơi" (như mô-đun lịch trình đã được trình bày trước đó), tức là nó cho phép các thứ khác chạy song song:

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()và do_something2()có thể chạy song song và ở bất kỳ tốc độ nào. Ở đây, cái thứ 2 sẽ được thực thi nhanh gấp đôi. Cũng xin lưu ý rằng tôi đã sử dụng một bộ đếm đơn giản như một điều kiện để chấm dứt một trong hai chức năng. Bạn có thể sử dụng bất kỳ đối số nào khác mà bạn thích hoặc không có gì nếu bạn chạy chức năng nào cho đến khi chương trình kết thúc (ví dụ: đồng hồ).

Đây là phiên bản phù hợp với mã từ MestreLion. Ngoài chức năng ban đầu, mã này:

1) thêm first_interval được sử dụng để kích hoạt bộ đếm thời gian tại một thời điểm cụ thể (người gọi cần tính toán First_interval và truyền vào)

2) giải quyết một điều kiện cuộc đua trong mã gốc. Trong mã gốc, nếu luồng điều khiển không thể hủy bộ hẹn giờ đang chạy ("Dừng bộ hẹn giờ và hủy thực thi hành động của bộ hẹn giờ. Điều này sẽ chỉ hoạt động nếu bộ hẹn giờ vẫn ở giai đoạn chờ." Trích dẫn từ https: // docs.python.org/2/l Library / threading.html ), bộ đếm thời gian sẽ chạy vô tận.

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

Điều này có vẻ đơn giản hơn nhiều so với giải pháp được chấp nhận - nó có thiếu sót gì không? Đến đây để tìm kiếm một số mì ống sao chép đơn giản và đã thất vọng.

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

Mà đầu ra không đồng bộ.

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

Điều này có nghĩa là nếu tác vụ đang chạy chiếm một lượng thời gian đáng kể, thì khoảng thời gian đó sẽ là 2 giây + thời gian tác vụ, vì vậy nếu bạn cần lập lịch chính xác thì đây không phải là dành cho bạn.

Lưu ý daemon=Truecờ có nghĩa là chủ đề này sẽ không chặn ứng dụng tắt. Ví dụ, có vấn đề pytestsẽ treo vô thời hạn sau khi chạy các bài kiểm tra chờ cho đến khi kết thúc này.

Tôi sử dụng điều này để gây ra 60 sự kiện mỗi giờ với hầu hết các sự kiện xảy ra ở cùng một số giây sau toàn bộ phút:

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

Tùy thuộc vào điều kiện thực tế, bạn có thể nhận được dấu vết của chiều dài:

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

nhưng cuối 60 phút bạn sẽ có 60 tích tắc; và hầu hết trong số chúng sẽ xảy ra ở độ lệch chính xác đến phút bạn thích.

Trên hệ thống của tôi, tôi nhận được độ trôi điển hình <1/20 của giây cho đến khi cần điều chỉnh.

Ưu điểm của phương pháp này là độ phân giải của đồng hồ trôi; điều này có thể gây ra vấn đề nếu bạn đang làm những việc như nối thêm một mục trên mỗi đánh dấu và bạn mong đợi 60 mục được thêm vào mỗi giờ. Việc không tính đến sự trôi dạt có thể khiến các chỉ dẫn thứ cấp như di chuyển trung bình để xem xét dữ liệu quá sâu vào quá khứ dẫn đến đầu ra bị lỗi.

ví dụ: Hiển thị giờ địa phương hiện tại

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

Đây là một giải pháp khác mà không cần sử dụng bất kỳ libaries thê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()