Come ottenere i keycodes in Python

Question

Devo sapere quale tasto viene premuto, ma non è necessario il codice del carattere, voglio sapere quando qualcuno premere il tasto 'A', anche se la chiave si ottiene è 'a' o 'A', e così con tutti gli altri tasti.

Non posso usare PyGame o qualsiasi altra libreria (tra cui Tkinter). Solo Python Standard Library. E questo deve essere fatto in un terminale, non è un'interfaccia grafica.

Non è necessario il codice di carattere. Ho bisogno di conoscere il codice della chiave.

Esempio:

ord('a') != ord('A')                      # 97 != 65
someFunction('a') == someFunction('A')    # a_code == A_code

Answer 1

TTY modulo standard. Esso permette di passare dalla modalità predefinita linea orientata (cotto) in modalità char-oriented (cbreak) con tty.setcbreak (sys.stdin) . Leggendo singolo carattere da sys.stdin si tradurrà in prossimo tasto della tastiera premuto (se genera il codice):

import sys
import tty
tty.setcbreak(sys.stdin)
while True:
    print ord(sys.stdin.read(1))

Nota. Soluzione è Unix (compreso Linux) solo

Modifica: Su Windows prova a msvcrt.getche () / getwche () . / Me ha un posto dove provare ...

---

Modifica 2: Utilizzare win32 basso livello console API tramite ctypes.windll ( vedi esempio a SO ) con funzione ReadConsoleInput . Si dovrebbe filtrare i tasti premuti - e.EventType==KEY_EVENT e potete trovare il valore e.Event.KeyEvent.wVirtualKeyCode. Esempio di applicazione (non in Python, solo per avere un'idea) sono disponibili all'indirizzo http :?. //www.benryves.com/tutorials/ t = winconsole & c = 4

Answer 2

A seconda di ciò che si sta cercando di realizzare, magari utilizzando una libreria come Pygame sarebbe fare quello che vuoi. Pygame contiene una gestione più avanzata pressione di un tasto di quanto sia normalmente disponibile con le librerie standard di Python.

Answer 3

Probabilmente dovrà utilizzare Tkinter , che è lo 'standard' Python gui, ed è stato incluso in pitone per molti anni.

Una soluzione a riga di comando non è probabilmente disponibili, a causa del modo in cui i dati passano dentro e fuori dei processi della riga di comando. programmi GUI (di qualche sapore o altro) tutti gli input degli utenti Ricevere attraverso un flusso evento (possibilmente libreria avvolto). Ogni evento sarà un record di dettagli dell'evento. Per gli eventi di tasti, il record si può contenere qualsiasi di un codice chiave, modificatore di campo di bit chiave, o di carattere di testo in qualche codifica. Quali campi, e come essi sono chiamati dipende la biblioteca evento che si sta chiamando.

programmi della riga di comando ricevono l'input dell'utente attraverso dei personaggi-stream. Non v'è alcun modo per catturare i dati di livello inferiore. Come Myroslav ha spiegato nel suo post, tty può essere in modalità cotti e crudi, con l'unica differenza che in modalità cotto il terminale elaborerà (alcuni) caratteri di controllo per voi, come cancellare e inserire in modo che il processo riceve linee di ingresso, invece di 1 carattere alla volta.

Elaborazione nulla inferiore che richiede chiamate di sistema (OS dipendente) o dispositivi a carattere di apertura in / dev. libreria standard di Python fornisce nessun impianto standard per questo.

Answer 4

Se avete bisogno di lavorare in finestre solo si dovrebbe provare a MSVCRT .

Answer 5

L'ovvia risposta:

someFunction = string.upper

ord('a') != ord('A')                      # 97 != 65
someFunction('a') == someFunction('A')    # a_code == A_code

o, in altre parole (chiave):

char_from_user = getch().upper() # read a char converting to uppercase
if char == 'Q':
    # quit
    exit = True # or something
elif char in ['A', 'K']:
    do_something()

ecc ...

Ecco un'implementazione della funzione getch, che avrebbe funzionato in entrambe le piattaforme Windows e Linux, rel="nofollow in questa ricetta :

class _Getch(object):
    """Gets a single character from standard input.  
       Does not echo to the screen."""
    def __init__(self):
        try:
            self.impl = _GetchWindows()
        except ImportError:
            self.impl = _GetchUnix()

    def __call__(self): 
        return self.impl()

class _GetchUnix(object):
    def __init__(self):
        import tty, sys

    def __call__(self):
        import sys, tty, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch


class _GetchWindows(object):
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        return msvcrt.getch()


getch = _Getch()

Answer 6

Questa funzione restituisce il codice per il carattere maiuscolo:

def upCcode( ch ):
    if(len(ch) == 1):
        return ord(ch.upper())

e questo è per il codice di carattere minuscolo:

def lowCcode( ch ):
        if(len(ch) == 1):
            return ord(ch.lower())

in questo modo è molto più facile, e non avrà bisogno di importare librerie esterne.

Sarà necessario scegliere uno dei due metodi per essere il 'someFunction' hai descritto nella sua interrogazione. Ecco un esempio:

USCITA:

# when using upCode():
>> upCcode('a')
65

>> upCcode('A')
65

# when using lowCode():
>> lowCcode('a')
97

>> lowCcode('A')
97

Answer 7

Date un'occhiata a pynput modulo in Python. Essa ha anche un bel esercitazione con cui è possibile creare facilmente ascoltatori da tastiera per il vostro codice.

L'esempio ufficiale per gli ascoltatori è:

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()

Spero che questo aiuti.