我必须在 python 中做一个需要执行一段时间的程序，然后（不管它在哪里执行）它必须将信息转储到文件中，关闭文件然后退出。
这里的行为在 JavaScript 中等价于使用setTimeout(func, 1000000)，其中第一个参数 (func) 是指向带有退出代码的函数的指针，第二个参数是程序执行的可用时间。
我知道如何用 C 语言（使用 SO 信号）制作这个程序，但是用 python
问问题
53151 次
4 回答
82
在实践中，定时器可能是做你想做的最简单的方法。
此代码将执行以下操作：
- 1 秒后，它打印“arg1 arg2”
- 2 秒后，它会打印“OWLS OWLS OWLS”
===
from threading import Timer
def twoArgs(arg1,arg2):
print arg1
print arg2
print ""
def nArgs(*args):
for each in args:
print each
#arguments:
#how long to wait (in seconds),
#what function to call,
#what gets passed in
r = Timer(1.0, twoArgs, ("arg1","arg2"))
s = Timer(2.0, nArgs, ("OWLS","OWLS","OWLS"))
r.start()
s.start()
===
上面的代码很可能会解决您的问题。
但！还有另一种方法，即不使用多线程。它的工作原理更像是单线程的 Javascript。
对于这个单线程版本，您需要做的就是将函数及其参数以及函数应该运行的时间存储在一个对象中。
一旦你有了包含函数调用和超时的对象，只需定期检查函数是否准备好执行。
正确的方法是创建一个优先级队列来存储我们将来要运行的所有函数，如下面的代码所示。
就像在 Javascript 中一样，这种方法不能保证函数会准确地按时运行。一个需要很长时间才能运行的函数会延迟它之后的函数。但它确实保证了一个函数将在其超时之前运行。
此代码将执行以下操作：
- 1秒后，打印“20”
- 2秒后，打印“132”
- 3 秒后，它退出。
===
from datetime import datetime, timedelta
import heapq
# just holds a function, its arguments, and when we want it to execute.
class TimeoutFunction:
def __init__(self, function, timeout, *args):
self.function = function
self.args = args
self.startTime = datetime.now() + timedelta(0,0,0,timeout)
def execute(self):
self.function(*self.args)
# A "todo" list for all the TimeoutFunctions we want to execute in the future
# They are sorted in the order they should be executed, thanks to heapq
class TodoList:
def __init__(self):
self.todo = []
def addToList(self, tFunction):
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def executeReadyFunctions(self):
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
while tFunction and datetime.now() > tFunction.startTime:
#execute all the functions that are ready
tFunction.execute()
if len(self.todo) > 0:
tFunction = heapq.heappop(self.todo)[1]
else:
tFunction = None
if tFunction:
#this one's not ready yet, push it back on
heapq.heappush(self.todo, (tFunction.startTime, tFunction))
def singleArgFunction(x):
print str(x)
def multiArgFunction(x, y):
#Demonstration of passing multiple-argument functions
print str(x*y)
# Make some TimeoutFunction objects
# timeout is in milliseconds
a = TimeoutFunction(singleArgFunction, 1000, 20)
b = TimeoutFunction(multiArgFunction, 2000, *(11,12))
c = TimeoutFunction(quit, 3000, None)
todoList = TodoList()
todoList.addToList(a)
todoList.addToList(b)
todoList.addToList(c)
while True:
todoList.executeReadyFunctions()
===
在实践中，您可能会在该 while 循环中进行更多操作，而不仅仅是检查您的超时函数是否准备就绪。您可能正在轮询用户输入、控制某些硬件、读取数据等。
于 2013-03-17T02:02:43.970 回答
12
您也可以在 python 中使用信号（仅限 unix）
import signal, sys
# install a SIGALRM handler
def handler(signum, frame):
print "got signal, exiting"
sys.exit(1)
signal.signal(signal.SIGALRM, handler)
# emit SIGALRM after 5 secs
signal.setitimer(signal.ITIMER_REAL, 5)
# do stuff
i = 1
while True:
if i % 100000 == 0:
print i
i += 1
于 2012-04-14T15:45:33.303 回答
10
asyncio在 python 3 中有一个很好的解决方案：
import asyncio
def async_call_later(seconds, callback):
async def schedule():
await asyncio.sleep(seconds)
if asyncio.iscoroutinefunction(callback):
await callback()
else:
callback()
asyncio.ensure_future(schedule())
async def do_something_async():
await asyncio.sleep(0.5)
print('Now! async')
async def main():
print('Scheduling...')
async_call_later(3, do_something_async)
async_call_later(3, lambda: print('Now!'))
print('Waiting...')
await asyncio.sleep(4)
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
请注意，python 中的 sleep 和类似函数需要几秒钟，所以我复制了它。但是如果你需要毫秒，你可以提供分数。（例如 0.5 => 500 毫秒）。
这种方法优于asyncio.call_later的一个优点是它只适用于同步回调。如果回调是协程，则此实现awaits 会更加健壮。
于 2018-08-23T21:21:36.327 回答
6
你可以使用call_laterpython3 的 asyncio 事件循环的方法。下面的示例将正常工作。
import asyncio
loop = asyncio.get_event_loop()
def callback():
print("callback")
loop.call_later(1, callback)
loop.call_later(1, callback)
async def main():
while True:
await asyncio.sleep(1)
loop.run_until_complete(main())
于 2018-11-04T17:12:50.290 回答