处理键盘 ¶

包 pynput.keyboard 包含用于控制和监视键盘的类。

控制键盘 ¶

使用 pynput.keyboard.Controller 像这样：

from pynput.keyboard import Key, Controller
keyboard = Controller()
# Press and release space
keyboard.press(Key.space)
keyboard.release(Key.space)
# Type a lower case A; this will work even if no key on the
# physical keyboard is labelled 'A'
keyboard.press('a')
keyboard.release('a')
# Type two upper case As
keyboard.press('A')
keyboard.release('A')
with keyboard.pressed(Key.shift):
    keyboard.press('a')
    keyboard.release('a')
# Type 'Hello World' using the shortcut type method
keyboard.type('Hello World')

监视键盘 ¶

使用 pynput.keyboard.Listener 像这样：

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()
# ...or, in a non-blocking fashion:
listener = keyboard.Listener(
    on_press=on_press,
    on_release=on_release)
listener.start()

键盘监听器是 threading.Thread ，且将从线程援引所有回调。

调用 pynput.keyboard.Listener.stop 从任何地方，引发 StopException 或返回 False 从回调以停止监听器。

key parameter passed to callbacks is a pynput.keyboard.Key , for special keys, a pynput.keyboard.KeyCode for normal alphanumeric keys, or just None for unknown keys.

当使用上文非阻塞版本时，当前线程将继续执行。这可能是必要的，当与纳入主循环的其它 GUI 框架集成时，但当从脚本运行时，这将导致程序立即终止。

键盘监听器线程 ¶

The listener callbacks are invoked directly from an operating thread on some platforms, notably Windows .

This means that long running procedures and blocking operations should not be invoked from the callback, as this risks freezing input for all processes.

A possible workaround is to just dispatch incoming messages to a queue, and let a separate thread handle them.

处理键盘监听器错误 ¶

If a callback handler raises an exception, the listener will be stopped. Since callbacks run in a dedicated thread, the exceptions will not automatically be reraised.

To be notified about callback errors, call Thread.join on the listener instance:

from pynput import keyboard
class MyException(Exception): pass
def on_press(key):
    if key == keyboard.Key.esc:
        raise MyException(key)
# Collect events until released
with keyboard.Listener(
        on_press=on_press) as listener:
    try:
        listener.join()
    except MyException as e:
        print('{0} was pressed'.format(e.args[0]))

键盘监听器监听触发事件 ¶

一旦 pynput.keyboard.Listener.stop has been called, the listener cannot be restarted, since listeners are instances of threading.Thread .

If your application requires toggling listening events, you must either add an internal flag to ignore events when not required, or create a new listener when resuming listening.

键盘监听器监听同步事件 ¶

To simplify scripting, synchronous event listening is supported through the utility class pynput.keyboard.Events . This class supports reading single events in a non-blocking fashion, as well as iterating over all events.

To read a single event, use the following code:

from pynput import keyboard
# The event listener will be running in this block
with keyboard.Events() as events:
    # Block at most one second
    event = events.get(1.0)
    if event is None:
        print('You did not press a key within one second')
    else:
        print('Received event {}'.format(event))

To iterate over keyboard events, use the following code:

from pynput import keyboard
# The event listener will be running in this block
with keyboard.Events() as events:
    for event in events:
        if event.key == keyboard.Key.esc:
            break
        else:
            print('Received event {}'.format(event))

Please note that the iterator method does not support non-blocking operation, so it will wait for at least one keyboard event.

The events will be instances of the inner classes found in pynput.keyboard.Events .

全局热键 ¶

A common use case for keyboard monitors is reacting to global hotkeys. Since a listener does not maintain any state, hotkeys involving multiple keys must store this state somewhere.

pynput provides the class pynput.keyboard.HotKey for this purpose. It contains two methods to update the state, designed to be easily interoperable with a keyboard listener: pynput.keyboard.HotKey.press and pynput.keyboard.HotKey.release which can be directly passed as listener callbacks.

The intended usage is as follows:

from pynput import keyboard
def on_activate():
    print('Global hotkey activated!')
def for_canonical(f):
    return lambda k: f(l.canonical(k))
hotkey = keyboard.HotKey(
    keyboard.HotKey.parse('<ctrl>+<alt>+h'),
    on_activate)
with keyboard.Listener(
        on_press=for_canonical(hotkey.press),
        on_release=for_canonical(hotkey.release)) as l:
    l.join()

This will create a hotkey, and then use a listener to update its state. Once all the specified keys are pressed simultaneously, on_activate will be invoked.

Note that keys are passed through pynput.keyboard.Listener.canonical before being passed to the HotKey instance. This is to remove any modifier state from the key events, and to normalise modifiers with more than one physical button.

方法 pynput.keyboard.HotKey.parse is a convenience function to transform shortcut strings to key collections. Please see its documentation for more information.

To register a number of global hotkeys, use the convenience class pynput.keyboard.GlobalHotKeys :

from pynput import keyboard
def on_activate_h():
    print('<ctrl>+<alt>+h pressed')
def on_activate_i():
    print('<ctrl>+<alt>+i pressed')
with keyboard.GlobalHotKeys({
        '<ctrl>+<alt>+h': on_activate_h,
        '<ctrl>+<alt>+i': on_activate_i}) as h:
    h.join()

参考 ¶

class pynput.keyboard. Controller [source] ¶

exception InvalidCharacterException [source] ¶

exception InvalidKeyException [source] ¶

alt_gr_pressed ¶

alt_pressed ¶

ctrl_pressed ¶

modifiers ¶

press ( key ) [source] ¶

参数：	key – 要按下的键。
引发：	InvalidKeyException – if the key is invalid ValueError – 若 `key` is a string, but its length is not `1`

pressed ( *args ) [source] ¶

参数：	keys – The keys to keep pressed.

release ( key ) [source] ¶

参数：	key – The key to release. If this is a string, it is passed to `touches()` and the returned releases are used.
引发：	InvalidKeyException – if the key is invalid ValueError – 若 `key` is a string, but its length is not `1`

shift_pressed ¶

tap ( key ) [source] ¶

参数：	key – 要按下的键。
引发：	InvalidKeyException – if the key is invalid ValueError – 若 `key` is a string, but its length is not `1`

touch ( key , is_press ) [source] ¶

参数：	key – The key to press or release. is_press ( bool ) – Whether to press the key.
引发：	InvalidKeyException – if the key is invalid

type ( string ) [source] ¶

参数：	string ( str ) – 要键入的字符串。
引发：	InvalidCharacterException – if an untypable character is encountered

class pynput.keyboard. Listener ( on_press=None , on_release=None , suppress=False , **kwargs ) [source] ¶

参数：	char ( str ) – The character.
返回：	键码

参数：	char – The dead key. This should be the unicode character representing the stand alone character, such as `'~'` for COMBINING TILDE .
返回：	键码

参数：	vk – The virtual key code. kwargs – Any other parameters to pass.
返回：	键码

参数：	key ( KeyCode ) – The key to join with this key.
返回：	键码
引发：	ValueError – if the keys cannot be joined