উত্তর এখানে তথ্যপূর্ণ ছিল, কিন্তু আমি এও পৃথক ঘটনা মূল প্রক্রিয়া বন্ধ অ্যাসিঙ্ক্রোনাস এবং অগ্নি মূল প্রক্রিয়া পেতে একটি উপায় চেয়েছিলেন, একটি থ্রেড-নিরাপদ, ক্রস-প্ল্যাটফর্ম ভাবে সব। পাইগেমটিও আমার পক্ষে খুব বেশি ফুলে উঠেছে। সুতরাং আমি নিম্নলিখিতটি তৈরি করেছি (পাইথন ২.7 এ তবে আমি সন্দেহ করি এটি সহজেই বহনযোগ্য), যা আমি অনুভব করেছি যে এটি অন্য কারও পক্ষে কার্যকর হলে আমি এখানে ভাগ করে নিই। আমি এটিকে কীপ্রেস.পিপি নামের একটি ফাইলে সংরক্ষণ করেছি।
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)
import threading
# From https://stackoverflow.com/a/2022629/2924421
class Event(list):
def __call__(self, *args, **kwargs):
for f in self:
f(*args, **kwargs)
def __repr__(self):
return "Event(%s)" % list.__repr__(self)
def getKey():
inkey = _Getch()
import sys
for i in xrange(sys.maxint):
k=inkey()
if k<>'':break
return k
class KeyCallbackFunction():
callbackParam = None
actualFunction = None
def __init__(self, actualFunction, callbackParam):
self.actualFunction = actualFunction
self.callbackParam = callbackParam
def doCallback(self, inputKey):
if not self.actualFunction is None:
if self.callbackParam is None:
callbackFunctionThread = threading.Thread(target=self.actualFunction, args=(inputKey,))
else:
callbackFunctionThread = threading.Thread(target=self.actualFunction, args=(inputKey,self.callbackParam))
callbackFunctionThread.daemon = True
callbackFunctionThread.start()
class KeyCapture():
gotKeyLock = threading.Lock()
gotKeys = []
gotKeyEvent = threading.Event()
keyBlockingSetKeyLock = threading.Lock()
addingEventsLock = threading.Lock()
keyReceiveEvents = Event()
keysGotLock = threading.Lock()
keysGot = []
keyBlockingKeyLockLossy = threading.Lock()
keyBlockingKeyLossy = None
keyBlockingEventLossy = threading.Event()
keysBlockingGotLock = threading.Lock()
keysBlockingGot = []
keyBlockingGotEvent = threading.Event()
wantToStopLock = threading.Lock()
wantToStop = False
stoppedLock = threading.Lock()
stopped = True
isRunningEvent = False
getKeyThread = None
keyFunction = None
keyArgs = None
# Begin capturing keys. A seperate thread is launched that
# captures key presses, and then these can be received via get,
# getAsync, and adding an event via addEvent. Note that this
# will prevent the system to accept keys as normal (say, if
# you are in a python shell) because it overrides that key
# capturing behavior.
# If you start capture when it's already been started, a
# InterruptedError("Keys are still being captured")
# will be thrown
# Note that get(), getAsync() and events are independent, so if a key is pressed:
#
# 1: Any calls to get() that are waiting, with lossy on, will return
# that key
# 2: It will be stored in the queue of get keys, so that get() with lossy
# off will return the oldest key pressed not returned by get() yet.
# 3: All events will be fired with that key as their input
# 4: It will be stored in the list of getAsync() keys, where that list
# will be returned and set to empty list on the next call to getAsync().
# get() call with it, aand add it to the getAsync() list.
def startCapture(self, keyFunction=None, args=None):
# Make sure we aren't already capturing keys
self.stoppedLock.acquire()
if not self.stopped:
self.stoppedLock.release()
raise InterruptedError("Keys are still being captured")
return
self.stopped = False
self.stoppedLock.release()
# If we have captured before, we need to allow the get() calls to actually
# wait for key presses now by clearing the event
if self.keyBlockingEventLossy.is_set():
self.keyBlockingEventLossy.clear()
# Have one function that we call every time a key is captured, intended for stopping capture
# as desired
self.keyFunction = keyFunction
self.keyArgs = args
# Begin capturing keys (in a seperate thread)
self.getKeyThread = threading.Thread(target=self._threadProcessKeyPresses)
self.getKeyThread.daemon = True
self.getKeyThread.start()
# Process key captures (in a seperate thread)
self.getKeyThread = threading.Thread(target=self._threadStoreKeyPresses)
self.getKeyThread.daemon = True
self.getKeyThread.start()
def capturing(self):
self.stoppedLock.acquire()
isCapturing = not self.stopped
self.stoppedLock.release()
return isCapturing
# Stops the thread that is capturing keys on the first opporunity
# has to do so. It usually can't stop immediately because getting a key
# is a blocking process, so this will probably stop capturing after the
# next key is pressed.
#
# However, Sometimes if you call stopCapture it will stop before starting capturing the
# next key, due to multithreading race conditions. So if you want to stop capturing
# reliably, call stopCapture in a function added via addEvent. Then you are
# guaranteed that capturing will stop immediately after the rest of the callback
# functions are called (before starting to capture the next key).
def stopCapture(self):
self.wantToStopLock.acquire()
self.wantToStop = True
self.wantToStopLock.release()
# Takes in a function that will be called every time a key is pressed (with that
# key passed in as the first paramater in that function)
def addEvent(self, keyPressEventFunction, args=None):
self.addingEventsLock.acquire()
callbackHolder = KeyCallbackFunction(keyPressEventFunction, args)
self.keyReceiveEvents.append(callbackHolder.doCallback)
self.addingEventsLock.release()
def clearEvents(self):
self.addingEventsLock.acquire()
self.keyReceiveEvents = Event()
self.addingEventsLock.release()
# Gets a key captured by this KeyCapture, blocking until a key is pressed.
# There is an optional lossy paramater:
# If True all keys before this call are ignored, and the next pressed key
# will be returned.
# If False this will return the oldest key captured that hasn't
# been returned by get yet. False is the default.
def get(self, lossy=False):
if lossy:
# Wait for the next key to be pressed
self.keyBlockingEventLossy.wait()
self.keyBlockingKeyLockLossy.acquire()
keyReceived = self.keyBlockingKeyLossy
self.keyBlockingKeyLockLossy.release()
return keyReceived
else:
while True:
# Wait until a key is pressed
self.keyBlockingGotEvent.wait()
# Get the key pressed
readKey = None
self.keysBlockingGotLock.acquire()
# Get a key if it exists
if len(self.keysBlockingGot) != 0:
readKey = self.keysBlockingGot.pop(0)
# If we got the last one, tell us to wait
if len(self.keysBlockingGot) == 0:
self.keyBlockingGotEvent.clear()
self.keysBlockingGotLock.release()
# Process the key (if it actually exists)
if not readKey is None:
return readKey
# Exit if we are stopping
self.wantToStopLock.acquire()
if self.wantToStop:
self.wantToStopLock.release()
return None
self.wantToStopLock.release()
def clearGetList(self):
self.keysBlockingGotLock.acquire()
self.keysBlockingGot = []
self.keysBlockingGotLock.release()
# Gets a list of all keys pressed since the last call to getAsync, in order
# from first pressed, second pressed, .., most recent pressed
def getAsync(self):
self.keysGotLock.acquire();
keysPressedList = list(self.keysGot)
self.keysGot = []
self.keysGotLock.release()
return keysPressedList
def clearAsyncList(self):
self.keysGotLock.acquire();
self.keysGot = []
self.keysGotLock.release();
def _processKey(self, readKey):
# Append to list for GetKeyAsync
self.keysGotLock.acquire()
self.keysGot.append(readKey)
self.keysGotLock.release()
# Call lossy blocking key events
self.keyBlockingKeyLockLossy.acquire()
self.keyBlockingKeyLossy = readKey
self.keyBlockingEventLossy.set()
self.keyBlockingEventLossy.clear()
self.keyBlockingKeyLockLossy.release()
# Call non-lossy blocking key events
self.keysBlockingGotLock.acquire()
self.keysBlockingGot.append(readKey)
if len(self.keysBlockingGot) == 1:
self.keyBlockingGotEvent.set()
self.keysBlockingGotLock.release()
# Call events added by AddEvent
self.addingEventsLock.acquire()
self.keyReceiveEvents(readKey)
self.addingEventsLock.release()
def _threadProcessKeyPresses(self):
while True:
# Wait until a key is pressed
self.gotKeyEvent.wait()
# Get the key pressed
readKey = None
self.gotKeyLock.acquire()
# Get a key if it exists
if len(self.gotKeys) != 0:
readKey = self.gotKeys.pop(0)
# If we got the last one, tell us to wait
if len(self.gotKeys) == 0:
self.gotKeyEvent.clear()
self.gotKeyLock.release()
# Process the key (if it actually exists)
if not readKey is None:
self._processKey(readKey)
# Exit if we are stopping
self.wantToStopLock.acquire()
if self.wantToStop:
self.wantToStopLock.release()
break
self.wantToStopLock.release()
def _threadStoreKeyPresses(self):
while True:
# Get a key
readKey = getKey()
# Run the potential shut down function
if not self.keyFunction is None:
self.keyFunction(readKey, self.keyArgs)
# Add the key to the list of pressed keys
self.gotKeyLock.acquire()
self.gotKeys.append(readKey)
if len(self.gotKeys) == 1:
self.gotKeyEvent.set()
self.gotKeyLock.release()
# Exit if we are stopping
self.wantToStopLock.acquire()
if self.wantToStop:
self.wantToStopLock.release()
self.gotKeyEvent.set()
break
self.wantToStopLock.release()
# If we have reached here we stopped capturing
# All we need to do to clean up is ensure that
# all the calls to .get() now return None.
# To ensure no calls are stuck never returning,
# we will leave the event set so any tasks waiting
# for it immediately exit. This will be unset upon
# starting key capturing again.
self.stoppedLock.acquire()
# We also need to set this to True so we can start up
# capturing again.
self.stopped = True
self.stopped = True
self.keyBlockingKeyLockLossy.acquire()
self.keyBlockingKeyLossy = None
self.keyBlockingEventLossy.set()
self.keyBlockingKeyLockLossy.release()
self.keysBlockingGotLock.acquire()
self.keyBlockingGotEvent.set()
self.keysBlockingGotLock.release()
self.stoppedLock.release()
ধারণাটি হ'ল আপনি হয় কেবল কল করতে পারেন keyPress.getKey(), যা কীবোর্ড থেকে একটি কী পড়বে, তারপরে ফিরে আসবে।
আপনি যদি এর চেয়ে বেশি কিছু চান তবে আমি একটি KeyCaptureজিনিস তৈরি করেছিলাম । আপনি যেমন কিছু মাধ্যমে একটি তৈরি করতে পারেন keys = keyPress.KeyCapture()।
তারপরে তিনটি জিনিস আপনি করতে পারেন:
addEvent(functionName)একটি পরামিতি লাগে যে কোনও ফাংশন লাগে। তারপরে প্রতিবার কোনও কী টিপে গেলে, এই ইনপুট হিসাবে এই ফাংশনটিকে সেই কীটির স্ট্রিং দিয়ে ডাকা হবে। এগুলি একটি পৃথক থ্রেডে চালিত হয়, যাতে আপনি এগুলিতে যা চান তা ব্লক করতে পারেন এবং এটি কী-ক্যাপচারারের কার্যকারিতা বিঘ্নিত করবে না বা অন্যান্য ইভেন্টগুলিতে বিলম্ব করবে না।
get()আগের মতো একই ব্লক করে একটি কী প্রদান করে। এটি এখন এখানে প্রয়োজন কারণ কীগুলি KeyCaptureএখন অবজেক্টের মাধ্যমে ক্যাপচার করা হচ্ছে , সুতরাং keyPress.getKey()সেই আচরণের সাথে দ্বন্দ্ব হবে এবং উভয়ই কিছু কী মিস করবে কারণ একসাথে কেবল একটি চাবি ক্যাপচার করা যেতে পারে। এছাড়াও, বলুন যে ব্যবহারকারী 'ক' টিপুন, তারপরে 'বি', আপনি কল করেছেন get(), ব্যবহারকারী 'সি' টিপেন। সেই get()কলটি তত্ক্ষণাত 'ক' ফিরে আসবে, তারপরে আপনি যদি আবার কল করেন তবে এটি 'বি', তারপরে 'সি' ফিরে আসবে। আপনি যদি আবার কল করেন তবে এটি অন্য কী টিপ না দেওয়া অবধি বন্ধ হয়ে যাবে। এটি নিশ্চিত করে যে আপনি কোনও কীগুলি মিস করবেন না, যদি ইচ্ছা হয় তবে অবরুদ্ধ উপায়ে। সুতরাং এইভাবে এটি keyPress.getKey()আগের চেয়ে কিছুটা আলাদা
আপনি যদি getKey()পিছনের আচরণ চান তবে এটির get(lossy=True)মতো get(), এটি কেবলমাত্র কল করার পরে চাপানো কীগুলি দেয় get()। সুতরাং উপরের উদাহরণে, get()ব্যবহারকারী 'সি' চাপ না দেওয়া পর্যন্ত অবরুদ্ধ হবে এবং তারপরে আপনি যদি আবার কল করেন তবে এটি অন্য কী টিপ না দেওয়া অবধি ব্লক হয়ে যাবে।
getAsync()কিছুটা আলাদা এটি এমন কোনও কিছুর জন্য ডিজাইন করা হয়েছে যা প্রচুর প্রক্রিয়াজাতকরণ করে, তারপর মাঝে মাঝে ফিরে আসে এবং কোন কীগুলি চাপানো হয়েছিল তা পরীক্ষা করে। সুতরাং getAsync()সমস্ত কী শেষ কল থেকে চাপা একটি তালিকা ফেরৎ getAsync()প্রাচীনতম সাম্প্রতিকতম কী চাপা কী থেকে জন্য, চাপা। এটিও অবরুদ্ধ হয় না, এর অর্থ হ'ল শেষ কল করার পরে যদি কোনও কী চাপানো না হয় getAsync(), একটি খালি []ফিরে আসবে।
কীগুলি ক্যাপচার করতে শুরু করতে, আপনাকে উপরে তৈরি করা সামগ্রীর keys.startCapture()সাথে কল করতে হবে keys। startCaptureঅবরুদ্ধকরণ নয়, এবং কেবল এমন এক থ্রেড শুরু হয় যা কেবল কী টিপে রেকর্ড করে এবং সেই কী টিপুনগুলি প্রক্রিয়া করার জন্য অন্য থ্রেড। দু'টি থ্রেড রয়েছে তা নিশ্চিত করতে যে থ্রেডে কী টিপস রেকর্ড করে যে কোনও কী মিস করে না।
আপনি কীগুলি ক্যাপচারিং বন্ধ করতে চাইলে, আপনি কল করতে পারেন keys.stopCapture()এবং এটি কীগুলি ক্যাপচারিং বন্ধ করবে। যাইহোক, যেহেতু কীটি ক্যাপচার করা একটি ব্লকিং অপারেশন, থ্রেড ক্যাপচারিং কীগুলি কল করার পরে আরও একটি কী ক্যাপচার করতে পারে stopCapture()।
এটি প্রতিরোধ করতে, আপনি startCapture(functionName, args)কোনও ফাংশনটির মধ্যে একটি alচ্ছিক প্যারামিটারগুলিতে প্রবেশ করতে পারেন যা কোনও চাবির মতো কিছু করে যদি কোনও কী 'সি' এর সমান হয় এবং তারপরে বাইরে চলে যায়। এটি গুরুত্বপূর্ণ যে এই ফাংশনটি খুব আগে করা উচিত, উদাহরণস্বরূপ, এখানে ঘুম আমাদের চাবিগুলি মিস করতে বাধ্য করবে।
যাইহোক, যদি stopCapture()এই ফাংশনটিতে ডাকা হয়, কী ক্যাপচারগুলি তত্ক্ষণাত বন্ধ করা হবে, আর কোনও ক্যাপচারের চেষ্টা না করে এবং সমস্ত get()কলগুলি তত্ক্ষণাত্ ফিরে আসবে, যদি কোনও কী টিপে না দেওয়া হয় তা না করেই None
এছাড়াও, পূর্ববর্তী সমস্ত কীগুলি চাপলে get()এবং getAsync()সংরক্ষণ করুন (যতক্ষণ না আপনি সেগুলি পুনরুদ্ধার করবেন), আপনি কল করতে পারেন clearGetList()এবং clearAsyncList()কীগুলি পূর্বে চাপানো হয়েছে তা ভুলে যেতে পারেন ।
মনে রাখবেন যে get(), getAsync()এবং ইভেন্টগুলি স্বতন্ত্র, সুতরাং যদি কোনও কী টিপানো হয়: ১. একটি কলটি get()অপেক্ষায় রয়েছে, ক্ষতির সাথে, কীটি ফিরে আসবে। অন্যান্য অপেক্ষার কলগুলি (যদি থাকে) অপেক্ষারত চলবে। ২. কীটি কীগুলি পাওয়ার কীগুলির কাতারে সংরক্ষণ করা হবে, যাতে get()ক্ষয়ক্ষতি বন্ধ হয়ে get()এখনও পুরানো চাবিটি ফিরে আসে না । ৩. সমস্ত ইভেন্টগুলি কীটি দিয়ে তাদের ইনপুট হিসাবে নিক্ষেপ করা হবে 4.. কীটি getAsync()কীগুলির তালিকায় সংরক্ষণ করা হবে , যেখানে সেই লিস টুইলটি ফিরে আসবে এবং পরের কলটিতে খালি তালিকায় সেট হবেgetAsync()
এগুলি যদি খুব বেশি হয় তবে এখানে ব্যবহারের উদাহরণ রয়েছে:
import keyPress
import time
import threading
def KeyPressed(k, printLock):
printLock.acquire()
print "Event: " + k
printLock.release()
time.sleep(4)
printLock.acquire()
print "Event after delay: " + k
printLock.release()
def GetKeyBlocking(keys, printLock):
while keys.capturing():
keyReceived = keys.get()
time.sleep(1)
printLock.acquire()
if not keyReceived is None:
print "Block " + keyReceived
else:
print "Block None"
printLock.release()
def GetKeyBlockingLossy(keys, printLock):
while keys.capturing():
keyReceived = keys.get(lossy=True)
time.sleep(1)
printLock.acquire()
if not keyReceived is None:
print "Lossy: " + keyReceived
else:
print "Lossy: None"
printLock.release()
def CheckToClose(k, (keys, printLock)):
printLock.acquire()
print "Close: " + k
printLock.release()
if k == "c":
keys.stopCapture()
printLock = threading.Lock()
print "Press a key:"
print "You pressed: " + keyPress.getKey()
print ""
keys = keyPress.KeyCapture()
keys.addEvent(KeyPressed, printLock)
print "Starting capture"
keys.startCapture(CheckToClose, (keys, printLock))
getKeyBlockingThread = threading.Thread(target=GetKeyBlocking, args=(keys, printLock))
getKeyBlockingThread.daemon = True
getKeyBlockingThread.start()
getKeyBlockingThreadLossy = threading.Thread(target=GetKeyBlockingLossy, args=(keys, printLock))
getKeyBlockingThreadLossy.daemon = True
getKeyBlockingThreadLossy.start()
while keys.capturing():
keysPressed = keys.getAsync()
printLock.acquire()
if keysPressed != []:
print "Async: " + str(keysPressed)
printLock.release()
time.sleep(1)
print "done capturing"
আমি যে সাধারণ পরীক্ষাটি করেছি তা থেকে এটি আমার পক্ষে ভাল কাজ করছে, তবে আমি যদি কিছু মিস করি তবে আমি আনন্দের সাথে অন্যদের প্রতিক্রিয়া জানাব।
আমি এখানে এটি পোস্ট ।
msvcrt.getchসঙ্গেmsvcrt.getwchসেখানে প্রস্তাব।