Réponses:
Dans Python 3, utilisez input()
:
input("Press Enter to continue...")
Dans Python 2, utilisez raw_input()
:
raw_input("Press Enter to continue...")
Cependant, cela n'attend que l'utilisateur pour appuyer sur Entrée.
On peut vouloir utiliser msvcrt ((Windows / DOS uniquement) Le module msvcrt vous donne accès à un certain nombre de fonctions dans la bibliothèque d'exécution Microsoft Visual C / C ++ (MSVCRT)):
import msvcrt as m
def wait():
m.getch()
Cela devrait attendre une pression sur une touche.
Information additionnelle:
en Python 3 raw_input()
n'existe pas
En Python 2 input(prompt)
est équivalent àeval(raw_input(prompt))
input
ne continue pas si vous appuyez sur une touche, uniquement si vous appuyez sur Entrée.
Une façon de faire cela en Python 2, est d'utiliser raw_input()
:
raw_input("Press Enter to continue...")
En python3 c'est juste input()
enter
?
input()
.
Sur ma boîte Linux, j'utilise le code suivant. Ceci est similaire au code que j'ai vu ailleurs (dans les anciennes FAQ python par exemple) mais ce code tourne dans une boucle serrée où ce code ne fonctionne pas et il y a beaucoup de cas de coins étranges que le code ne tient pas compte de cela le code le fait.
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)
Si vous êtes d'accord avec les commandes système, vous pouvez utiliser les éléments suivants:
Linux:
import os
os.system('read -sn 1 -p "Press any key to continue..."')
print
Les fenêtres:
import os
os.system("pause")
system
puis appeler sys.exit(0)
.
Simplement en utilisant
input("Press Enter to continue...")
provoquera une SyntaxError: EOF attendue lors de l'analyse.
Utilisation simple du correctif:
try:
input("Press enter to continue")
except SyntaxError:
pass
input
en python 2 - la fonction correcte est raw_input
. En python 2, input
est équivalent à eval(raw_input())
.
Le manuel python fournit les éléments suivants:
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)
qui peut être intégré dans votre cas d'utilisation.
Cross Platform, code 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
J'ai supprimé le fctl / non-blocking parce qu'il donnait des IOError
s et je n'en avais pas besoin. J'utilise ce code spécifiquement parce que je veux qu'il se bloque. ;)
Addenda:
J'ai implémenté cela dans un package sur PyPI avec beaucoup d'autres goodies appelés console :
>>> from console.utils import wait_key
>>> wait_key()
'h'
Je ne connais pas de méthode indépendante de la plateforme, mais sous Windows, si vous utilisez le module msvcrt, vous pouvez utiliser sa fonction getch:
import msvcrt
c = msvcrt.getch()
print 'you entered', c
mscvcrt inclut également la fonction kbhit () non bloquante pour voir si une touche a été enfoncée sans attendre (pas sûr qu'il y ait une fonction curses correspondante). Sous UNIX, il y a le paquet curses, mais je ne sais pas si vous pouvez l'utiliser sans l'utiliser pour toute la sortie d'écran. Ce code fonctionne sous UNIX:
import curses
stdscr = curses.initscr()
c = stdscr.getch()
print 'you entered', chr(c)
curses.endwin()
Notez que curses.getch () renvoie l'ordinal de la touche enfoncée afin de lui donner la même sortie que je devais la transtyper.
Si vous voulez attendre la saisie (afin que l'utilisateur ne frappe pas le clavier, il ne se produira pas quelque chose d'inattendu), utilisez
sys.stdin.readline()
Je suis nouveau sur python et je pensais déjà que je suis trop stupide pour reproduire les suggestions les plus simples faites ici. Il s'avère qu'il y a un écueil à savoir:
Lorsqu'un script python est exécuté depuis IDLE, certaines commandes IO semblent se comporter complètement différemment (car il n'y a en fait pas de fenêtre de terminal).
Par exemple. msvcrt.getch n'est pas bloquant et renvoie toujours $ ff. Cela a déjà été signalé il y a longtemps (voir par exemple https://bugs.python.org/issue9290 ) - et il est marqué comme corrigé, le problème semble en quelque sorte persister dans les versions actuelles de python / IDLE.
Donc, si l'un des codes publiés ci-dessus ne fonctionne pas pour vous, essayez d'exécuter le script manuellement, et NON depuis IDLE .
Si vous voulez voir s'ils ont appuyé sur une touche exacte (comme dire «b»), procédez comme suit:
while True:
choice = raw_input("> ")
if choice == 'b' :
print "You win"
input("yay")
break
os.system semble invoquer toujours sh, qui ne reconnaît pas les options s et n pour la lecture. Cependant la commande read peut être passée à bash:
os.system("""bash -c 'read -s -n 1 -p "Press any key to continue..."'""")