Come faccio a far aspettare Python per un tasto premuto?

Voglio che il mio script attenda fino a quando l'utente preme un tasto qualsiasi.

Come lo faccio?

In Python 3 usare input():

input("Press Enter to continue...")

In Python 2 usa raw_input():

raw_input("Press Enter to continue...")

Ciò attende solo che l'utente prema Invio.

Si consiglia di utilizzare msvcrt ((solo Windows / DOS) Il modulo msvcrt consente di accedere a una serie di funzioni nella libreria Microsoft Visual C / C ++ Runtime (MSVCRT)):

import msvcrt as m
def wait():
    m.getch()

Questo dovrebbe attendere la pressione di un tasto.

Informazioni addizionali:

in Python 3 raw_input()non esiste

In Python 2 input(prompt)è equivalente aeval(raw_input(prompt))

Un modo per farlo in Python 2 è usare raw_input():

raw_input("Press Enter to continue...")

In python3 è giusto input()

Sulla mia scatola di Linux, uso il seguente codice. Questo è simile al codice che ho visto altrove (ad esempio nelle vecchie FAQ di Python) ma quel codice gira in un circuito stretto dove questo codice non lo fa e ci sono molti casi angolari strani che il codice non tiene conto di ciò il codice lo fa.

def read_single_keypress():
    """Waits for a single keypress on stdin.

    This is a silly function to call if you need to do it a lot because it has
    to store stdin's current setup, setup stdin for reading single keystrokes
    then read the single keystroke then revert stdin back after reading the
    keystroke.

    Returns a tuple of characters of the key that was pressed - on Linux, 
    pressing keys like up arrow results in a sequence of characters. Returns 
    ('\x03',) on KeyboardInterrupt which can happen when a signal gets
    handled.

    """
    import termios, fcntl, sys, os
    fd = sys.stdin.fileno()
    # save old state
    flags_save = fcntl.fcntl(fd, fcntl.F_GETFL)
    attrs_save = termios.tcgetattr(fd)
    # make raw - the way to do this comes from the termios(3) man page.
    attrs = list(attrs_save) # copy the stored version to update
    # iflag
    attrs[0] &= ~(termios.IGNBRK | termios.BRKINT | termios.PARMRK
                  | termios.ISTRIP | termios.INLCR | termios. IGNCR
                  | termios.ICRNL | termios.IXON )
    # oflag
    attrs[1] &= ~termios.OPOST
    # cflag
    attrs[2] &= ~(termios.CSIZE | termios. PARENB)
    attrs[2] |= termios.CS8
    # lflag
    attrs[3] &= ~(termios.ECHONL | termios.ECHO | termios.ICANON
                  | termios.ISIG | termios.IEXTEN)
    termios.tcsetattr(fd, termios.TCSANOW, attrs)
    # turn off non-blocking
    fcntl.fcntl(fd, fcntl.F_SETFL, flags_save & ~os.O_NONBLOCK)
    # read a single keystroke
    ret = []
    try:
        ret.append(sys.stdin.read(1)) # returns a single character
        fcntl.fcntl(fd, fcntl.F_SETFL, flags_save | os.O_NONBLOCK)
        c = sys.stdin.read(1) # returns a single character
        while len(c) > 0:
            ret.append(c)
            c = sys.stdin.read(1)
    except KeyboardInterrupt:
        ret.append('\x03')
    finally:
        # restore old state
        termios.tcsetattr(fd, termios.TCSAFLUSH, attrs_save)
        fcntl.fcntl(fd, fcntl.F_SETFL, flags_save)
    return tuple(ret)

Se si è d'accordo con i comandi di sistema, è possibile utilizzare quanto segue:

Linux:

import os
os.system('read -sn 1 -p "Press any key to continue..."')
print

Finestre:

import os
os.system("pause")

Semplicemente usando

input("Press Enter to continue...")

causerà un SyntaxError: EOF previsto durante l'analisi.

Utilizzo semplice della correzione:

try:
    input("Press enter to continue")
except SyntaxError:
    pass

Il manuale di Python fornisce quanto segue:

import termios, fcntl, sys, os
fd = sys.stdin.fileno()

oldterm = termios.tcgetattr(fd)
newattr = termios.tcgetattr(fd)
newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
termios.tcsetattr(fd, termios.TCSANOW, newattr)

oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)

try:
    while 1:
        try:
            c = sys.stdin.read(1)
            print "Got character", repr(c)
        except IOError: pass
finally:
    termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)

che può essere inserito nel tuo caso d'uso.

Cross Platform, codice Python 2/3:

# import sys, os

def wait_key():
    ''' Wait for a key press on the console and return it. '''
    result = None
    if os.name == 'nt':
        import msvcrt
        result = msvcrt.getch()
    else:
        import termios
        fd = sys.stdin.fileno()

        oldterm = termios.tcgetattr(fd)
        newattr = termios.tcgetattr(fd)
        newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
        termios.tcsetattr(fd, termios.TCSANOW, newattr)

        try:
            result = sys.stdin.read(1)
        except IOError:
            pass
        finally:
            termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)

    return result

Ho rimosso la roba fctl / non bloccante perché stava dando IOError se non ne avevo bisogno. Sto usando questo codice specificamente perché voglio che si blocchi. ;)

Addendum:

Ho implementato questo in un pacchetto su PyPI con molti altri gadget chiamati console :

>>> from console.utils import wait_key

>>> wait_key()
'h'

Non conosco un modo indipendente dalla piattaforma per farlo, ma in Windows, se usi il modulo msvcrt, puoi usare la sua funzione getch:

import msvcrt
c = msvcrt.getch()
print 'you entered', c

mscvcrt include anche la funzione kbhit () non bloccante per vedere se un tasto è stato premuto senza attendere (non sono sicuro che ci sia una funzione curses corrispondente). Sotto UNIX, c'è il pacchetto curses, ma non sono sicuro se puoi usarlo senza usarlo per tutto l'output dello schermo. Questo codice funziona sotto UNIX:

import curses
stdscr = curses.initscr()
c = stdscr.getch()
print 'you entered', chr(c)
curses.endwin()

Nota che curses.getch () restituisce l'ordinale del tasto premuto in modo da avere lo stesso output che ho dovuto lanciare.

Se si desidera attendere l'invio (quindi l'utente che bussa alla tastiera non provoca un evento indesiderato) utilizzare

sys.stdin.readline()

Sono nuovo di Python e stavo già pensando di essere troppo stupido per riprodurre i suggerimenti più semplici fatti qui. Si scopre, c'è una trappola che uno dovrebbe sapere:

Quando uno script Python viene eseguito da IDLE, alcuni comandi IO sembrano comportarsi in modo completamente diverso (poiché in realtà non esiste una finestra terminale).

Per esempio. msvcrt.getch non è bloccante e restituisce sempre $ ff. Questo è già stato segnalato molto tempo fa (vedi ad esempio https://bugs.python.org/issue9290 ) - ed è contrassegnato come risolto, in qualche modo il problema sembra persistere nelle attuali versioni di python / IDLE.

Quindi, se uno qualsiasi dei codici pubblicati sopra non funziona per te, prova a eseguire lo script manualmente e NON da IDLE .

Se vuoi vedere se hanno premuto un tasto esatto (come dire 'b') Fai questo:

while True:
    choice = raw_input("> ")

    if choice == 'b' :
        print "You win"
        input("yay")
        break

os.system sembra sempre invocare sh, che non riconosce le opzioni s e n per la lettura. Tuttavia, il comando read può essere passato a bash:

 os.system("""bash -c 'read -s -n 1 -p "Press any key to continue..."'""")