Como obter os códigos de tecla em Python

Question

Eu tenho que saber o que tecla é pressionada, mas não precisa do código do personagem, eu quero saber quando alguém pressione a tecla 'A', mesmo se a chave obtida é 'a' ou 'A', e assim com todas as outras chaves.

Eu não posso usar PyGame ou qualquer outra biblioteca (incluindo Tkinter). Apenas biblioteca padrão Python. E isso tem que ser feito em um, não uma interface gráfica terminal.

não precisa do código de caracteres. Eu preciso saber o código da chave.

Ex:

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

Answer 1

tty módulo padrão. Ele permite a passagem de modo orientado por linhas padrão (cozido) em modo orientada para o carvão animal (cbreak) com tty.setcbreak (sys.stdin) . Leitura único caractere de sys.stdin irá resultar na próxima tecla do teclado pressionado (se ele gera código):

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

Nota:. Solução é Unix (incluindo Linux), apenas

Edit: No Windows tentar msvcrt.getche () / getwche () . / Me tem onde tentar ...

---

Edit 2: Utilizar win32 baixo nível consola API via ctypes.windll ( ver no SO ) com função ReadConsoleInput . Você deve filtrar keypresses - e.EventType==KEY_EVENT e olhar para o valor e.Event.KeyEvent.wVirtualKeyCode. Exemplo de aplicação (e não em Python, só para ter uma idéia) podem ser encontradas em http :?. //www.benryves.com/tutorials/ t = WinConsole & c = 4

Answer 2

Dependendo do que você está tentando realizar, talvez usando uma biblioteca, como pygame iria fazer o que quiser. Pygame contém manuseio keypress mais avançado do que normalmente está disponível com bibliotecas padrão do Python.

Answer 3

Você provavelmente terá que usar Tkinter , que é o Python gui 'standard', e foi incluído com python por muitos anos.

Uma solução de linha de comando é, provavelmente, não disponível, devido à forma como os dados passam para dentro e fora dos processos de linha de comando. programas GUI (de algum sabor ou outro) tudo recieve de entrada do usuário através de um fluxo de eventos (possivelmente biblioteca envolto). Cada evento será um registro de detalhes do evento. Para eventos de teclas, o registro vai pode conter qualquer de um código de acesso, modificador bitfield chave, ou caracteres de texto em alguns codificação. Quais campos, e como eles são nomeados depende da biblioteca de evento que você está chamando.

programas de linha de comando recebem a entrada do usuário através de personagens-fluxos. Não há maneira de recuperar dados de nível mais baixo. Como Myroslav explicou em seu post, do tty pode estar no modo cozidos ou crus, a única diferença é que no modo cozidos os terminais processo (alguns) caracteres de controle para você, como apagar e entrar para que o processo recebe linhas de entrada, em vez de 1 carácter de cada vez.

Processamento de qualquer coisa menor do que requer (dependentes OS) chamadas de sistema ou dispositivos de caracteres de abertura em / dev. biblioteca padrão do Python fornece nenhuma facilidade padrão para isso.

Answer 4

Se você precisa trabalhar em janelas só você deve tentar msvcrt .

Answer 5

A resposta óbvia:

someFunction = string.upper

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

ou, em outras palavras (chave):

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

etc ...

Aqui está uma implementação da função getch, que iria trabalhar em ambas as plataformas Windows e Linux, base sobre esta receita :

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

Esta função irá retornar o código para o caractere maiúsculo:

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

e este é o código de caractere minúsculo:

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

Desta forma é muito mais fácil, e você não precisará importar bibliotecas externas.

Você terá que escolher um dos dois métodos para ser o 'someFunction' você descreveu na sua pergunta. Aqui está um exemplo:

SAÍDA:

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

>> upCcode('A')
65

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

>> lowCcode('A')
97

Answer 7

Dê uma olhada pynput módulo em Python. Ele também tem uma boa tutorial usando o que você pode facilmente criar ouvintes de teclado para seu código.

O exemplo oficial para os ouvintes é:

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

Espero que isso ajude.