détecter une pression sur une touche en python?

Je crée un programme de type chronomètre en python et j'aimerais savoir comment détecter si une touche est enfoncée (comme p pour pause et s pour stop), et je n'aimerais pas que ce soit quelque chose comme raw_input qui attend le entrée de l'utilisateur avant de poursuivre l'exécution. Quelqu'un sait comment faire cela dans une boucle while?

Aussi, j'aimerais créer cette multiplateforme, mais si ce n'est pas possible, ma principale cible de développement est linux

Python a un module clavier avec de nombreuses fonctionnalités. Installez-le, peut-être avec cette commande:

pip3 install keyboard

Ensuite, utilisez-le dans du code comme:

import keyboard  # using module keyboard
while True:  # making a loop
    try:  # used try so that if user pressed other than the given key error will not be shown
        if keyboard.is_pressed('q'):  # if key 'q' is pressed 
            print('You Pressed A Key!')
            break  # finishing the loop
    except:
        break  # if user pressed a key other than the given key the loop will break

Pour ceux qui sont sous windows et qui ont du mal à trouver une réponse fonctionnelle, voici la mienne: pynput

from pynput.keyboard import Key, Listener

def on_press(key):
    print('{0} pressed'.format(
        key))

def on_release(key):
    print('{0} release'.format(
        key))
    if key == Key.esc:
        # Stop listener
        return False

# Collect events until released
with Listener(
        on_press=on_press,
        on_release=on_release) as listener:
    listener.join()

La fonction ci-dessus imprime la touche sur laquelle vous appuyez et lance une action lorsque vous relâchez la touche «esc». La documentation du clavier est ici pour une utilisation plus variée.

Markus von Broady a mis en évidence un problème potentiel qui est: Cette réponse ne nécessite pas que vous soyez dans la fenêtre actuelle pour que ce script soit activé, une solution aux fenêtres serait:

from win32gui import GetWindowText, GetForegroundWindow
current_window = (GetWindowText(GetForegroundWindow()))
desired_window_name = "Stopwatch" #Whatever the name of your window should be

#Infinite loops are dangerous.
while True: #Don't rely on this line of code too much and make sure to adapt this to your project.
    if current_window == desired_window_name:

        with Listener(
            on_press=on_press,
            on_release=on_release) as listener:
            listener.join()

Comme OP le mentionne à propos de raw_input - cela signifie qu'il veut une solution cli. Linux: les malédictions sont ce que vous voulez (windows PDCurses). Curses, est une API graphique pour le logiciel cli, vous pouvez réaliser plus que simplement détecter les événements clés.

Ce code détectera les touches jusqu'à ce qu'une nouvelle ligne soit pressée.

import curses
import os

def main(win):
    win.nodelay(True)
    key=""
    win.clear()                
    win.addstr("Detected key:")
    while 1:          
        try:                 
           key = win.getkey()         
           win.clear()                
           win.addstr("Detected key:")
           win.addstr(str(key)) 
           if key == os.linesep:
              break           
        except Exception as e:
           # No input   
           pass         

curses.wrapper(main)

Il y a plus de choses qui peuvent être faites avec keyboardmodule.

Voici quelques méthodes:

Méthode n ° 1:

Utilisation de la fonction read_key():

import keyboard

while True:
    if keyboard.read_key() == "p":
        print("You pressed p")
        break

Cela va casser la boucle lorsque la touche pest enfoncée.

Méthode n ° 2:

Utilisation de la fonction wait:

import keyboard

keyboard.wait("p")
print("You pressed p")

Il attendra que vous appuyiez sur pet continuera le code pendant qu'il est enfoncé.

Méthode n ° 3:

Utilisation de la fonction on_press_key:

import keyboard

keyboard.on_press_key("p", lambda _:print("You pressed p"))

Il a besoin d'une fonction de rappel. J'ai utilisé _parce que la fonction clavier renvoie l'événement clavier à cette fonction.

Une fois exécuté, il exécutera la fonction lorsque la touche sera enfoncée. Vous pouvez arrêter tous les hooks en exécutant cette ligne:

keyboard.unhook_all()

Méthode n ° 4:

Cette méthode est en quelque sorte déjà répondue par user8167727 mais je ne suis pas d'accord avec le code qu'ils ont créé. Il utilisera la fonction is_pressedmais d'une autre manière:

import keyboard

while True:
    if keyboard.is_pressed("p"):
        print("You pressed p")
        break

Cela cassera la boucle lorsque vous pappuyez sur.

Remarques:

• keyboard lira les pressions sur les touches de l'ensemble du système d'exploitation.
• keyboard nécessite root sur linux

Pour Windows, vous pouvez utiliser msvcrtcomme ceci:

   import msvcrt
   while True:
       if msvcrt.kbhit():
           key = msvcrt.getch()
           print(key)   # just to show the result

Utilisez ce code pour trouver la touche enfoncée

from pynput import keyboard

def on_press(key):
    try:
        print('alphanumeric key {0} pressed'.format(
            key.char))
    except AttributeError:
        print('special key {0} pressed'.format(
            key))

def on_release(key):
    print('{0} released'.format(
        key))
    if key == keyboard.Key.esc:
        # Stop listener
        return False

# Collect events until released
with keyboard.Listener(
        on_press=on_press,
        on_release=on_release) as listener:
    listener.join()

Utilisez PyGame pour avoir une fenêtre et ensuite vous pouvez obtenir les événements clés.

Pour la lettre p:

import pygame, sys
import pygame.locals

pygame.init()
BLACK = (0,0,0)
WIDTH = 1280
HEIGHT = 1024
windowSurface = pygame.display.set_mode((WIDTH, HEIGHT), 0, 32)

windowSurface.fill(BLACK)

while True:
    for event in pygame.event.get():
        if event.key == pygame.K_p: # replace the 'p' to whatever key you wanted to be pressed
             pass #Do what you want to here
        if event.type == pygame.locals.QUIT:
             pygame.quit()
             sys.exit()

J'ai donc créé ce .. genre de jeu .. basé sur ce post (en utilisant la bibliothèque msvcr et Python 3.7).

Voici la "fonction principale" du jeu, qui consiste à détecter les touches enfoncées:

# Requiered libraries - - - -
import msvcrt
# - - - - - - - - - - - - - -


def _secret_key(self):
    # Get the key pressed by the user and check if he/she wins.

    bk = chr(10) + "-"*25 + chr(10)

    while True:

        print(bk + "Press any key(s)" + bk)
        #asks the user to type any key(s)

        kp = str(msvcrt.getch()).replace("b'", "").replace("'", "")
        # Store key's value.

        if r'\xe0' in kp:
            kp += str(msvcrt.getch()).replace("b'", "").replace("'", "")
            # Refactor the variable in case of multi press.

        if kp == r'\xe0\x8a':
            # If user pressed the secret key, the game ends.
            # \x8a is CTRL+F12, that's the secret key.

            print(bk + "CONGRATULATIONS YOU PRESSED THE SECRET KEYS!\a" + bk)
            print("Press any key to exit the game")
            msvcrt.getch()
            break
        else:
            print("    You pressed:'", kp + "', that's not the secret key(s)\n")
            if self.select_continue() == "n":
                if self.secondary_options():
                    self._main_menu()
                break

Si vous voulez le code source complet du porgram, vous pouvez le voir ou le télécharger à partir d'ici:

Le jeu de clé secrète (GitHub)

(note: la touche secrète est: Ctrl+ F12)

J'espère que vous pourrez servir d'exemple et d'aider ceux qui viennent consulter ces informations.

Je vous suggère d'utiliser PyGame et d'ajouter un handle d'événement.

http://www.pygame.org/docs/ref/event.html

key = cv2.waitKey(1)

Ceci provient du package openCV. Il détecte une pression sur une touche sans attendre.