Deferring a function call

[TomF]

I'm writing a simple simulator, and I want to schedule an action to
occur at a later time. Basically, at some later point I want to call a
function f(a, b, c). But the values of a, b and c are determined at
the current time.

One way way to do this is to keep a list of entries of the form [[TIME,
FN, ARGS]...] and at simulated time TIME do: apply(FN, ARGS)
Aside from the fact that apply is deprecated, it seems like there
should be a cleaner (possibly more Pythonic) way to do this. Ideas?

-Tom

 

[Chris Rebert]

I'm writing a simple simulator, and I want to schedule an action to occur at
a later time.  Basically, at some later point I want to call a function f(a,
b, c).  But the values of a, b and c are determined at the current time.

See the `sched` std lib module:
http://docs.python.org/library/sched.html

Cheers,
Chris

 

[Chris Rebert]

I'm writing a simple simulator, and I want to schedule an action to occur at
a later time.  Basically, at some later point I want to call a function f(a,
b, c).  But the values of a, b and c are determined at the current time.

See the `sched` std lib module:
http://docs.python.org/library/sched.html

Cheers,
Chris

 

[Steven D'Aprano]

I'm writing a simple simulator, and I want to schedule an action to
occur at a later time. Basically, at some later point I want to call a
function f(a, b, c). But the values of a, b and c are determined at the
current time.

One way way to do this is to keep a list of entries of the form [[TIME,
FN, ARGS]...] and at simulated time TIME do: apply(FN, ARGS) Aside from
the fact that apply is deprecated,

Instead of apply(f, args) you should write:

f(*args)

If you have keyword arguments as well (or instead):

f(*args, **kwargs)

it seems like there should be a
cleaner (possibly more Pythonic) way to do this. Ideas?

Chris Rebert has already mentioned the sched module. Otherwise, put the
function call in a thread, and have the thread use time.sleep to wait
until the right time to execute.

 

[Lawrence D'Oliveiro]

One way way to do this is to keep a list of entries of the form [[TIME,
FN, ARGS]...] and at simulated time TIME do:

fn(*args) or fn(**kwargs)

 

[Cameron Simpson]

| Chris Rebert has already mentioned the sched module. Otherwise, put the
| function call in a thread, and have the thread use time.sleep to wait
| until the right time to execute.

There is also the Timer class from the threading module.

Cheers,
--
Cameron Simpson <[email protected]> DoD#743
http://www.cskk.ezoshosting.com/cs/

A crash reduces
your expensive computer
to a simple stone.
- Haiku Error Messages http://www.salonmagazine.com/21st/chal/1998/02/10chal2.html

 

[Michael Ricordeau]

For scheduling, I use eventlet package and spawn_after_local .
http://eventlet.net

But you must be aware of the constraints like using "monkey patched" modules .




Le Mon, 18 Oct 2010 21:21:41 -0700,

 

[Peter Otten]

I'm writing a simple simulator, and I want to schedule an action to
occur at a later time. Basically, at some later point I want to call a
function f(a, b, c). But the values of a, b and c are determined at
the current time.

One way way to do this is to keep a list of entries of the form [[TIME,
FN, ARGS]...] and at simulated time TIME do: apply(FN, ARGS)
Aside from the fact that apply is deprecated, it seems like there
should be a cleaner (possibly more Pythonic) way to do this. Ideas?

You can prepare the function

fstar = functools.partial(f, a, b, c)

and later invoke it as

fstar()

Peter

 

[TomF]

Thanks for the ideas, everyone.

functools.partial and lambda expressions seem like a more pythonic way
of doing what I want. I don't know whether they're actually more
efficient or better, but at least they eliminate the need to carry args
around separately.

I'd forgotten Python has a sched module in its standard library. It
may be overkill for what I want to do but I'll take a look.

-Tom

 

[Werner Thie]

For me nothing beats using twisted ( http://www.twistedmatrix.com ) with
its clean implementation of deferreds and a host of other useful things
for simulations besides being the 'Swiss Army Knife' of networking in
Python. If you throw in stackless ( http://www.stackless.com )
simulations with extremely high counts of participants and/or fine
granularity distributed across multiple machines are fun to write,
operate and maintain.

Werner