Clavier de saisie avec délai d'attente en Python

L'exemple que vous avez lié est mauvais et l'exception est en fait se produisant lors de l'appel d'alarme gestionnaire au lieu de quand lire des blocs. Mieux, essayez ceci:

import signal
TIMEOUT = 5 # number of seconds your want for timeout

def interrupted(signum, frame):
    "called when read times out"
    print 'interrupted!'
signal.signal(signal.SIGALRM, interrupted)

def input():
    try:
            print 'You have 5 seconds to type in your stuff...'
            foo = raw_input()
            return foo
    except:
            # timeout
            return

# set alarm
signal.alarm(TIMEOUT)
s = input()
# disable the alarm after success
signal.alarm(0)
print 'You typed', s

Pas un Python solution, mais...

J'ai couru dans, à ce problème avec un script qui s'exécute sous CentOS (Linux), et ce qui a fonctionné pour ma situation était en cours d'exécution juste le Bash "lire -t" de la commande dans un sous-processus. Brutal dégoûtant hack, je sais, mais je me sens coupable, assez sur la façon dont il a travaillé, que je voulais partager avec tout le monde ici.

import subprocess
subprocess.call('read -t 30', shell=True)

Avais-je besoin de quelque chose, qui ont attendu pendant 30 secondes, à moins que la touche ENTRÉE est enfoncée. Cela a très bien fonctionné.

Paul réponse n'a pas assez de travail. Modifié le code ci-dessous qui fonctionne pour moi sur

• windows 7 x64

• vanille CMD shell (par exemple, pas git-bash ou d'autres non-M$ shell)

  -- rien msvcrt travaille dans git-bash il apparaît.

• python 3.6

(Je suis de poster une nouvelle réponse, parce que l'édition de Paul répond directement allait changer à partir de python 2.x-->3.x, ce qui semble trop pour un point de montage (py2 est encore en usage)

import sys, time, msvcrt

def readInput( caption, default, timeout = 5):

    start_time = time.time()
    sys.stdout.write('%s(%s):'%(caption, default))
    sys.stdout.flush()
    input = ''
    while True:
        if msvcrt.kbhit():
            byte_arr = msvcrt.getche()
            if ord(byte_arr) == 13: # enter_key
                break
            elif ord(byte_arr) >= 32: #space_char
                input += "".join(map(chr,byte_arr))
        if len(input) == 0 and (time.time() - start_time) > timeout:
            print("timing out, using default value.")
            break

    print('')  # needed to move to next line
    if len(input) > 0:
        return input
    else:
        return default

# and some examples of usage
ans = readInput('Please type a name', 'john') 
print( 'The name is %s' % ans)
ans = readInput('Please enter a number', 10 ) 
print( 'The number is %s' % ans) 

Code suivant a travaillé pour moi.

J'ai utilisé deux fils l'un à obtenir le raw_Input et un autre à attendre pendant un temps précis.
Si l'un des quitte thread, le thread est terminé et est retourné.

def _input(msg, q):
    ra = raw_input(msg)
    if ra:
        q.put(ra)
    else:
        q.put("None")
    return

def _slp(tm, q):
    time.sleep(tm)
    q.put("Timeout")
    return

def wait_for_input(msg="Press Enter to continue", time=10):
    q = Queue.Queue()
    th = threading.Thread(target=_input, args=(msg, q,))
    tt = threading.Thread(target=_slp, args=(time, q,))

    th.start()
    tt.start()
    ret = None
    while True:
        ret = q.get()
        if ret:
            th._Thread__stop()
            tt._Thread__stop()
            return ret
    return ret

print time.ctime()    
t= wait_for_input()
print "\nResponse :",t 
print time.ctime()

Ici est un portable simple et Python 3 solution à l'aide de threads.
C'est la seule qui a fonctionné pour moi, tout en étant de la croix-plate-forme.

D'autres choses que j'ai essayé tous les problèmes:

• À l'aide du signal.SIGALRM: ne fonctionne pas sur Windows
• À l'aide de select appel: ne fonctionne pas sur Windows
• L'aide de la force à la fin d'un processus (au lieu de fil): stdin ne peut pas être utilisé dans le nouveau processus (stdin est auto-fermé)
• La Redirection de l'entrée standard stdin à StringIO et écrit directement à stdin: va encore écrire à la précédente stdin si input() a déjà été appelée (voir https://stackoverflow.com/a/15055639/9624704)

    from threading import Thread
    class myClass:
        _input = None

        def __init__(self):
            get_input_thread = Thread(target=self.get_input)
            get_input_thread.daemon = True  # Otherwise the thread won't be terminated when the main program terminates.
            get_input_thread.start()
            get_input_thread.join(timeout=20)

            if myClass._input is None:
                print("No input was given within 20 seconds")
            else:
                print("Input given was: {}".format(myClass._input))


        @classmethod
        def get_input(cls):
            cls._input = input("")
            return

Une réponse tardive 🙂

Je voudrais faire quelque chose comme ceci:

from time import sleep

print('Please provide input in 20 seconds! (Hit Ctrl-C to start)')
try:
    for i in range(0,20):
        sleep(1) # could use a backward counter to be preeety :)
    print('No input is given.')
except KeyboardInterrupt:
    raw_input('Input x:')
    print('You, you! You know something.')

Je sais que ce n'est pas le même, mais beaucoup de la vie réelle problème pourrait être résolu de cette façon. (Habituellement, j'ai besoin de timeout pour la saisie de l'utilisateur, quand je veux quelque chose de continuer à courir, si l'utilisateur n'est pas là pour le moment.)

Espérons que cela, au moins partiellement, aide. (Si quelqu'un lit ça de toute façon 🙂 )