Предупреждение: это предназначено для работы в * nix и OSX по запросу, но определенно не будет работать в Windows.

Я использовал эту модификацию рецепта ActiveState в качестве основы для кода ниже. Это простой в использовании объект, который может читать ввод с таймаутом. Он использует опрос для сбора символов по одному и имитирует поведение raw_input() / input().

Ввод с тайм-аутом

Примечание: очевидно, что метод _getch_nix() ниже не работает для OP, но он работает для меня в OSX 10.9.5. Возможно, вам повезет с вызовом _getch_osx(), хотя, похоже, он работает только в 32-разрядном питоне, поскольку Carbon не полностью поддерживает 64-разрядный.

import sys
import time


class TimeoutInput(object):
    def __init__(self, poll_period=0.05):
        import sys, tty, termios  # apparently timing of import is important if using an IDE
        self.poll_period = poll_period

    def _getch_nix(self):
        import sys, tty, termios
        from select import select
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            [i, o, e] = select([sys.stdin.fileno()], [], [], self.poll_period)
            if i:
                ch = sys.stdin.read(1)
            else:
                ch = ''
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

    def _getch_osx(self):
        # from same discussion on the original ActiveState recipe:
        # http://code.activestate.com/recipes/134892-getch-like-unbuffered-character-reading-from-stdin/#c2
        import Carbon
        if Carbon.Evt.EventAvail(0x0008)[0] == 0:  # 0x0008 is the keyDownMask
            return ''
        else:
            # The event contains the following info:
            # (what,msg,when,where,mod)=Carbon.Evt.GetNextEvent(0x0008)[1]
            #
            # The message (msg) contains the ASCII char which is
            # extracted with the 0x000000FF charCodeMask; this
            # number is converted to an ASCII character with chr() and
            # returned
            (what,msg,when,where,mod)=Carbon.Evt.GetNextEvent(0x0008)[1]
            return chr(msg & 0x000000FF)

    def input(self, prompt=None, timeout=None,
              extend_timeout_with_input=True, require_enter_to_confirm=True):
        """timeout: float seconds or None (blocking)"""
        prompt = prompt or ''
        sys.stdout.write(prompt)  # this avoids a couple of problems with printing
        sys.stdout.flush()  # make sure prompt appears before we start waiting for input
        input_chars = []
        start_time = time.time()
        received_enter = False
        while (time.time() - start_time) < timeout:
            # keep polling for characters
            c = self._getch_osx()  # self.poll_period determines spin speed
            if c in ('\n', '\r'):
                received_enter = True
                break
            elif c:
                input_chars.append(c)
                sys.stdout.write(c)
                sys.stdout.flush()
                if extend_timeout_with_input:
                    start_time = time.time()
        sys.stdout.write('\n')  # just for consistency with other "prints"
        sys.stdout.flush()
        captured_string = ''.join(input_chars)
        if require_enter_to_confirm:
            return_string = captured_string if received_enter else ''
        else:
            return_string = captured_string
        return return_string

Попробуй это

# this should work like raw_input() except it will time out
ti = TimeoutInput(poll_period=0.05)
s = ti.input(prompt='wait for timeout:', timeout=5.0,
             extend_timeout_with_input=False, require_enter_to_confirm=False)
print(s)

Повторный ввод

Это реализует ваше первоначальное намерение, насколько я понимаю. Я не вижу смысла делать рекурсивные вызовы - я думаю, что вам нужно просто многократно вводить ввод? Пожалуйста, поправьте меня, если это не так.

ti = TimeoutInput()
prompt = "Hello is it me you're looking for?"
timeout = 4.0
while True:
    # some_function()
    s = ti.input(prompt, timeout)
    if s.lower() == 'q':
        print "goodbye"
        break

Вы можете установить будильник перед вводом, а затем привязать его к индивидуальному обработчику. после того, как заданный период времени сработает, обработчик вызовет исключение, и ваша пользовательская функция input может обработать все остальное.
быстрый пример:

import signal
class InputTimedOut(Exception):
    pass

def inputTimeOutHandler(signum, frame):
    "called when read times out"
    print 'interrupted!'
    raise InputTimedOut

signal.signal(signal.SIGALRM, inputTimeOutHandler)

def input_with_timeout(timeout=0):
    foo = ""
    try:
            print 'You have {0} seconds to type in your stuff...'.format(timeout)
            signal.alarm(timeout)
            foo = raw_input()
            signal.alarm(0)    #disable alarm
    except InputTimedOut:
            pass
    return foo

s = input_with_timeout(timeout=3)
print 'You typed', s

Кредит, где это необходимо: Ввод с клавиатуры с тайм-аутом в Python

Я не думаю, что есть способ показать приглашение, которое истечет по прошествии времени, без отображения другого сообщения из другого потока.

Вы можете добавить следующую строку перед вызовом raw_input:

 thread.start_new_thread(interrupt_user,())

Вы можете определить функцию interrupt_user следующим образом:

sleep(5)
print "\nTime up"

В функции raw_input_with_time не вызывайте сон. Вместо этого сохраните время до вызова raw_input и определите, превышает ли время, прошедшее после вызова, 5 секунд. Кроме того, если пользователь ввел «q», он не должен вызывать себя, поэтому цикл остановится.

Другой способ сделать это - разместить блокировку ввода-вывода в новом потоке (в отличие от предложенной вами схемы, в которой она есть в основном потоке). Предостережение для этого заключается в том, что нет чистого способа убить поток в python, поэтому это не очень хорошо с повторяющимися вызовами (N потоков будут зависать до тех пор, пока основной не закончится, и я думаю, что raw_input не работает хорошо ...) .

Итак, будьте осторожны, это сработает один раз, далеко не идеальное решение.

import threading
import Queue

def threaded_raw_input(ret_queue):
    print("In thread")
    prompt = "Hello is it me you're looking for?"
    astring = raw_input(prompt)
    ret_queue.put(astring)

if __name__ == '__main__':
    print("Main")
    ret_queue = Queue.Queue()
    th = threading.Thread(target=threaded_raw_input, args=(ret_queue,))
    th.daemon = True    
    th.start()
    try:
        astring = ret_queue.get(timeout=4)
    except Queue.Empty:
        print("\nToo late")
    else:
        print("Your input {}".format(astring))

Это просто проф концепция. Запрашивает у пользователя входные данные.

import time, os
import curses

def main(win):
    win.nodelay(True)
    x=0
    output=""
    while 1:
        win.clear()
        win.addstr(str("Prompt:"))
        win.addstr(str(output))
        x+=1
        try:
           key = win.getkey()
           if key == os.linesep:
              return output
           output += str(key)
           x = 0             
        except: 
           pass
        if x>=50:  # 5s
           return output
        time.sleep(0.1) 

curses.wrapper(main)

Что, если вместо вызова some_function по истечении времени ожидания ввода вы превратите это в фоновый поток, который продолжает работу с интервалом времени ожидания? Работа будет продолжаться, пока основной поток будет постоянно заблокирован при ожидании ввода. Вы можете по-разному реагировать на этот ввод в зависимости от того, что работник делает (работает или спит) - вы можете просто полностью игнорировать его. AFAIK, нет заметной разницы между тем, чтобы не вводить данные или вводить данные, но игнорировать их. Эта идея использует это.

Примечание. Все, что я намерен сделать, - это продемонстрировать другой способ мышления о проблеме, который может подходить или не подходить в вашем конкретном случае. Хотя я думаю, что это очень гибкий подход.

Подтверждение концепции:

from __future__ import print_function
from threading import Event, Thread
from time import sleep

def some_function():
    print("Running some function")
    sleep(1)

def raw_input_with_timeout():
    cancel_event = Event()
    wip_event = Event() # Only needed to know if working or waiting

    def worker():
        timeout = 4
        try:
            while not cancel_event.is_set():
                wip_event.set()
                some_function()
                print("Repeating unless 'q' is entered within %d secs!" % timeout)
                wip_event.clear()
                cancel_event.wait(timeout)
        finally:
            wip_event.clear()

    worker_thread = Thread(target=worker)
    worker_thread.start()
    try:
        while not cancel_event.is_set():
            try:
                if raw_input() == 'q' and not wip_event.is_set():
                    cancel_event.set()
            except KeyboardInterrupt:
                pass
    finally:
        cancel_event.set()
        worker_thread.join()
    print("Goodbye")

Он не полагается на какую-либо платформу; это просто простой код Python. Только попробовав некоторые альтернативные реализации, принимающие ввод из потока, я понял, насколько преимуществом является то, что пользовательский ввод остается в основном потоке.

Я не уделял слишком много внимания тому, чтобы сделать его безопасным и чистым, но наверняка это можно сделать, сохранив общую структуру. Самый большой недостаток, который я вижу в этом, заключается в том, что предыдущий вклад никогда не исчезнет. Это вызывает путаницу, когда рабочий выводит, скрывая предыдущий ввод. Если вы нажмете q, но не Enter вовремя, нажатие q и Enter в следующий раз приведет к вводу qq, даже если эти q не находятся рядом друг с другом на экране. Обычно так работают приложения командной строки, поэтому я не уверен, стоит ли это исправлять. Вы также можете принять ввод, состоящий только из q, как отмену. Другой вариант - читать напрямую из stdin, не используя raw_input.

Одна из идей сделать структуру кода лучше - сделать основной поток еще более тупым и передать все входные данные рабочему (используя очередь), чтобы решить, что с ним делать.