Comment puis-je faire python attendre une touche enfoncée

Question

Je veux que mon script pour attendre jusqu'à ce que l'utilisateur appuie sur une touche.

Comment puis-je faire?

Answer 1

En Python 3, pas raw_input() existe. Donc, il suffit d'utiliser:

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

En Python 2, vous devez utiliser raw_input(), comme input(prompt) est équivalent à eval(raw_input(prompt)):

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

Ce ne attend que l'utilisateur d'appuyer sur Entrée, donc vous pouvez utiliser msvcrt ((Windows / DOS uniquement) Le module msvcrt vous donne accès à un certain nombre de fonctions dans le Microsoft Visual C / C ++ Runtime Library (MSVCRT)):

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

Cela devrait attendre une touche.

Answer 2

Une façon de le faire en Python 2, est d'utiliser raw_input():

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

Dans python3 il est juste input()

Answer 3

Sur mon linux, j'utilise le code suivant. Ceci est similaire au code que j'ai vu ailleurs (dans les anciens FAQ python par exemple), mais qui tourne le code dans une boucle serrée où ce code ne fonctionne pas et il y a beaucoup de cas d'angle impair que le code ne tient pas compte que ce ne code.

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)

Answer 4

Si vous êtes ok avec le système en fonction des commandes que vous pouvez utiliser les éléments suivants:

Linux:

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

Windows:

os.system("pause")

Answer 5

Il suffit en utilisant

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

provoquera une SyntaxError. EOF prévu lors de l'analyse

Utilisation simple fixe:

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

Answer 6

Le python manuel 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 roulé dans votre cas d'utilisation.

Answer 7

Je ne sais pas d'une plate-forme de manière indépendante de le faire, 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 comprend également la fonction kbhit non-blocage () pour voir si une touche a été pressée sans attendre (pas sûr s'il y a une fonction de malédictions correspondante). Sous UNIX, il y a le paquet malédictions, mais ne savez pas si vous pouvez l'utiliser sans l'utiliser pour tous la sortie de l'é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 () retourne l'ordinal de la touche enfoncée afin de le faire ont la même sortie que je devais jeter.

Answer 8

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 enlevé le fcTL / substance non-bloquant parce qu'il donnait IOErrors et je ne l'ai pas besoin. J'utilise ce code spécifique parce que je veux bloquer. ;)

Answer 9

Si vous voulez attendre entrer (afin que l'utilisateur frappe le clavier ne provoque pas quelque chose non destiné à se produire) utiliser

sys.stdin.readline()

Answer 10

Je suis nouveau à python et je pensais déjà que je suis trop stupide pour reproduire les suggestions les plus simples faites ici. Il se trouve, il y a un piège il faut savoir:

Quand est exécuté un script python de IDLE, certains IO-commandes semblent se comporter complètement différent (car il n'y a en fait aucune fenêtre de terminal).

Par exemple. msvcrt.getch est non-blocage et renvoie toujours ff $. Cela a déjà été signalé depuis longtemps (voir par exemple https://bugs.python.org/issue9290 ) - et il est marqué comme fixe, en quelque sorte le problème semble persister dans les versions actuelles de python / IDLE.

Donc, si tout le code affiché ci-dessus ne fonctionne pas pour vous, essayez d'exécuter le script manuellement, et pas de IDLE .

Answer 11

Si vous voulez voir si elles appuyé sur une touche exacte (comme dire «b) Pour ce faire:

while True:
    choice = raw_input("> ")

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

Answer 12

os.system semble toujours invoquer sh, qui ne reconnaît pas les s et n des options pour la lecture. Cependant, la commande de lecture peut être transmis à bash:

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