Comment obtenir les codes d'activation en Python

Question

Je dois savoir ce que touche, mais pas besoin du code du caractère, je veux savoir quand quelqu'un appuyez sur la touche « A », même si la clé obtenue est « a » ou « A », et donc avec toutes les autres clés.

Je ne peux pas utiliser PyGame ou toute autre bibliothèque (y compris Tkinter). Seulement bibliothèque standard Python. Et cela a à faire dans un terminal, pas d'interface graphique.

PAS BESOIN DU CODE DE CARACTERE. JE SAVOIR LE CODE CLÉ.

Ex:

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

Answer 1

Voir TTY module standard. Il permet de passer du mode de ligne à orientation par défaut (cuit) en mode orienté char-(cbreak) avec tty.setcbreak (sys.stdin) . Lecture unique de charbon sys.stdin se traduira dans la clé suivante du clavier emboutie (si elle génère du code):

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

Remarque:. Solution est Unix (y compris Linux) uniquement

Edit: Sous Windows essayer msvcrt.getche () / getwche () . / Moi n'a nulle part d'essayer ...

---

Edit 2: Utiliser Win32 API de la console de bas niveau via ctypes.windll ( voir l'exemple au SO ) avec fonction ReadConsoleInput . Vous devez filtrer les pressions de touche - e.EventType==KEY_EVENT et rechercher la valeur de e.Event.KeyEvent.wVirtualKeyCode. Exemple d'application (pas en Python, juste pour avoir une idée) se trouve à http :. //www.benryves.com/tutorials/ t = WinConsole & c = 4

Answer 2

En fonction de ce que vous essayez d'accomplir, en utilisant peut-être une bibliothèque, comme pygame serait faire ce que vous voulez. Pygame contient la manipulation keypress plus avancée que est normalement disponible avec les bibliothèques standard de Python.

Answer 3

Vous devrez probablement utiliser Tkinter , qui est le Python 'standard' IUG, et a été inclus avec python depuis de nombreuses années.

Une solution de ligne de commande est probablement pas disponible, en raison de la façon dont les données passe dans et hors des processus de ligne de commande. programmes GUI (de un peu de saveur ou d'une autre) tous les recieve entrées utilisateur via un flux d'événements (peut-être enveloppé bibliothèque). Chaque événement sera un compte rendu des détails de l'événement. Pour frappe clavier, l'enregistrement peut contenir tout d'un code d'activation, bitfield touche de modification, ou le caractère de texte dans un codage. Quels sont les domaines, et la façon dont ils sont nommés dépend de la bibliothèque de l'événement que vous appelez.

Programmes de ligne de commande recieve entrée de l'utilisateur par le biais de caractères courants. Il n'y a aucun moyen de données sur les prises de niveau inférieur. Comme Myroslav expliqué dans son poste, ttys peut être en mode cuits ou non cuits, la seule différence étant qu'en mode cuit le terminal traitera (certains) des caractères de contrôle pour vous, comme supprimer et entrer afin que le processus reçoit des lignes d'entrée, au lieu de 1 caractère à la fois.

Traitement quoi que ce soit inférieur à celui qui nécessite (OS à charge) les appels système ou dispositifs de caractère d'ouverture dans / dev. bibliothèque standard de Python ne fournit aucune installation standard pour cela.

Answer 4

Si vous avez besoin de travailler dans les fenêtres que vous devriez essayer msvcrt .

Answer 5

La réponse évidente:

someFunction = string.upper

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

ou, dans d'autres (clés) mots:

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 ...

Voici une implémentation de la fonction getch, qui fonctionnerait dans les deux plates-formes Windows et Linux, base sur cette recette :

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

cette fonction retourne le code pour le caractère majuscule:

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

et c'est le code de caractères minuscules:

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

cette façon est beaucoup plus facile, et vous ne serez pas besoin d'importer des bibliothèques externes.

Vous devrez choisir l'une des deux méthodes pour être le « someFunction » que vous avez décrit dans votre question. Voici un exemple:

SORTIE:

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

>> upCcode('A')
65

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

>> lowCcode('A')
97

Answer 7

Jetez un oeil à pynput Module en Python. Il a également une belle tutoriel l'aide que vous pouvez facilement créer des écouteurs de clavier pour votre code.

L'exemple officiel pour les auditeurs est:

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

Hope this helps.