Implementierung einer zeitgesteuerten Schleifenausführung von Aufgaben über Python3

In unserer tatsächlichen Entwicklung gibt es häufig eine solche Anforderung: Ein bestimmtes Funktionsmodul oder eine bestimmte Aufgabe muss zyklisch innerhalb desselben Zeitraums ausgeführt werden. Hier gibt es ein Konzept eines Timers. Wie sollten wir konkret einen Timer implementieren? Timer verfügen über viele sehr praktische Funktionen, die die Ausführung von Threads steuern, den Systemverbrauch reduzieren usw. können. Lassen Sie uns nun die Implementierung der Timing-Funktion in Python3 üben.

Wenn Sie beispielsweise Python zum Entwickeln eines Crawler-Systems verwenden, müssen Sie möglicherweise Aufgaben in regelmäßigen Abständen wiederholt ausführen, um einen Thread-Dienst zur Überwachung von Daten zu implementieren Im Hintergrund kann der Crawling-Status helfen.

[Videoempfehlung: Python3-Video-Tutorial]

[Handbuchempfehlung: Python-Chinesisch-Handbuch]

Durch Python-Dokumentation Wir finden Sie threading.Timer() zum Implementieren der Timing-Funktion:

Einfacher Implementierungscode:

import threading
def func1(a):
    #Do something
    print('Do something')
    a+=1
    print(a)
    print('当前线程数为{}'.format(threading.activeCount()))
    if a>5:
        return
    t=threading.Timer(5,func1,(a,))
    t.start()

Rendering:

Durch Konsultation der Informationen kann Python verwendet werden, um drei verschiedene geplante Aufgabenausführungsmethoden zu implementieren:

1 Geplanter Aufgabencode

#!/user/bin/env python
#定时执行任务命令
import time,os,sched
schedule = sched.scheduler(time.time,time.sleep)
def perform_command(cmd,inc):
  os.system(cmd)
  print('task')
def timming_exe(cmd,inc=60):
  schedule.enter(inc,0,perform_command,(cmd,inc))
  schedule.run()
print('show time after 2 seconds:')
timming_exe('echo %time%',2)

2. Regelmäßige Ausführung von Aufgaben

#!/user/bin/env python
import time,os,sched
schedule = sched.scheduler(time.time,time.sleep)
def perform_command(cmd,inc):
  #在inc秒后再次运行自己，即周期运行
  schedule.enter(inc, 0, perform_command, (cmd, inc))
  os.system(cmd)
def timming_exe(cmd,inc=60):
  schedule.enter(inc,0,perform_command,(cmd,inc))
  schedule.run()#持续运行，直到计划时间队列变成空为止
print('show time after 2 seconds:')
timming_exe('echo %time%',2)

3 .Loop-Ausführungsbefehl

#!/user/bin/env python
import time,os
def re_exe(cmd,inc = 60):
  while True:
    os.system(cmd)
    time.sleep(inc)
re_exe("echo %time%",5)

Zusammenfassend: Die Methoden von Python zum Implementieren von Timern basieren alle auf Zeitplan und Threading, und die spezifische Verwendung muss entsprechend der tatsächlichen Situation flexibel verwendet werden.

Die beiden am häufigsten verwendeten Module: Threading, Sched

Threading-Modul verwendet:

import threading ,time
from time import sleep, ctime
class Timer(threading.Thread):
        """
        very simple but useless timer.
        """
        def __init__(self, seconds):
                self.runTime = seconds
                threading.Thread.__init__(self)
        def run(self):
                time.sleep(self.runTime)
                print ("Buzzzz!! Time's up!")
class CountDownTimer(Timer):
        """
        a timer that can counts down the seconds.
        """
        def run(self):
                counter = self.runTime
                for sec in range(self.runTime):
                        print (counter)
                        time.sleep(1.0)
                        counter -= 1
                print ("Done")
 
class CountDownExec(CountDownTimer):
        """
        a timer that execute an action at the end of the timer run.
        """
        def __init__(self, seconds, action, args=[]):
                self.args = args
                self.action = action
                CountDownTimer.__init__(self, seconds)
        def run(self):
                CountDownTimer.run(self)
                self.action(self.args)
 
def myAction(args=[]):
        print ("Performing my action with args:")
        print (args)
 
if __name__ == "__main__":
        t = CountDownExec(3, myAction, ["hello", "world"])
        t.start()
        print("2333")

Sched-Modul verwendet:

'''
使用sched模块实现的timer,sched模块不是循环的，一次调度被执行后就Over了，如果想再执行，
可以使用while循环的方式不停的调用该方法
'''
import time, sched
#被调度触发的函数
def event_func(msg):
    print("Current Time:", time.strftime("%y-%m-%d %H:%M:%S"), 'msg:', msg)
def run_function():
    #初始化sched模块的scheduler类
    s = sched.scheduler(time.time, time.sleep)
    #设置一个调度,因为time.sleep()的时间是一秒,所以timer的间隔时间就是sleep的时间,加上enter的第一个参数
    s.enter(0, 2, event_func, ("Timer event.",))
    s.run()
def timer1():
    while True:
        #sched模块不是循环的，一次调度被执行后就Over了，如果想再执行，可以使用while循环的方式不停的调用该方法
        time.sleep(1)
        run_function()
if __name__ == "__main__":
    timer1()

Das obige ist der detaillierte Inhalt vonImplementierung einer zeitgesteuerten Schleifenausführung von Aufgaben über Python3. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!