Is it possible to get another thread's print content?

I present at the end a way for doing what is requested but I do not recommend using bare prints for this. There are better tools, and if you still want to stick with print, you can use the file keyword to specify where the output should go.

import time
import sys 

def get(out_stream=sys.stdout):
    for i in range(100):
        print(i, file=out_stream)
        print("\n")
        time.sleep(1)

you can pass a file object opened with open as the argument, and the output will go to that file. Alternatively, you can use a io.StringIO as @barmar suggested, and write the contents to a file once get finishes.

All other options mess with sys.stdout, that is the default file object that print uses (it is the default value of the file keyword argument). This affects everything that uses sys.stdout, which can be more than all the print statements that get executed.

If you need to redirect bare print statements (not using print's file keyword), you must replace sys.stdout. The most obvious replacement would be to use an output file object:

from threading import Thread
import time
import sys

def get():
    for i in range(100):
        print(i)
        time.sleep(1)


if __name__ == "__main__":
    old_stdout = sys.stdout
    with open("output.txt", "a") as text_fil:
        sys.stdout = text_fil
        get_thread = Thread(None, get)
        get_thread.start()
        get_thread.join()
    sys.stdout = old_stdout

If you need to have one writing thread and a reading thread, exactly as the question states, you can use Queues, but a simpler approach uses pipes (I added a dummy thread (postthread) that calls post to make it similar to OP's use):

from threading import Thread
import time
import sys
import os

def get():
    for i in range(100):
        print(i)
        time.sleep(1)

def post(read_pipe):
    with open("output.txt", "ab") as text_fil:  # os.read yields bytes
        try:
            data = os.read(read_pipe, 65535)  # arbitrary (but large) number
            text_fil.write(data)
        except Exception as e:
            return True  # the read descriptor was closed: quit
    return len(data) == 0  # the write descriptor was closed: quit

def postthread(read_pipe):
    for _ in range(21):
        time.sleep(5)
        if post(read_pipe):
            return

if __name__ == "__main__":
    old_stdout = sys.stdout
    r_fd, w_fd = os.pipe()
    with os.fdopen(w_fd, 'wt') as write_pipe: # write pipe is a file object
        read_pipe = r_fd
        sys.stdout = write_pipe
        get_thread = Thread(None, get)
        post_thread = Thread(None, postthread, args=(read_pipe, ))
        post_thread.start()
        get_thread.start()
        get_thread.join()
        sys.stdout = old_stdout
        # closing the write pipe (and its file descriptor) causes read to see EOF.
    post_thread.join()
    os.close(r_fd)
    sys.stdout = old_stdout