पायथन में कीबोर्ड इवेंट कैसे उत्पन्न करें?


97

संक्षिप्त सारांश:

मैं एक ऐसा प्रोग्राम बनाने की कोशिश कर रहा हूं, जो कंप्यूटर पर कीबोर्ड इवेंट भेजेगा कि सभी प्रयोजनों के लिए नकली घटनाओं को कीबोर्ड पर वास्तविक कीस्ट्रोक्स के रूप में माना जाना चाहिए।

मूल पोस्ट:

मैं अजगर का उपयोग करके कीबोर्ड घटनाओं को उत्पन्न करने का एक तरीका ढूंढ रहा हूं।

मान लें कि फ़ंक्शन को एक कुंजी मिलती है जिसे इसे दबाकर अनुकरण करना चाहिए, जैसे:

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

उपरोक्त स्पष्ट रूप से उदाहरण हैं, लेकिन मैं जो देख रहा हूं वह एक पुस्तकालय, मॉड्यूल या जो कुछ भी है, जिसका उपयोग मैं कीबोर्ड घटनाओं का अनुकरण करने के लिए कर सकता हूं।

नोट : यह वर्णों को नोटपैड पर भेजने या पाठ को फ़ील्ड्स या ऐसे में इनपुट करने से अलग है। मैं एक वास्तविक कीबोर्ड घटना का अनुकरण करने के लिए अजगर स्क्रिप्ट चाहता हूं, कंप्यूटर सोचेंगे कि वास्तव में एक कीबोर्ड ईवेंट है।

अतिरिक्त नोट:

मैं सक्रिय विंडो में कीस्ट्रोक्स नहीं भेजना चाहता हूं - मैं चाहता हूं कि सिस्टम को यह विश्वास हो कि कीबोर्ड की चाबियाँ दबाए जा रहे हैं, सूक्ष्म अंतर है, क्योंकि कुछ सक्रिय-विंडो कुछ कुंजी-संयोजनों को स्वीकार नहीं करते हैं, या यदि मैं कीबोर्ड शॉर्टकट का उपयोग करना चाहता हूं मेरी स्क्रिप्ट के माध्यम से पृष्ठभूमि प्रक्रियाओं के लिए, उन्हें सक्रिय-विंडो से गुजरने की आवश्यकता नहीं है

अब तक मैंने इन चीजों को देखा है:

सामने के अनुप्रयोग के लिए कीबोर्ड ईवेंट बनाएं

पायथन के माध्यम से कीबोर्ड कीप इवेंट कैसे उत्पन्न करें?

जो सभी सेब के बारे में थे और बिल्कुल भी मदद नहीं की।

और इस:

पायथन पर कीबोर्ड और माउस का अनुकरण करने का सबसे आसान तरीका कौन सा है?

जो ऐसा लगता है कि यह वही हो सकता है जो मुझे चाहिए, लेकिन मुझे इसके लिए पुस्तकालय या कोई दस्तावेज नहीं मिल सकता है।

मैंने और भी जगहों की खोज की है, लेकिन अभी तक कोई हल नहीं मिला है।


3
केवल एक चीज मुझे पता है SendKeys , जो केवल विंडोज है। यह एक समस्या की तरह लगता है जिसका क्रॉस-प्लेटफॉर्म समाधान नहीं होगा। आप इसकी आवश्यकता क्यों है? आप किस समस्या का समाधान कर रहे हैं?
स्टीवन रूमालस्की

Xप्लेटफार्मों के लिए है, xdotoolलेकिन आमतौर पर डिफ़ॉल्ट रूप से स्थापित नहीं है। मेरा मानना ​​है कि डॉक्स पढ़ने के लिए Xसी में एक न्यूनतम मॉड्यूल लिखना मुश्किल नहीं होना चाहिए जो आप चाहते हैं (मुझे विश्वास है कि xsendkeysकुछ समय पहले एक कार्यक्रम था)।
बाकूउ नोव

@StevenRumbalski धन्यवाद, यह आशाजनक लग रहा है, लेकिन मैं जोड़ना चाहूंगा, मैं अपने प्रश्न को संपादित करूंगा। मैं सक्रिय विंडो में कीस्ट्रोक्स नहीं भेजना चाहता हूं - मैं चाहता हूं कि सिस्टम को यह विश्वास हो कि कीबोर्ड कीज को दबाया जा रहा है, सूक्ष्म अंतर है, क्योंकि कुछ सक्रिय-विंडो कुछ कुंजी-संयोजनों को स्वीकार नहीं करते हैं, या यदि मैं पृष्ठभूमि प्रक्रियाओं के लिए कीबोर्ड शॉर्टकट का उपयोग करना चाहता हूं। मेरी स्क्रिप्ट के माध्यम से, उन्हें सक्रिय-विंडो से गुजरने की आवश्यकता नहीं है।
इबार रोज

3
क्या यह शुद्ध अजगर होना चाहिए? क्या इसके लिए क्रॉस-प्लेटफ़ॉर्म होना चाहिए?
zenpoy

@zenpoy के लिए, इसे क्रॉस-प्लेटफ़ॉर्म करने की आवश्यकता नहीं है, जब तक कि यह विंडोज़ एक्सपी पर काम करेगा, और 7, कम से कम .. अजगर के लिए। कोड अजगर में लिखा जा रहा है। यदि मॉड्यूल / लाइब्रेरी / पैकेज / डीएलएल जो अजगर से प्रभावी ढंग से हस्तक्षेप किया जा सकता है, यह कोई फर्क नहीं पड़ता। आदर्श रूप से, यह शुद्ध अजगर और क्रॉस-प्लेटफॉर्म होगा।
इबार रोज

जवाबों:


113

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

hexKeyCodeWindows API द्वारा परिभाषित वर्चुअल कीबोर्ड मैपिंग है। कोड की सूची MSDN पर उपलब्ध है: वर्चुअल-कुंजी कोड (विंडोज)


मुझे यह विचार अभी तक पसंद है। मैं VK_Key's की सूची नहीं ढूँढ सकता, और क्या आप शायद एक उदाहरण फ़ंक्शन कॉल कर सकते हैं।
इबार रोज

3
मैं ऑल्ट-टैब हिट करने के लिए एक सरल विधि विधि जोड़ता हूं।
लुकासग

मैं इसे आश्चर्यजनक रूप से उपयोग कर रहा हूं, लेकिन अब मेरे पास एक छोटी सी समस्या है, उम्मीद है कि आप मेरी मदद कर सकते हैं - मैं माउस एक्स, वाई को कैसे स्थानांतरित कर सकता हूं?
इबर रोज

15
अगली बार उत्तर की नकल करने के बजाय डुप्लिकेट प्रश्न की ओर इशारा करें: stackoverflow.com/questions/13289777/…
Nakilon

8
ऐसा लगता है कि यह विंडोज़ विशिष्ट है। लिनक्स के लिए वैकल्पिक तरीका क्या है?
इन्सान कोडर

85

Python3 और python2 दोनों के लिए आप उपयोग कर सकते हैं pyautogui( pip install pyautogui)

from pyautogui import press, typewrite, hotkey

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

यह विंडोज, ओएसएक्स और उबंटू एलटीएस के साथ क्रॉसप्लेक्ट्रीयर भी है।


1
pressमीडिया कीज़ के साथ भी काम करता है। मैं इसे अपने कंप्यूटर को म्यूट करने के लिए उपयोग करता हूंpress('volumemute')
कॉर्नस्मिथ

3
यह काम करता है, लेकिन यह स्वीकृत उत्तर की तुलना में धीमा है। (मेरे आवेदन के लिए बहुत धीमा, जिसके लिए बहुत कम विलंबता की आवश्यकता होती है।)
टिमएच - कोडिडैक्ट

मैं कुछ परिस्थितियों में चला गया हूं, जहां अनुप्रयोग pyutogui के माध्यम से कमांड स्वीकार नहीं करेंगे, लेकिन साइटल्स लगातार काम करते हैं।
एलिसन विल्सन

1
यह पाइयुतुगुई पैकेज क्रॉस प्लेटफॉर्म है, जो मैक और विंडो में काम करता है
चार्ल्स चॉ

@CharlesChow अच्छी कॉल, यह लोगों के लिए ध्यान देने योग्य है इसलिए मैंने इसे उत्तर में जोड़ा। और यह उबंटू के साथ भी काम करता है (LTS और नए केवल
गीथब के

11

user648852 का विचार कम से कम मेरे लिए OS X के लिए बहुत अच्छा काम करता है, यहाँ यह करने के लिए कोड है:

#!/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

मैंने lib कीबोर्ड की कोशिश की और यह विंडोज पर अच्छा काम करता है। नीचे की रेखा मुझे ब्राउज़र में टैब बदलने में मदद करती है:

keyboard.press_and_release('ctrl+tab')

मैक पर भी अच्छी तरह से काम करता है। मैंने लिनक्स का परीक्षण नहीं किया है, लेकिन यह काम करना चाहिए।
दाउद तगावी-नजद

5

मुझे भी यही समस्या थी और इसके लिए मैंने खुद की लाइब्रेरी बनाई जो 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

कीबोर्ड घटनाओं को उत्पन्न करने में सक्षम होने के लिए हर प्लेटफ़ॉर्म का एक अलग तरीका है। ऐसा इसलिए है क्योंकि उन्हें प्रत्येक को सिस्टम लाइब्रेरी (और सिस्टम एक्सटेंशन) का उपयोग करने की आवश्यकता है। एक क्रॉस प्लेटफ़ॉर्म समाधान के लिए, आपको इनमें से प्रत्येक समाधान को लेना होगा और फिर उचित दृष्टिकोण करने के लिए प्लेटफ़ॉर्म चेक में लपेटना होगा।

विंडोज़ के लिए, आप pywin32 एक्सटेंशन का उपयोग करने में सक्षम हो सकते हैं । win32api.keybd_event

win32api.keybd_event

keybd_event (bVk, bScan, dwFlags, dwExtraInfo)

एक कीबोर्ड घटना का अनुकरण करें

पैरामीटर

bVk: BYTE - वर्चुअल-कुंजी कोड
bScan: BYTE - हार्डवेयर स्कैन कोड
dwFlags = 0: DWORD - विभिन्न फ़ंक्शन विकल्पों को निर्दिष्ट करने वाले झंडे
dwExtraInfo = 0: DWORD - कीस्ट्रोक से संबंधित अतिरिक्त डेटा

आपको इसे ठीक से उपयोग करने के लिए pywin32 की जांच करने की आवश्यकता होगी, क्योंकि मैंने कभी इसका उपयोग नहीं किया है।


2

केवल Windows: आप या तो Ironpython या एक लाइब्रेरी का उपयोग कर सकते हैं जो cPython को विंडोज़ पर .NET फ्रेमवर्क का उपयोग करने की अनुमति देता है। उसके बाद .NET के Sendkeys वर्ग का उपयोग करें या एक कीस्ट्रोक को अनुकरण करने के लिए अधिक सामान्य भेजें

ओएस एक्स केवल: उपयोग PyObjC तो उपयोग का उपयोग CGEventCreateKeyboardEventकॉल।

पूर्ण प्रकटीकरण: मैंने इसे केवल पायथन के साथ ओएस एक्स पर किया है, लेकिन मैंने .NET sendkeys (C # के साथ) का उपयोग किया है और यह बहुत अच्छा काम करता है।


मैंने IronPython से .net SendKeys का उपयोग किया है (एक डेस्कटॉप ऐप की स्वीकृति परीक्षण रूपरेखा के लिए) और इसने बहुत अच्छा काम किया।
जोनाथन हार्टले

1
python for .net। आ समाधान, मैं कैसे तो प्रयोग करेंगे sendkeys। क्या आप संभवतः इसका एक उदाहरण दे सकते हैं?
इबार रोज

2

मैक ओ एस

यहाँ कोड के उदाहरण के साथ वर्ग के रूप में @Phylliida उत्तर का अधिक पूर्ण संस्करण दिया गया है:

#!/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)

यहाँ उपरोक्त वर्ग का उपयोग करते हुए डेमो कोड है:

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

जो टाइपिंग का अनुकरण करेगा Hello World! वर्तमान विंडो पर पाठ का ।

आप शेल स्क्रिप्ट के रूप में कोड से ऊपर चला सकते हैं। के लिंक की जाँच करेंkeyboard.pyफ़ाइल


2

Python2.7 (windows32) के लिए मैंने केवल pywin32-223 स्थापित किया । और मैंने सरल अजगर का कोड लिखा:

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)

यदि आप कोड चलाते हैं और तुरंत नोटपैड विंडो (जहां पाठ पहले से मौजूद है) पर जाएं और कर्सर को शीर्ष रेखा पर रखें।


यह ठीक उसी keybd_event फ़ंक्शन पहले से ही ctypes में मौजूद है
ऑब्जेक्ट-

ctypes.windll.user32.keybd_event (0x01, 0, 0, 0)
वस्तु-वस्तु

0

अनुशंसित उत्तर के कोड के बारे में,

मेरे बॉट के लिए अनुशंसित जवाब से काम नहीं चला। ऐसा इसलिए है क्योंकि मैं Chrome का उपयोग कर रहा हूं जो मुझे अपने dwFlags में KEYEVENTF_SCANCODE का उपयोग करने की आवश्यकता है।

काम करने के लिए उसका कोड प्राप्त करने के लिए मुझे इन कोड ब्लॉक को संशोधित करना पड़ा:

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

मुझे आशा है कि यह किसी के सिरदर्द में मदद करता है!


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

2
StackOverflow में आपका स्वागत है। हालांकि यह कोड प्रश्न को हल कर सकता है, जिसमें यह भी बताया गया है कि यह समस्या कैसे और क्यों हल करती है, इससे वास्तव में आपके पोस्ट की गुणवत्ता को बेहतर बनाने में मदद मिलेगी, और शायद अधिक वोट भी मिलेंगे। याद रखें कि आप भविष्य में पाठकों के लिए सवाल का जवाब दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है। कृपया स्पष्टीकरण जोड़ने के लिए अपने उत्तर को संपादित करें और संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं।
रूली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.