टर्मिनल से स्क्रिप्ट में कीबोर्ड इनपुट का पता कैसे लगाएं?

सिंक्रोनस/ब्लॉकिंग कुंजी कैप्चर:

एक साधारण इनपुट या raw_input, एक ब्लॉकिंग फ़ंक्शन जो एक नई लाइन दबाने पर उपयोगकर्ता द्वारा टाइप किया गया टेक्स्ट लौटाता है।

typedString = raw_input()

एक सरल अवरोधक फ़ंक्शन जो उपयोगकर्ता द्वारा एक कुंजी दबाने की प्रतीक्षा करता है, फिर वह कुंजी लौटाता है

class _Getch:
 """Gets a single character from standard input.  Does not echo to the
screen. From http://code.activestate.com/recipes/134892/"""
def __init__(self):
  try:
    self.impl = _GetchWindows()
  except ImportError:
    try:
      self.impl = _GetchMacCarbon()
    except(AttributeError, ImportError):
      self.impl = _GetchUnix()

def __call__(self): return self.impl()


class _GetchUnix:
def __init__(self):
  import tty, sys, termios # import termios now or else you'll get the Unix version on the Mac

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:
def __init__(self):
  import msvcrt

def __call__(self):
  import msvcrt
  return msvcrt.getch()

class _GetchMacCarbon:
"""
A function which returns the current ASCII key that is down;
if no ASCII key is down, the null string is returned.  The
page http://www.mactech.com/macintosh-c/chap02-1.html was
very helpful in figuring out how to do this.
"""
def __init__(self):
  import Carbon
  Carbon.Evt #see if it has this (in Unix, it doesn't)

def __call__(self):
  import Carbon
  if Carbon.Evt.EventAvail(0x0008)[0]==0: # 0x0008 is the keyDownMask
    return ''
  else:
    #
    # The event contains the following info:
    # (what,msg,when,where,mod)=Carbon.Evt.GetNextEvent(0x0008)[1]
    #
    # The message (msg) contains the ASCII char which is
    # extracted with the 0x000000FF charCodeMask; this
    # number is converted to an ASCII character with chr() and
    # returned
    #
    (what,msg,when,where,mod)=Carbon.Evt.GetNextEvent(0x0008)[1]
    return chr(msg & 0x000000FF)


def getKey():
  inkey = _Getch()
  import sys
  for i in xrange(sys.maxint):
    k=inkey()
    if k<>'':break

  return k

एसिंक्रोनस कुंजी कैप्चर:

जब भी उपयोगकर्ता कमांड प्रॉम्प्ट में एक कुंजी टाइप करता है, तो एक कॉलबैक जिसे दबाए गए कुंजी के साथ कॉल किया जाता है, यहां तक ​​​​कि एक दुभाषिया (एक कीलॉगर) में चीजें टाइप करते समय भी

कॉलबैक अभी तक लागू नहीं किया गया है।

एक कॉलबैक जिसे टाइप किए गए टेक्स्ट के बाद कॉल किया जाता है उपयोगकर्ता एंटर दबाता है (एक कम रीयलटाइम कीलॉगर)

कॉलबैक अभी तक लागू नहीं किया गया है।

एक कॉलबैक जिसे प्रोग्राम चलने पर दबाए गए कुंजी के साथ कॉल किया जाता है (मान लीजिए) , लूप के लिए या थोड़ी देर में लूप)

विंडोज़:

import threading
from win32api import STD_INPUT_HANDLE
from win32console import GetStdHandle, KEY_EVENT, ENABLE_ECHO_INPUT, ENABLE_LINE_INPUT, ENABLE_PROCESSED_INPUT


class KeyAsyncReader():
  def __init__(self):
    self.stopLock = threading.Lock()
    self.stopped = True
    self.capturedChars = ""

    self.readHandle = GetStdHandle(STD_INPUT_HANDLE)
    self.readHandle.SetConsoleMode(ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT|ENABLE_PROCESSED_INPUT)



  def startReading(self, readCallback):
    self.stopLock.acquire()

    try:
      if not self.stopped:
        raise Exception("Capture is already going")

      self.stopped = False
      self.readCallback = readCallback

      backgroundCaptureThread = threading.Thread(target=self.backgroundThreadReading)
      backgroundCaptureThread.daemon = True
      backgroundCaptureThread.start()
    except:
      self.stopLock.release()
      raise

    self.stopLock.release()


  def backgroundThreadReading(self):
    curEventLength = 0
    curKeysLength = 0
    while True:
      eventsPeek = self.readHandle.PeekConsoleInput(10000)

      self.stopLock.acquire()
      if self.stopped:
        self.stopLock.release()
        return
      self.stopLock.release()


      if len(eventsPeek) == 0:
        continue

      if not len(eventsPeek) == curEventLength:
        if self.getCharsFromEvents(eventsPeek[curEventLength:]):
          self.stopLock.acquire()
          self.stopped = True
          self.stopLock.release()
          break

        curEventLength = len(eventsPeek)



  def getCharsFromEvents(self, eventsPeek):
    callbackReturnedTrue = False
    for curEvent in eventsPeek:
      if curEvent.EventType == KEY_EVENT:
              if ord(curEvent.Char) == 0 or not curEvent.KeyDown:
                pass
              else:
                curChar = str(curEvent.Char)
                if self.readCallback(curChar) == True:
                  callbackReturnedTrue = True


    return callbackReturnedTrue

  def stopReading(self):
    self.stopLock.acquire()
    self.stopped = True
    self.stopLock.release()

मतदान:

उपयोगकर्ता बस कुंजी दबाए जाने पर कुछ करने में सक्षम होना चाहता है, उस कुंजी की प्रतीक्षा किए बिना (इसलिए यह गैर होना चाहिए) -अवरुद्ध करना)। इस प्रकार वे एक पोल() फ़ंक्शन को कॉल करते हैं और वह या तो एक कुंजी लौटाता है, या कोई नहीं लौटाता है। यह या तो हानिपूर्ण हो सकता है (यदि वे मतदान के बीच बहुत अधिक समय लेते हैं तो वे एक कुंजी खो सकते हैं) या गैर-हानिपूर्ण (पोलर दबाए गए सभी कुंजी के इतिहास को संग्रहीत करेगा, इसलिए जब मतदान() फ़ंक्शन उनसे अनुरोध करता है तो उन्हें हमेशा वापस कर दिया जाएगा) दबाए गए क्रम में)।

Windows और OS isWindows = ग़लत कोशिश करना: Win32api से STD_INPUT_HANDLE आयात करें Win32console से GetStdHandle, KEY_EVENT, ENABLE_ECHO_INPUT, ENABLE_LINE_INPUT, ENABLE_PROCESSED_INPUT आयात करें isWindows = सत्य ई के रूप में आयात त्रुटि को छोड़कर: आयात sys आयात चयन करें टर्मियोस आयात करें क्लास कीपोलर(): def __प्रवेश__(स्वयं): वैश्विक विंडोज़ है यदि विंडोज़ है: self.readHandle = GetStdHandle(STD_INPUT_HANDLE) self.readHandle.SetConsoleMode(ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT|ENABLE_PROCESSED_INPUT) self.curEventLength = 0 self.curKeysLength = 0 self.capturedChars = [] अन्य: # टर्मिनल सेटिंग्स सहेजें self.fd = sys.stdin.fileno() self.new_term = टर्मियोस.tcgetattr(self.fd) self.old_term = टर्मियोस.tcgetattr(self.fd) # नई टर्मिनल सेटिंग अनबफ़र्ड self.new_term[3] = (self.new_term[3] & ~termios.ICANON & ~termios.ECHO) टर्मियोस.tcsetattr(सेल्फ.एफडी, टर्मिओस.टीसीएसएएफएलयूएसएच, सेल्फ.न्यू_टर्म) स्वयं लौटें def __exit__(स्वयं, प्रकार, मान, ट्रेसबैक): यदि विंडोज़ है: उत्तीर्ण अन्य: टर्मियोस.टीसीसेटएटीआर(सेल्फ.एफडी, टर्मिओस.टीसीएसएएफएलयूएसएच, सेल्फ.ओल्ड_टर्म) डीईएफ़ पोल(स्वयं): यदि विंडोज़ है: यदि नहीं len(self.capturedChars) == 0: self.capturedChars.pop(0) वापस करें इवेंटपीक = self.readHandle.PeekConsoleInput(10000)