You can run it in a thread (so that it doesn't block your code from running), and get the output until you get the second line, then wait for it to terminate. This is an example that will read the output from the command dir /s on Windows to get all the directory listing.

import subprocess, thread, time

def run():
    global can_break

    args = ["dir", "/s"]
    shell = True

    count = 0
    popen = subprocess.Popen(args, shell=shell, stdout=subprocess.PIPE)
    while True:
        line = popen.stdout.readline()
        if line == "": continue
        count += 1
        if count == 2:
            do_something_with(line)
            break

    print "We got our line, we are waiting now"
    popen.wait()
    print "Done."
    can_break = True

def do_something_with(line):
    print '>>> This is it:', line

thread.start_new_thread(run, tuple())

can_break = False
while not can_break:
    print 'Wait'
    time.sleep(1)

print 'Okay!'

Output will look like:

Wait
>>> This is it:  Volume Serial Number is XXXX-XXXX

We got our line, we are waiting now
Wait
Wait
Wait
.
.
.
Done.
Wait
Okay!

If you want to execute it in Background I recommend you to use nohup output that would normally go to the terminal goes to a file called nohup.out

import subprocess

subprocess.Popen("nohup usr/local/bin/otherscript.pl {0} >/dev/null 2>&1 &", shell=True)

>/dev/null 2>&1 & will not create output and will redirect to background

You could use nohup with Popen:

from subprocess import Popen, check_call

from os import devnull

p = Popen(["nohup", "python", "test.py"], stdout=open(devnull, "w"))

import time

print(p.pid)
for i in range(3):
    print("In for")
    time.sleep(1)

check_call("ps -ef | grep {} | grep -v grep".format(p.pid), shell=True)
p.terminate()
check_call("ps -ef | grep {} | grep -v grep".format(p.pid), shell=True)

test.py:

import  time
while True:
    time.sleep(1)
    print("Still alive")

The output:

In [3]: from os import devnull

In [4]: p = Popen(["nohup", "python", "b.py"], stdout=open(devnull, "w"))
nohup: ignoring input and redirecting stderr to stdout
In [5]: print(p.pid)
28332

In [6]: for i in range(3):
   ...:         print("In for")
   ...:         time.sleep(1)
   ...:     
In for
In for
In for

In [7]: check_call("ps -ef | grep {} | grep -v grep".format(p.pid), shell=True)
padraic  28332 28301  1 20:55 pts/8    00:00:00 python test.py 
Out[7]: 0

In [8]: p.terminate()

In [9]: check_call("ps -ef | grep {} | grep -v grep".format(p.pid), shell=True)
padraic  28332 28301  0 20:55 pts/8    00:00:00 [python] <defunct>
Out[9]: 0

Here is a good explaination of shell=True

Setting the shell argument to a true value causes subprocess to spawn an intermediate shell process, and tell it to run the command

Always use=shell=False, your code however works on my linux environment as below, for simplicity I used a shell file as command to run] :

import os,signal
import time
import subprocess
from threading import Thread

g_flag = 0
class StartChecking(Thread):
    def __init__(self):
        Thread.__init__(self)
    def run(self):
        global g_flag
        print 'Starting thread'
        proc = subprocess.Popen(["./a.sh"], stdout=subprocess.PIPE, shell=True)
        pid = proc.pid
        print 'Sniff started ' + str(pid)
        if (pid != 0) and (pid != 1):
            while g_flag == 0:
                time.sleep(0.1)
            os.kill(pid, signal.SIGTERM)
            print 'Killed ' + str(pid)
        (out, err) = proc.communicate() # Currently its blocking here
        print out


th = StartChecking()
th.start()
#Do something else
time.sleep(5)
g_flag = 1
th.join()
print 'thread joined'

A quite messy way of doing this is to first start the .py in the command line before starting LXDE, then use Ctrl-Z. Type "bg && startx". The .py will run in the command line while LXDE can be used.
Credit to Gerben for the "Ctrl-Z" and "bg" idea.

python test.py &

will run the file in the background.

In order to find the running program, you can use ps -e to list all running programs. You can use grep to find your particular program from the list.

Note: This answer is less current than it was when posted in 2009. Using the subprocess module shown in other answers is now recommended in the docs

(Note that the subprocess module provides more powerful facilities for spawning new processes and retrieving their results; using that module is preferable to using these functions.)

If you want your process to start in the background you can either use system() and call it in the same way your shell script did, or you can spawn it:

import os
os.spawnl(os.P_DETACH, 'some_long_running_command')

(or, alternatively, you may try the less portable os.P_NOWAIT flag).

See the documentation here.