Efficient Python Daemon

Rather than writing your own daemon, use python-daemon instead! python-daemon implements the well-behaved daemon specification of PEP 3143, "Standard daemon process library".

I have included example code based on the accepted answer to this question, and even though the code looks almost identical, it has an important fundamental difference. Without python-daemon you would have to use & to put your process in the background and nohup and to keep your process from getting killed when you exit your shell. Instead this will automatically detach from your terminal when you run the program.

For example:

import daemonimport timedef do_something():    while True:        with open("/tmp/current_time.txt", "w") as f:            f.write("The time is now " + time.ctime())        time.sleep(5)def run():    with daemon.DaemonContext():        do_something()if __name__ == "__main__":    run()

To actually run it:

python background_test.py

And note the absence of & here.

Also, this other stackoverflow answer explains in detail the many benefits of using python-daemon.

I think your idea is pretty much exactly what you want. For example:

import timedef do_something():    with open("/tmp/current_time.txt", "w") as f:        f.write("The time is now " + time.ctime())def run():    while True:        time.sleep(60)        do_something()if __name__ == "__main__":    run()

The call to time.sleep(60) will put your program to sleep for 60 seconds. When that time is up, the OS will wake up your program and run the do_something() function, then put it back to sleep. While your program is sleeping, it is doing nothing very efficiently. This is a general pattern for writing background services.

To actually run this from the command line, you can use &:

$ python background_test.py &

When doing this, any output from the script will go to the same terminal as the one you started it from. You can redirect output to avoid this:

$ python background_test.py >stdout.txt 2>stderr.txt &

Using & in the shell is probably the dead simplest way as Greg described.

If you really want to create a powerful Daemon though, you will need to look into the os.fork() command.

The example from Wikipedia:

#!/usr/bin/env python# -*- coding: utf-8 -*-import os, timedef createDaemon():  """       This function create a service/Daemon that will execute a det. task  """  try:    # Store the Fork PID    pid = os.fork()    if pid > 0:      print 'PID: %d' % pid      os._exit(0)  except OSError, error:    print 'Unable to fork. Error: %d (%s)' % (error.errno, error.strerror)    os._exit(1)  doTask()def doTask():  """       This function create a task that will be a daemon  """  # Open the file in write mode  file = open('/tmp/tarefa.log', 'w')  # Start the write  while True:    print >> file, time.ctime()    file.flush()    time.sleep(2)  # Close the file  file.close()if __name__ == '__main__':  # Create the Daemon  createDaemon()

And then you could put whatever task you needed inside the doTask() block.

You wouldn't need to launch this using &, and it would allow you to customize the execution a little further.