¿Cómo generar eventos de teclado en Python?


97

Breve resumen:

Estoy tratando de crear un programa que envíe eventos de teclado a la computadora que, a todos los efectos, los eventos simulados deben tratarse como pulsaciones de teclas reales en el teclado.

publicación original:

Estoy buscando una forma de generar eventos de teclado usando Python.

Suponga que la función recibe una tecla que debe simular presionar, así:

keyboardevent('a') #lower case 'a'
keyboardevent('B') #upper case 'B'
keyboardevent('->') # right arrow key

def keyboardevent(key):
    #code that simulated 'key' being pressed on keyboard

Obviamente, los anteriores son ejemplos, pero lo que estoy buscando es una biblioteca, un módulo o lo que sea, que pueda usar para simular eventos de teclado.

nota : Esto es diferente a enviar caracteres a blocs de notas o ingresar texto en campos o similares. Quiero que el script Python simule un evento de teclado real, la computadora pensará que realmente hay un evento de teclado.

Nota extra:

No quiero enviar pulsaciones de teclas a la ventana activa; quiero que el sistema crea que se están presionando las teclas del teclado, una diferencia sutil, ya que algunas ventanas activas no aceptan ciertas combinaciones de teclas, o si quisiera usar atajos de teclado para procesos en segundo plano a través de mi secuencia de comandos, no es necesario que pasen por la ventana activa

Hasta ahora he mirado estas cosas:

Genere eventos de teclado para la aplicación más avanzada

¿Cómo generar eventos de pulsación de teclas del teclado a través de Python?

Que tenían que ver con la manzana y no ayudaron en absoluto.

Y esto:

¿Cuál es la forma más sencilla de simular el teclado y el mouse en Python?

Lo que parece que podría ser lo que necesito, pero no puedo encontrar la biblioteca ni ninguna documentación.

También he buscado en más lugares, pero aún no he encontrado una solución.


3
Lo único que conozco es SendKeys , que es solo para Windows. Esto parece un problema que no tendrá una solución multiplataforma. ¿Por qué necesitas esto? ¿Qué problema estás resolviendo?
Steven Rumbalski

Para las Xplataformas existe, xdotoolpero normalmente no se instala de forma predeterminada. Creo que leer los documentos Xno debería ser difícil para escribir un módulo mínimo en C que haga lo que quieres (creo que hubo un xsendkeysprograma hace algún tiempo).
Bakuriu

@StevenRumbalski gracias, esto parece prometedor, pero me gustaría agregar, editaré mi pregunta. No quiero enviar pulsaciones de teclas a la ventana activa; quiero que el sistema crea que se están presionando las teclas del teclado, una diferencia sutil, ya que algunas ventanas activas no aceptan ciertas combinaciones de teclas, o si quisiera usar atajos de teclado para procesos en segundo plano. a través de mi script, no necesitan pasar por la ventana activa.
Inbar Rose

3
¿Tiene que ser pitón puro? ¿Tiene que ser multiplataforma?
zenpoy

@zenpoy por ahora, no necesita ser multiplataforma, siempre y cuando funcione en Windows XP, y 7, al menos ... como para Python. el código se escribirá en python. si el módulo / biblioteca / paquete / dll se puede interconectar desde python de manera efectiva, no importa. idealmente, sería Python puro y multiplataforma.
Inbar Rose

Respuestas:


113

Se puede hacer usando ctypes:

import ctypes
from ctypes import wintypes
import time

user32 = ctypes.WinDLL('user32', use_last_error=True)

INPUT_MOUSE    = 0
INPUT_KEYBOARD = 1
INPUT_HARDWARE = 2

KEYEVENTF_EXTENDEDKEY = 0x0001
KEYEVENTF_KEYUP       = 0x0002
KEYEVENTF_UNICODE     = 0x0004
KEYEVENTF_SCANCODE    = 0x0008

MAPVK_VK_TO_VSC = 0

# msdn.microsoft.com/en-us/library/dd375731
VK_TAB  = 0x09
VK_MENU = 0x12

# C struct definitions

wintypes.ULONG_PTR = wintypes.WPARAM

class MOUSEINPUT(ctypes.Structure):
    _fields_ = (("dx",          wintypes.LONG),
                ("dy",          wintypes.LONG),
                ("mouseData",   wintypes.DWORD),
                ("dwFlags",     wintypes.DWORD),
                ("time",        wintypes.DWORD),
                ("dwExtraInfo", wintypes.ULONG_PTR))

class KEYBDINPUT(ctypes.Structure):
    _fields_ = (("wVk",         wintypes.WORD),
                ("wScan",       wintypes.WORD),
                ("dwFlags",     wintypes.DWORD),
                ("time",        wintypes.DWORD),
                ("dwExtraInfo", wintypes.ULONG_PTR))

    def __init__(self, *args, **kwds):
        super(KEYBDINPUT, self).__init__(*args, **kwds)
        # some programs use the scan code even if KEYEVENTF_SCANCODE
        # isn't set in dwFflags, so attempt to map the correct code.
        if not self.dwFlags & KEYEVENTF_UNICODE:
            self.wScan = user32.MapVirtualKeyExW(self.wVk,
                                                 MAPVK_VK_TO_VSC, 0)

class HARDWAREINPUT(ctypes.Structure):
    _fields_ = (("uMsg",    wintypes.DWORD),
                ("wParamL", wintypes.WORD),
                ("wParamH", wintypes.WORD))

class INPUT(ctypes.Structure):
    class _INPUT(ctypes.Union):
        _fields_ = (("ki", KEYBDINPUT),
                    ("mi", MOUSEINPUT),
                    ("hi", HARDWAREINPUT))
    _anonymous_ = ("_input",)
    _fields_ = (("type",   wintypes.DWORD),
                ("_input", _INPUT))

LPINPUT = ctypes.POINTER(INPUT)

def _check_count(result, func, args):
    if result == 0:
        raise ctypes.WinError(ctypes.get_last_error())
    return args

user32.SendInput.errcheck = _check_count
user32.SendInput.argtypes = (wintypes.UINT, # nInputs
                             LPINPUT,       # pInputs
                             ctypes.c_int)  # cbSize

# Functions

def PressKey(hexKeyCode):
    x = INPUT(type=INPUT_KEYBOARD,
              ki=KEYBDINPUT(wVk=hexKeyCode))
    user32.SendInput(1, ctypes.byref(x), ctypes.sizeof(x))

def ReleaseKey(hexKeyCode):
    x = INPUT(type=INPUT_KEYBOARD,
              ki=KEYBDINPUT(wVk=hexKeyCode,
                            dwFlags=KEYEVENTF_KEYUP))
    user32.SendInput(1, ctypes.byref(x), ctypes.sizeof(x))

def AltTab():
    """Press Alt+Tab and hold Alt key for 2 seconds
    in order to see the overlay.
    """
    PressKey(VK_MENU)   # Alt
    PressKey(VK_TAB)    # Tab
    ReleaseKey(VK_TAB)  # Tab~
    time.sleep(2)
    ReleaseKey(VK_MENU) # Alt~

if __name__ == "__main__":
    AltTab()

hexKeyCodees la asignación de teclado virtual definida por la API de Windows. La lista de códigos está disponible en MSDN: Códigos de clave virtual (Windows)


me gusta esta idea hasta ahora. No puedo encontrar una lista de VK_Key, y tal vez podría poner una llamada de función de ejemplo.
Inbar Rose

3
Agrego un método de método simple para presionar alt-tab.
lucasg

He estado usando esto maravillosamente, pero ahora tengo un pequeño problema, espero que puedan ayudarme. ¿Cómo puedo mover el mouse X, Y?
Inbar Rose

15
La próxima vez, apunte a duplicar la pregunta en lugar de duplicar la respuesta: stackoverflow.com/questions/13289777/…
Nakilon

8
parece que esto es específico de Windows. ¿Cuál es la forma alternativa para linux?
Insane Coder

84

Tanto para python3 como para python2 puedes usar pyautogui( pip install pyautogui)

from pyautogui import press, typewrite, hotkey

press('a')
typewrite('quick brown fox')
hotkey('ctrl', 'w')

También es multiplataforma con Windows, OSX y Ubuntu LTS.


1
presstambién funciona con teclas multimedia. Yo lo uso para silenciar mi ordenador conpress('volumemute')
CornSmith

3
Esto funciona, pero es más lento que la respuesta aceptada. (Demasiado lento para mi aplicación, que requiere una latencia muy baja).
TimH - Codidact

Me he encontrado con ciertas circunstancias en las que las aplicaciones no aceptan comandos a través de pyautogui, pero cytpes parece funcionar de manera constante.
Allison Wilson

1
Este paquete pyautogui es multiplataforma, funciona en mac y windows
Charles Chow

@CharlesChow buena llamada, vale la pena señalarlo para la gente, así que lo agregué a la respuesta. Y también funciona con Ubuntu (LTS y más reciente solo de acuerdo con github)
CornSmith

11

La idea de user648852 al menos para mí funciona muy bien para OS X, aquí está el código para hacerlo:

#!/usr/bin/env python

import time
from Quartz.CoreGraphics import CGEventCreateKeyboardEvent
from Quartz.CoreGraphics import CGEventPost

# Python releases things automatically, using CFRelease will result in a scary error
#from Quartz.CoreGraphics import CFRelease

from Quartz.CoreGraphics import kCGHIDEventTap

# From http://stackoverflow.com/questions/281133/controlling-the-mouse-from-python-in-os-x
# and from https://developer.apple.com/library/mac/documentation/Carbon/Reference/QuartzEventServicesRef/index.html#//apple_ref/c/func/CGEventCreateKeyboardEvent


def KeyDown(k):
    keyCode, shiftKey = toKeyCode(k)

    time.sleep(0.0001)

    if shiftKey:
        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, True))
        time.sleep(0.0001)

    CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, True))
    time.sleep(0.0001)

    if shiftKey:
        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, False))
        time.sleep(0.0001)

def KeyUp(k):
    keyCode, shiftKey = toKeyCode(k)

    time.sleep(0.0001)

    CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, False))
    time.sleep(0.0001)

def KeyPress(k):
    keyCode, shiftKey = toKeyCode(k)

    time.sleep(0.0001)

    if shiftKey:
        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, True))
        time.sleep(0.0001)

    CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, True))
    time.sleep(0.0001)

    CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, False))
    time.sleep(0.0001)

    if shiftKey:
        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, False))
        time.sleep(0.0001)



# From http://stackoverflow.com/questions/3202629/where-can-i-find-a-list-of-mac-virtual-key-codes

def toKeyCode(c):
    shiftKey = False
    # Letter
    if c.isalpha():
        if not c.islower():
            shiftKey = True
            c = c.lower()

    if c in shiftChars:
        shiftKey = True
        c = shiftChars[c]
    if c in keyCodeMap:
        keyCode = keyCodeMap[c]
    else:
        keyCode = ord(c)
    return keyCode, shiftKey

shiftChars = {
    '~': '`',
    '!': '1',
    '@': '2',
    '#': '3',
    '$': '4',
    '%': '5',
    '^': '6',
    '&': '7',
    '*': '8',
    '(': '9',
    ')': '0',
    '_': '-',
    '+': '=',
    '{': '[',
    '}': ']',
    '|': '\\',
    ':': ';',
    '"': '\'',
    '<': ',',
    '>': '.',
    '?': '/'
}


keyCodeMap = {
    'a'                 : 0x00,
    's'                 : 0x01,
    'd'                 : 0x02,
    'f'                 : 0x03,
    'h'                 : 0x04,
    'g'                 : 0x05,
    'z'                 : 0x06,
    'x'                 : 0x07,
    'c'                 : 0x08,
    'v'                 : 0x09,
    'b'                 : 0x0B,
    'q'                 : 0x0C,
    'w'                 : 0x0D,
    'e'                 : 0x0E,
    'r'                 : 0x0F,
    'y'                 : 0x10,
    't'                 : 0x11,
    '1'                 : 0x12,
    '2'                 : 0x13,
    '3'                 : 0x14,
    '4'                 : 0x15,
    '6'                 : 0x16,
    '5'                 : 0x17,
    '='                 : 0x18,
    '9'                 : 0x19,
    '7'                 : 0x1A,
    '-'                 : 0x1B,
    '8'                 : 0x1C,
    '0'                 : 0x1D,
    ']'                 : 0x1E,
    'o'                 : 0x1F,
    'u'                 : 0x20,
    '['                 : 0x21,
    'i'                 : 0x22,
    'p'                 : 0x23,
    'l'                 : 0x25,
    'j'                 : 0x26,
    '\''                : 0x27,
    'k'                 : 0x28,
    ';'                 : 0x29,
    '\\'                : 0x2A,
    ','                 : 0x2B,
    '/'                 : 0x2C,
    'n'                 : 0x2D,
    'm'                 : 0x2E,
    '.'                 : 0x2F,
    '`'                 : 0x32,
    'k.'                : 0x41,
    'k*'                : 0x43,
    'k+'                : 0x45,
    'kclear'            : 0x47,
    'k/'                : 0x4B,
    'k\n'               : 0x4C,
    'k-'                : 0x4E,
    'k='                : 0x51,
    'k0'                : 0x52,
    'k1'                : 0x53,
    'k2'                : 0x54,
    'k3'                : 0x55,
    'k4'                : 0x56,
    'k5'                : 0x57,
    'k6'                : 0x58,
    'k7'                : 0x59,
    'k8'                : 0x5B,
    'k9'                : 0x5C,

    # keycodes for keys that are independent of keyboard layout
    '\n'                : 0x24,
    '\t'                : 0x30,
    ' '                 : 0x31,
    'del'               : 0x33,
    'delete'            : 0x33,
    'esc'               : 0x35,
    'escape'            : 0x35,
    'cmd'               : 0x37,
    'command'           : 0x37,
    'shift'             : 0x38,
    'caps lock'         : 0x39,
    'option'            : 0x3A,
    'ctrl'              : 0x3B,
    'control'           : 0x3B,
    'right shift'       : 0x3C,
    'rshift'            : 0x3C,
    'right option'      : 0x3D,
    'roption'           : 0x3D,
    'right control'     : 0x3E,
    'rcontrol'          : 0x3E,
    'fun'               : 0x3F,
    'function'          : 0x3F,
    'f17'               : 0x40,
    'volume up'         : 0x48,
    'volume down'       : 0x49,
    'mute'              : 0x4A,
    'f18'               : 0x4F,
    'f19'               : 0x50,
    'f20'               : 0x5A,
    'f5'                : 0x60,
    'f6'                : 0x61,
    'f7'                : 0x62,
    'f3'                : 0x63,
    'f8'                : 0x64,
    'f9'                : 0x65,
    'f11'               : 0x67,
    'f13'               : 0x69,
    'f16'               : 0x6A,
    'f14'               : 0x6B,
    'f10'               : 0x6D,
    'f12'               : 0x6F,
    'f15'               : 0x71,
    'help'              : 0x72,
    'home'              : 0x73,
    'pgup'              : 0x74,
    'page up'           : 0x74,
    'forward delete'    : 0x75,
    'f4'                : 0x76,
    'end'               : 0x77,
    'f2'                : 0x78,
    'page down'         : 0x79,
    'pgdn'              : 0x79,
    'f1'                : 0x7A,
    'left'              : 0x7B,
    'right'             : 0x7C,
    'down'              : 0x7D,
    'up'                : 0x7E
}

6

Probé el teclado lib y funciona bien en Windows. La siguiente línea me ayuda a cambiar de pestaña en el navegador:

keyboard.press_and_release('ctrl+tab')

También funciona bien en MAC. No he probado Linux, pero debería funcionar.
Davoud Taghawi-Nejad

5

Tuve este mismo problema e hice mi propia biblioteca que usa ctypes:

"""
< --- CTRL by [object Object] --- >
Only works on windows.
Some characters only work with a US standard keyboard.
Some parts may also only work in python 32-bit.
"""

#--- Setup ---#
from ctypes import *
from time import sleep
user32 = windll.user32
kernel32 = windll.kernel32
delay = 0.01

####################################
###---KEYBOARD CONTROL SECTION---###
####################################

#--- Key Code Variables ---#
class key:
        cancel = 0x03
        backspace = 0x08
        tab = 0x09
        enter = 0x0D
        shift = 0x10
        ctrl = 0x11
        alt = 0x12
        capslock = 0x14
        esc = 0x1B
        space = 0x20
        pgup = 0x21
        pgdown = 0x22
        end = 0x23
        home = 0x24
        leftarrow = 0x26
        uparrow = 0x26
        rightarrow = 0x27
        downarrow = 0x28
        select = 0x29
        print = 0x2A
        execute = 0x2B
        printscreen = 0x2C
        insert = 0x2D
        delete = 0x2E
        help = 0x2F
        num0 = 0x30
        num1 = 0x31
        num2 = 0x32
        num3 = 0x33
        num4 = 0x34
        num5 = 0x35
        num6 = 0x36
        num7 = 0x37
        num8 = 0x38
        num9 = 0x39
        a = 0x41
        b = 0x42
        c = 0x43
        d = 0x44
        e = 0x45
        f = 0x46
        g = 0x47
        h = 0x48
        i = 0x49
        j = 0x4A
        k = 0x4B
        l = 0x4C
        m = 0x4D
        n = 0x4E
        o = 0x4F
        p = 0x50
        q = 0x51
        r = 0x52
        s = 0x53
        t = 0x54
        u = 0x55
        v = 0x56
        w = 0x57
        x = 0x58
        y = 0x59
        z = 0x5A
        leftwin = 0x5B
        rightwin = 0x5C
        apps = 0x5D
        sleep = 0x5F
        numpad0 = 0x60
        numpad1 = 0x61
        numpad3 = 0x63
        numpad4 = 0x64
        numpad5 = 0x65
        numpad6 = 0x66
        numpad7 = 0x67
        numpad8 = 0x68
        numpad9 = 0x69
        multiply = 0x6A
        add = 0x6B
        seperator = 0x6C
        subtract = 0x6D
        decimal = 0x6E
        divide = 0x6F
        F1 = 0x70
        F2 = 0x71
        F3 = 0x72
        F4 = 0x73
        F5 = 0x74
        F6 = 0x75
        F7 = 0x76
        F8 = 0x77
        F9 = 0x78
        F10 = 0x79
        F11 = 0x7A
        F12 = 0x7B
        F13 = 0x7C
        F14 = 0x7D
        F15 = 0x7E
        F16 = 0x7F
        F17 = 0x80
        F19 = 0x82
        F20 = 0x83
        F21 = 0x84
        F22 = 0x85
        F23 = 0x86
        F24 = 0x87
        numlock = 0x90
        scrolllock = 0x91
        leftshift = 0xA0
        rightshift = 0xA1
        leftctrl = 0xA2
        rightctrl = 0xA3
        leftmenu = 0xA4
        rightmenu = 0xA5
        browserback = 0xA6
        browserforward = 0xA7
        browserrefresh = 0xA8
        browserstop = 0xA9
        browserfavories = 0xAB
        browserhome = 0xAC
        volumemute = 0xAD
        volumedown = 0xAE
        volumeup = 0xAF
        nexttrack = 0xB0
        prevoustrack = 0xB1
        stopmedia = 0xB2
        playpause = 0xB3
        launchmail = 0xB4
        selectmedia = 0xB5
        launchapp1 = 0xB6
        launchapp2 = 0xB7
        semicolon = 0xBA
        equals = 0xBB
        comma = 0xBC
        dash = 0xBD
        period = 0xBE
        slash = 0xBF
        accent = 0xC0
        openingsquarebracket = 0xDB
        backslash = 0xDC
        closingsquarebracket = 0xDD
        quote = 0xDE
        play = 0xFA
        zoom = 0xFB
        PA1 = 0xFD
        clear = 0xFE

#--- Keyboard Control Functions ---#

# Category variables
letters = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
shiftsymbols = "~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?"

# Presses and releases the key
def press(key):
        user32.keybd_event(key, 0, 0, 0)
        sleep(delay)
        user32.keybd_event(key, 0, 2, 0)
        sleep(delay)

# Holds a key
def hold(key):
        user32.keybd_event(key, 0, 0, 0)
        sleep(delay)

# Releases a key
def release(key):
        user32.keybd_event(key, 0, 2, 0)
        sleep(delay)

# Types out a string
def typestr(sentence):
        for letter in sentence:
                shift = letter in shiftsymbols
                fixedletter = "space"
                if letter == "`" or letter == "~":
                        fixedletter = "accent"
                elif letter == "1" or letter == "!":
                        fixedletter = "num1"
                elif letter == "2" or letter == "@":
                        fixedletter = "num2"
                elif letter == "3" or letter == "#":
                        fixedletter = "num3"
                elif letter == "4" or letter == "$":
                        fixedletter = "num4"
                elif letter == "5" or letter == "%":
                        fixedletter = "num5"
                elif letter == "6" or letter == "^":
                        fixedletter = "num6"
                elif letter == "7" or letter == "&":
                        fixedletter = "num7"
                elif letter == "8" or letter == "*":
                        fixedletter = "num8"
                elif letter == "9" or letter == "(":
                        fixedletter = "num9"
                elif letter == "0" or letter == ")":
                        fixedletter = "num0"
                elif letter == "-" or letter == "_":
                        fixedletter = "dash"
                elif letter == "=" or letter == "+":
                        fixedletter = "equals"
                elif letter in letters:
                        fixedletter = letter.lower()
                elif letter == "[" or letter == "{":
                        fixedletter = "openingsquarebracket"
                elif letter == "]" or letter == "}":
                        fixedletter = "closingsquarebracket"
                elif letter == "\\" or letter == "|":
                        fixedletter == "backslash"
                elif letter == ";" or letter == ":":
                        fixedletter = "semicolon"
                elif letter == "'" or letter == "\"":
                        fixedletter = "quote"
                elif letter == "," or letter == "<":
                        fixedletter = "comma"
                elif letter == "." or letter == ">":
                        fixedletter = "period"
                elif letter == "/" or letter == "?":
                        fixedletter = "slash"
                elif letter == "\n":
                        fixedletter = "enter"
                keytopress = eval("key." + str(fixedletter))
                if shift:
                        hold(key.shift)
                        press(keytopress)
                        release(key.shift)
                else:
                        press(keytopress)

#--- Mouse Variables ---#
                        
class mouse:
        left = [0x0002, 0x0004]
        right = [0x0008, 0x00010]
        middle = [0x00020, 0x00040]

#--- Mouse Control Functions ---#

# Moves mouse to a position
def move(x, y):
        user32.SetCursorPos(x, y)

# Presses and releases mouse
def click(button):
        user32.mouse_event(button[0], 0, 0, 0, 0)
        sleep(delay)
        user32.mouse_event(button[1], 0, 0, 0, 0)
        sleep(delay)

# Holds a mouse button
def holdclick(button):
        user32.mouse_event(button[0], 0, 0, 0, 0)
        sleep(delay)

# Releases a mouse button
def releaseclick(button):
        user32.mouse_event(button[1])
        sleep(delay)

2

Cada plataforma tendrá un enfoque diferente para poder generar eventos de teclado. Esto se debe a que cada uno de ellos necesita hacer uso de bibliotecas del sistema (y extensiones del sistema). Para una solución multiplataforma, necesitaría tomar cada una de estas soluciones y luego envolverlas en una verificación de plataforma para realizar el enfoque adecuado.

Para Windows, es posible que pueda usar la extensión pywin32 . win32api.keybd_event

win32api.keybd_event

keybd_event (bVk, bScan, dwFlags, dwExtraInfo)

Simular un evento de teclado

Parámetros

bVk: BYTE - Código de tecla virtual
bScan: BYTE - Código de escaneo de hardware
dwFlags = 0: DWORD - Banderas que especifican varias opciones de función
dwExtraInfo = 0: DWORD - Datos adicionales asociados con la pulsación de tecla

Deberá investigar pywin32 para saber cómo usarlo correctamente, ya que nunca lo he usado.


2

Solo Windows: puede usar Ironpython o una biblioteca que permita a cPython acceder a los marcos .NET en Windows. Luego use la clase sendkeys de .NET o el envío más general para simular una pulsación de tecla.

Solo OS X: use PyObjC y luego use CGEventCreateKeyboardEventcall.

Divulgación completa: solo he hecho esto en OS X con Python, pero he usado sendkeys .NET (con C #) y eso funciona muy bien.


He utilizado .Net SendKeys de IronPython (para el marco de prueba de aceptación de una aplicación de escritorio) y funcionó muy bien.
Jonathan Hartley

1
python for .net. una solución, ¿cómo usaría el sendkeys. ¿Podría dar un ejemplo de esto?
Inbar Rose

2

Mac OS

Aquí está la versión más completa de la respuesta de @Phylliida en forma de clase con ejemplo de código:

#!/usr/bin/python
# Script simulating keyboard events in macOS.
# See: https://stackoverflow.com/q/13564851/55075

import sys
import time
from Quartz.CoreGraphics import CGEventCreateKeyboardEvent
from Quartz.CoreGraphics import CGEventPost
from Quartz.CoreGraphics import kCGHIDEventTap
#from Quartz.CoreGraphics import CFRelease # Python releases things automatically.

class Keyboard():
    shiftChars = {
        '~': '`',
        '!': '1',
        '@': '2',
        '#': '3',
        '$': '4',
        '%': '5',
        '^': '6',
        '&': '7',
        '*': '8',
        '(': '9',
        ')': '0',
        '_': '-',
        '+': '=',
        '{': '[',
        '}': ']',
        '|': '\\',
        ':': ';',
        '"': '\'',
        '<': ',',
        '>': '.',
        '?': '/'
    }


    keyCodeMap = {
        'a'              : 0x00,
        's'              : 0x01,
        'd'              : 0x02,
        'f'              : 0x03,
        'h'              : 0x04,
        'g'              : 0x05,
        'z'              : 0x06,
        'x'              : 0x07,
        'c'              : 0x08,
        'v'              : 0x09,
        'b'              : 0x0B,
        'q'              : 0x0C,
        'w'              : 0x0D,
        'e'              : 0x0E,
        'r'              : 0x0F,
        'y'              : 0x10,
        't'              : 0x11,
        '1'              : 0x12,
        '2'              : 0x13,
        '3'              : 0x14,
        '4'              : 0x15,
        '6'              : 0x16,
        '5'              : 0x17,
        '='              : 0x18,
        '9'              : 0x19,
        '7'              : 0x1A,
        '-'              : 0x1B,
        '8'              : 0x1C,
        '0'              : 0x1D,
        ']'              : 0x1E,
        'o'              : 0x1F,
        'u'              : 0x20,
        '['              : 0x21,
        'i'              : 0x22,
        'p'              : 0x23,
        'l'              : 0x25,
        'j'              : 0x26,
        '\''             : 0x27,
        'k'              : 0x28,
        ';'              : 0x29,
        '\\'             : 0x2A,
        ','              : 0x2B,
        '/'              : 0x2C,
        'n'              : 0x2D,
        'm'              : 0x2E,
        '.'              : 0x2F,
        '`'              : 0x32,
        'k.'             : 0x41,
        'k*'             : 0x43,
        'k+'             : 0x45,
        'kclear'         : 0x47,
        'k/'             : 0x4B,
        'k\n'            : 0x4C,
        'k-'             : 0x4E,
        'k='             : 0x51,
        'k0'             : 0x52,
        'k1'             : 0x53,
        'k2'             : 0x54,
        'k3'             : 0x55,
        'k4'             : 0x56,
        'k5'             : 0x57,
        'k6'             : 0x58,
        'k7'             : 0x59,
        'k8'             : 0x5B,
        'k9'             : 0x5C,

        # keycodes for keys that are independent of keyboard layout
        '\n'             : 0x24,
        '\t'             : 0x30,
        ' '              : 0x31,
        'del'            : 0x33,
        'delete'         : 0x33,
        'esc'            : 0x35,
        'escape'         : 0x35,
        'cmd'            : 0x37,
        'command'        : 0x37,
        'shift'          : 0x38,
        'caps lock'      : 0x39,
        'option'         : 0x3A,
        'ctrl'           : 0x3B,
        'control'        : 0x3B,
        'right shift'    : 0x3C,
        'rshift'         : 0x3C,
        'right option'   : 0x3D,
        'roption'        : 0x3D,
        'right control'  : 0x3E,
        'rcontrol'       : 0x3E,
        'fun'            : 0x3F,
        'function'       : 0x3F,
        'f17'            : 0x40,
        'volume up'      : 0x48,
        'volume down'    : 0x49,
        'mute'           : 0x4A,
        'f18'            : 0x4F,
        'f19'            : 0x50,
        'f20'            : 0x5A,
        'f5'             : 0x60,
        'f6'             : 0x61,
        'f7'             : 0x62,
        'f3'             : 0x63,
        'f8'             : 0x64,
        'f9'             : 0x65,
        'f11'            : 0x67,
        'f13'            : 0x69,
        'f16'            : 0x6A,
        'f14'            : 0x6B,
        'f10'            : 0x6D,
        'f12'            : 0x6F,
        'f15'            : 0x71,
        'help'           : 0x72,
        'home'           : 0x73,
        'pgup'           : 0x74,
        'page up'        : 0x74,
        'forward delete' : 0x75,
        'f4'             : 0x76,
        'end'            : 0x77,
        'f2'             : 0x78,
        'page down'      : 0x79,
        'pgdn'           : 0x79,
        'f1'             : 0x7A,
        'left'           : 0x7B,
        'right'          : 0x7C,
        'down'           : 0x7D,
        'up'             : 0x7E
    }

    # See: https://stackoverflow.com/q/3202629/55075
    def toKeyCode(self, c):
        shiftKey = False
        # Letter
        if c.isalpha():
            if not c.islower():
                shiftKey = True
                c = c.lower()
        if c in Keyboard.shiftChars:
            shiftKey = True
            c = Keyboard.shiftChars[c]
        if c in Keyboard.keyCodeMap:
            keyCode = Keyboard.keyCodeMap[c]
        else:
            keyCode = ord(c)
        return keyCode, shiftKey

    def KeyDown(self, k):
        keyCode, shiftKey = self.toKeyCode(k)

        time.sleep(0.0001)

        if shiftKey:
            CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, True))
            time.sleep(0.0001)

        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, True))
        time.sleep(0.0001)

        if shiftKey:
            CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, False))
            time.sleep(0.0001)

    def KeyUp(self, k):
        keyCode, shiftKey = self.toKeyCode(k)

        time.sleep(0.0001)

        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, False))
        time.sleep(0.0001)

    def KeyPress(self, k):
        keyCode, shiftKey = self.toKeyCode(k)

        time.sleep(0.0001)

        if shiftKey:
            CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, True))
            time.sleep(0.0001)

        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, True))
        time.sleep(0.0001)

        CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, keyCode, False))
        time.sleep(0.0001)

        if shiftKey:
            CGEventPost(kCGHIDEventTap, CGEventCreateKeyboardEvent(None, 0x38, False))
            time.sleep(0.0001)

    def Type(self, text):
        for key in text:
            self.KeyDown(key)
            self.KeyUp(key)

Aquí está el código de demostración usando la clase anterior:

# DEMO
if __name__ == '__main__':
    keyboard = Keyboard()
    if sys.platform == "darwin":
        keyboard.Type('Hello World!')
    elif sys.platform == "win32":
        print("Error: Platform not supported!")

que simulará escribir Hello World!texto en la ventana actual.

Puede ejecutar el código anterior como un script de shell. Verifique el enlace al keyboard.pyarchivo .


2

Para Python2.7 (windows32) instalé solo pywin32-223 . Y escribí un código simple de Python:

import win32api
import time
import win32con

# simulate the pressing-DOWN "ARROW key" of 200 times

for i in range(200):
   time.sleep(0.5)
   win32api.keybd_event(0x28, 0,0,0)
   time.sleep(.05)
   win32api.keybd_event(0x28,0 ,win32con.KEYEVENTF_KEYUP ,0)

Se puede verificar si ejecuta el código e inmediatamente va a la ventana del bloc de notas (donde ya existe el texto) y coloca el cursor en la línea superior.


Esa misma función keybd_event ya existe en ctypes
object-Object

ctypes.windll.user32.keybd_event (0x01, 0, 0, 0)
object-Object

0

con respecto al código de respuesta recomendado,

Para mi bot, la respuesta recomendada no funcionó. Esto se debe a que estoy usando Chrome, lo que me obliga a usar KEYEVENTF_SCANCODE en mis dwFlags.

Para que su código funcione, tuve que modificar estos bloques de código:

class KEYBDINPUT(ctypes.Structure):
    _fields_ = (("wVk",         wintypes.WORD),
                ("wScan",       wintypes.WORD),
                ("dwFlags",     wintypes.DWORD),
                ("time",        wintypes.DWORD),
                ("dwExtraInfo", wintypes.ULONG_PTR))

    def __init__(self, *args, **kwds):
        super(KEYBDINPUT, self).__init__(*args, **kwds)
        # some programs use the scan code even if KEYEVENTF_SCANCODE
        # isn't set in dwFflags, so attempt to map the correct code.
        #if not self.dwFlags & KEYEVENTF_UNICODE:l
            #self.wScan = user32.MapVirtualKeyExW(self.wVk,
                                                 #MAPVK_VK_TO_VSC, 0)
            # ^MAKE SURE YOU COMMENT/REMOVE THIS CODE^

def PressKey(keyCode):
    input = INPUT(type=INPUT_KEYBOARD,
              ki=KEYBDINPUT(wScan=keyCode,
                            dwFlags=KEYEVENTF_SCANCODE))
    user32.SendInput(1, ctypes.byref(input), ctypes.sizeof(input))

def ReleaseKey(keyCode):
    input = INPUT(type=INPUT_KEYBOARD,
              ki=KEYBDINPUT(wScan=keyCode,
                            dwFlags=KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP))
    user32.SendInput(1, ctypes.byref(input), ctypes.sizeof(input))

time.sleep(5) # sleep to open browser tab
PressKey(0x26) # press right arrow key
time.sleep(2) # hold for 2 seconds
ReleaseKey(0x26) # release right arrow key

¡Espero que esto ayude al dolor de cabeza de alguien!


0
    def keyboardevent():
         keyboard.press_and_release('a')
         keyboard.press_and_release('shift + b')
         
    keyboardevent()

2
Bienvenido a StackOverflow. Si bien este código puede resolver la pregunta, incluir una explicación de cómo y por qué esto resuelve el problema realmente ayudaría a mejorar la calidad de su publicación y probablemente resultaría en más votos a favor. Recuerde que está respondiendo la pregunta a los lectores en el futuro, no solo a la persona que pregunta ahora. Edite su respuesta para agregar explicaciones y dar una indicación de las limitaciones y suposiciones que se aplican.
Ruli
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.