Quelle est la façon la plus simple de détection d'entrée de clavier de python dans le terminal?

L'un de la façon la plus simple que j'ai trouvé est d'utiliser pynput module.peuvent être trouvés ici avec de beaux exemples

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

ci-dessus est l'exemple a travaillé pour moi et pour l'installer, allez


pour python 2:

    pip install pynput

pour python 3:

    pip3 install pynput

Ces fonctions, basé sur la ci-dessus, semblent bien fonctionner pour obtenir des caractères à partir du clavier (bloquants et non bloquants):

import termios, fcntl, sys, os

def get_char_keyboard():
  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)

  c = None
  try:
    c = sys.stdin.read(1)
  except IOError: pass

  termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)

  return c

def get_char_keyboard_nonblock():
  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)

  c = None

  try:
    c = sys.stdin.read(1)
  except IOError: pass

  termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
  fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)

  return c

Je l'ai écrit plus facile à utiliser mise en œuvre pour @enrico.bacis de réponse. Il prend en charge de Linux(python2.7 et python3.5) et Windows(python2.7). Il peut prendre en charge Mac OS, mais je n'ai pas le tester. Si vous avez essayé sur un Mac, s'il vous plaît dites-moi le résultat.

'''
Author: Yu Lou
Date: 2017-02-23
Based on the answer by @enrico.bacis in http://stackoverflow.com/a/13207724/4398908
and @Phylliida in http://stackoverflow.com/a/31736883/4398908
'''
# Import modules
try:
try:
import termios, fcntl, sys, os, curses # Import modules for Linux
except ImportError:
import msvcrt # Import module for Windows
except ImportError:
raise Exception('This platform is not supported.')
class KeyGetterLinux:
'''
Implemented kbhit(), getch() and getchar() in Linux.
Tested on Ubuntu 16.10(Linux 4.8.0), Python 2.7.12 and Python 3.5.2
'''
def __init__(self):
self.buffer = '' # A buffer to store the character read by kbhit
self.started = False # Whether initialization is complete
def kbhit(self, echo = False):
'''
Return whether a key is hitten.
'''
if not self.buffer:
if echo:
self.buffer = self.getchar(block = False)
else:
self.buffer = self.getch(block = False)
return bool(self.buffer)
def getch(self, block = True):
'''
Return a single character without echo.
If block is False and no input is currently available, return an empty string without waiting.
'''
try:
curses.initscr()
curses.noecho()
return self.getchar(block)
finally:
curses.endwin()
def getchar(self, block = True):
'''
Return a single character and echo.
If block is False and no input is currently available, return an empty string without waiting.
'''
self._start()
try:
return self._getchar(block)
finally:
self._stop()
def _getchar(self, block = True):
'''
Return a single character and echo.
If block is False and no input is currently available, return a empty string without waiting.
Should be called between self._start() and self._end()
'''
assert self.started, ('_getchar() is called before _start()')
# Change the terminal setting
if block:
fcntl.fcntl(self.fd, fcntl.F_SETFL, self.old_flags & ~os.O_NONBLOCK)
else:
fcntl.fcntl(self.fd, fcntl.F_SETFL, self.old_flags | os.O_NONBLOCK)
if self.buffer: # Use the character in buffer first
result = self.buffer
self.buffer = ''
else:
try:
result = sys.stdin.read(1)
except IOError: # In python 2.7, using read() when no input is available will result in IOError.
return ''
return result
def _start(self):
'''
Initialize the terminal.
'''
assert not self.started, '_start() is called twice'
self.fd = sys.stdin.fileno()
self.old_attr = termios.tcgetattr(self.fd)
new_attr = termios.tcgetattr(self.fd)
new_attr[3] = new_attr[3] & ~termios.ICANON
termios.tcsetattr(self.fd, termios.TCSANOW, new_attr)
self.old_flags = fcntl.fcntl(self.fd, fcntl.F_GETFL)
self.started = True
def _stop(self):
'''
Restore the terminal.
'''
assert self.started, '_start() is not called'
termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old_attr)
fcntl.fcntl(self.fd, fcntl.F_SETFL, self.old_flags)
self.started = False
# Magic functions for context manager
def __enter__(self):
self._start()
self.getchar = self._getchar # No need for self._start() now
return self
def __exit__(self, type, value, traceback):
self._stop()
return False
class KeyGetterWindows:
'''
kbhit() and getchar() in Windows.
Tested on Windows 7 64 bit, Python 2.7.1
'''
def kbhit(self, echo):
return msvcrt.kbhit()
def getchar(self, block = True):
if not block and not msvcrt.kbhit():
return ''
return msvcrt.getchar()
def getch(self, block = True):
if not block and not msvcrt.kbhit():
return ''
return msvcrt.getch()
_getchar = getchar
# Magic functions for context manager
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
return False
try:
import termios
KeyGetter = KeyGetterLinux # Use KeyGetterLinux if termios exists
except ImportError:
KeyGetter = KeyGetterWindows # Use KeyGetterWindows otherwise

Ceci est un exemple(en supposant que vous avez enregistré les codes ci-dessus dans "key_getter.py'):

from key_getter import KeyGetter
import time
def test1(): # Test with block=False
print('test1')
k = KeyGetter()
try:
while True:
if k.kbhit():
print('Got', repr(k.getch(False)))
print('Got', repr(k.getch(False)))
else:
print('Nothing')
time.sleep(0.5)
except KeyboardInterrupt:
pass
print(input('Enter something:'))
def test2(): # Test context manager with block=True
print('test2')
with KeyGetter() as k:
try:
while True:
if k.kbhit():
print('Got', repr(k.getchar(True)))
print('Got', repr(k.getchar(True)))
else:
print('Nothing')
time.sleep(0.5)
except KeyboardInterrupt:
pass
print(input('Enter something:'))
test1()
test2()

Cela doit s'exécuter en tant que root: (attention, il s'agit d'un système à l'échelle de keylogger)

#!/usr/bin/python3
import signal
import keyboard
import time
import os
if not os.geteuid() == 0:
print("This script needs to be run as root.")
exit()
def exitNice(signum, frame):
global running 
running = False
def keyEvent(e):
global running
if e.event_type == "up":
print("Key up: " + str(e.name))
if e.event_type == "down":
print("Key down: " + str(e.name))
if e.name == "q":
exitNice("", "")
print("Quitting")
running = True
signal.signal(signal.SIGINT, exitNice)
keyboard.hook(keyEvent)
print("Press 'q' to quit")
fps = 1/24
while running:
time.sleep(fps)

import turtle
wn = turtle.Screen()
turtle = turtle.Turtle()
def printLetter():
print("a")
turtle.listen()
turtle.onkey(printLetter, "a")