Risposte:
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))
input
non continua se si preme un tasto, solo se si preme invio .
Un modo per farlo in Python 2 è usare raw_input()
:
raw_input("Press Enter to continue...")
In python3 è giusto input()
enter
?
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")
system
e quindi chiamare sys.exit(0)
.
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
input
in Python 2: la funzione corretta è raw_input
. In Python 2, input
è equivalente a eval(raw_input())
.
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..."'""")