There is likely to be a better approach.

Consider refactoring printbob.py so that it can be imported by other Python modules. This version can be imported or called from the command-line:

#!/usr/bin/env python

import sys

def main(args):
    for arg in args:
        print(arg)

if __name__ == '__main__':
    main(sys.argv)

Here it is called from the command-line:

python printbob.py one two three four five
printbob.py
one
two
three
four
five

Now we can import it in getbob.py:

#!/usr/bin/env python

import printbob

printbob.main('arg1 arg2 arg3 arg4'.split(' '))

Here it is running:

python getbob.py 
arg1
arg2
arg3
arg4

See also What does if __name__ == "__main__": do? for more detail of this Python idiom.

The recommended way to return a value from one python "script" to another is to import the script as a Python module and call the functions directly:

import another_module

value = another_module.get_value(34)

where another_module.py is:

#!/usr/bin/env python
def get_value(*args):
    return "Hello World " + ":".join(map(str, args))

def main(argv):
    print(get_value(*argv[1:]))

if __name__ == "__main__":
    import sys
    main(sys.argv)

You could both import another_module and run it as a script from the command-line. If you don't need to run it as a command-line script then you could remove main() function and if __name__ == "__main__" block.

See also, Call python script with input with in a python script using subprocess.

The subprocess module is the option, but the tricky part is to follow the output un parallel with your main loop of gtk, to accomplish that goal you must have to consider the platform that you are dealing, if you are in linux you can easily run another thread and use gtk.gdk.threads_init to use threads in pygtk, but if you are planing to run your application on windows, then you should use generators and gobject.idle_add.

About the widget, use gtk.TextBuffer associated with a gtk.TextView

Here is an example with threads

import gtk
import subprocess
import threading

gtk.gdk.threads_init()

class FollowProcess(threading.Thread):
    def __init__(self, cmd, text_buffer):
        self.tb = text_buffer
        self.child = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
        super(FollowProcess, self).__init__()

    def run(self):
        while not self.child.poll():
            out = self.child.stdout.read(1)
            if out != '':
                gtk.gdk.threads_enter()
                self.tb.insert_at_cursor(out)
                gtk.gdk.threads_leave()

def destroy(w, cmd):
    cmd.child.terminate()
    gtk.main_quit()

i = 0
def click_count(btn):
    global i
    message.set_text('Calling button %d' %i)
    i += 1

other_command = 'python extranger.py'

w = gtk.Window()
w.resize(400, 400)

message = gtk.Label('Nothing')
tb = gtk.TextBuffer()
tv = gtk.TextView(tb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(tv)

box = gtk.VBox()
button = gtk.Button('Active button')

cmd = FollowProcess('python extranger.py', tb)

button.connect('clicked', click_count )

w.connect('destroy', destroy, cmd)
box.pack_start(button, False)
box.pack_start(message, False)
box.pack_start(scroll)


w.add(box)
w.show_all()
cmd.start()
gtk.main()

And in extranger.py

import time
import sys

i = 0
while True:
    print 'some output %d' % i
    sys.stdout.flush() # you need this to see the output
    time.sleep(.5)
    i += 1

Note how the button stills responsive even with the update in parallel.