Pythonはユーザーから1文字を読みます
ユーザー入力から1文字を読み取る方法はありますか？たとえば、端末で1つのキーを押すとそれが返されます（getch()のようなものです）。それにはWindowsに関数があることは知っていますが、クロスプラットフォームのものが欲しいのですが。
これは、Windows、Linux、およびOSXで1文字を読み取る方法を説明しているサイトへのリンクです。 http://code.activestate.com/recipes/134892/
class _Getch:
"""Gets a single character from standard input. Does not echo to the
screen."""
def __init__(self):
try:
self.impl = _GetchWindows()
except ImportError:
self.impl = _GetchUnix()
def __call__(self): return self.impl()
class _GetchUnix:
def __init__(self):
import tty, sys
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()
getch = _Getch()
sys.stdin.read(1)
基本的にはSTDINから1バイトを読み込みます。
\nを待たない方法を使用する必要がある場合は、前の回答で提案したようにこのコードを使用できます。
class _Getch:
"""Gets a single character from standard input. Does not echo to the screen."""
def __init__(self):
try:
self.impl = _GetchWindows()
except ImportError:
self.impl = _GetchUnix()
def __call__(self): return self.impl()
class _GetchUnix:
def __init__(self):
import tty, sys
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()
getch = _Getch()
ActiveState recipe 2つの答えの中で逐語的に引用されている部分は、過剰設計されています。これは以下のようにまとめることができます。
def _find_getch():
try:
import termios
except ImportError:
# Non-POSIX. Return msvcrt's (Windows') getch.
import msvcrt
return msvcrt.getch
# POSIX system. Create and return a getch that manipulates the tty.
import sys, tty
def _getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
return _getch
getch = _find_getch()
試してみる価値がある readchar ライブラリもあります。これは、他の回答で述べたActiveStateレシピに一部基づいています。
インストール：
pip install readchar
使用法：
import readchar
print("Reading a char:")
print(repr(readchar.readchar()))
print("Reading a key:")
print(repr(readchar.readkey()))
WindowsとLinux上でPython 2.7でテストされています。
Windowsでは、文字またはASCII制御コードに対応するキーのみがサポートされています（Backspace、 Enter、 Esc、 Tab、 Ctrl+文字） GNU/Linux（正確な端末によりますが、多分？）では Insert、 Delete、 Pg Up、 Pg Dn、 Home、 End そして F n キー...しかし、それから、これらから特別なキーを分離する問題があります Esc。
警告：ここでのほとんどの（すべての）答えと同様に、次のようなシグナルキー Ctrl+C、 Ctrl+D そして Ctrl+Z キャッチされて返されます（それぞれ'\x03'、'\x04'および'\x1a'として）。あなたのプログラムは中断するのが難しくなる可能性があります。
代替方法
import os
import sys
import termios
import fcntl
def getch():
fd = sys.stdin.fileno()
oldterm = termios.tcgetattr(fd)
newattr = termios.tcgetattr(fd)
newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
termios.tcsetattr(fd, termios.TCSANOW, newattr)
oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)
try:
while 1:
try:
c = sys.stdin.read(1)
break
except IOError: pass
finally:
termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
return c
から このブログ記事 。
現時点では非常にぎこちなくなっていると思いますし、異なるプラットフォームでのデバッグは大変な作業です。
Pyglet、pygame、cocos2dのようなものを使うほうがいいでしょう - これよりももっと手の込んだものをやっていてビジュアルが必要な場合は、ORcurses端末で作業する場合は。
here を基にしたこのコードでは、KeyboardInterruptとEOFErrorが正しく発生します。 Ctrl+C または Ctrl+D 押されています。
WindowsとLinuxで動作するはずです。 OS Xバージョンはオリジナルのソースから入手できます。
class _Getch:
"""Gets a single character from standard input. Does not echo to the screen."""
def __init__(self):
try:
self.impl = _GetchWindows()
except ImportError:
self.impl = _GetchUnix()
def __call__(self):
char = self.impl()
if char == '\x03':
raise KeyboardInterrupt
Elif char == '\x04':
raise EOFError
return char
class _GetchUnix:
def __init__(self):
import tty
import sys
def __call__(self):
import sys
import tty
import 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()
getch = _Getch()
（現在の）トップランクの回答（ActiveStateコード付き）は非常に複雑です。単なる関数で十分な場合にクラスを使用する理由はわかりません。以下は、同じことを実行する2つの実装ですが、より読みやすいコードを使用しています。
これら両方の実装：
- python 2またはPython 3でうまく動作する
- windows、OSX、およびLinuxで動作します。
- 1バイトだけ読む（つまり、改行を待たない）
- 外部のライブラリに依存しない
- 自己完結型である（関数定義の外側にコードがない）
バージョン1：読みやすくてシンプル
def getChar():
try:
# for Windows-based systems
import msvcrt # If successful, we are on Windows
return msvcrt.getch()
except ImportError:
# for POSIX-based systems (with termios & tty support)
import tty, sys, termios # raises ImportError if unsupported
fd = sys.stdin.fileno()
oldSettings = termios.tcgetattr(fd)
try:
tty.setcbreak(fd)
answer = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, oldSettings)
return answer
バージョン2：繰り返しインポートや例外処理を避ける：
[EDIT]私はActiveStateコードの一つの利点を逃しました。文字を複数回読み取ることを計画している場合は、そのコードによって、UNIXのようなシステムでWindowsのインポートとImportError例外処理を繰り返す（無視できる）コストが回避されます。ごくわずかな最適化よりもコードの読みやすさについてもっと気にする必要がありますが、これはActiveStateコードと同じように機能し、読みやすくなる代替手段です（Louisの答えに似ていますが、getChar（）は自己完結型です）。
def getChar():
# figure out which function to use once, and store it in _func
if "_func" not in getChar.__dict__:
try:
# for Windows-based systems
import msvcrt # If successful, we are on Windows
getChar._func=msvcrt.getch
except ImportError:
# for POSIX-based systems (with termios & tty support)
import tty, sys, termios # raises ImportError if unsupported
def _ttyRead():
fd = sys.stdin.fileno()
oldSettings = termios.tcgetattr(fd)
try:
tty.setcbreak(fd)
answer = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, oldSettings)
return answer
getChar._func=_ttyRead
return getChar._func()
上記のgetChar（）バージョンのいずれかを実行するサンプルコード：
from __future__ import print_function # put at top of file if using Python 2
# Example of a Prompt for one character of input
promptStr = "Please give me a character:"
responseStr = "Thank you for giving me a '{}'."
print(promptStr, end="\n> ")
answer = getChar()
print("\n")
print(responseStr.format(answer))
答え ここ は参考になりましたが、私は非同期にキー押下を取得し、別々のイベントでキー押下を開始する方法もすべてスレッドセーフでクロスプラットフォームの方法で望んでいました。 PyGameも私にとっては肥大しすぎていました。そこで私は以下を作成しました（Python 2.7では、それは簡単に移植できると私は思います）、それは私がそれが他の誰かにとって有用であるならば私がここで共有すると考えました。これをkeyPress.pyというファイルに保存しました。
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()のようなものを通してそれを作成することができます。
それからあなたがすることができる3つの事があります：
addEvent(functionName)は、1つのパラメータを受け取る関数をすべて受け取ります。その後、キーが押されるたびに、この関数はそのキーの文字列を入力として呼び出されます。これらは別のスレッドで実行されるため、必要なものをすべてブロックして、KeyCapturerの機能を台無しにしたり、他のイベントを遅らせることはありません。
get()は、以前と同じブロック方法でキーを返します。キーは現在KeyCaptureオブジェクトを介してキャプチャーされているので、ここで必要になります。そのため、keyPress.getKey()はその動作と競合し、一度に1つのキーしかキャプチャーできないため、両方ともキーを失います。また、ユーザーが 'a'を押してから 'b'を押すと、get()が呼び出され、ユーザーは 'c'を押します。そのget()呼び出しはすぐに 'a'を返します。もう一度呼び出した場合は 'b'を返し、次に 'c'を返します。もう一度呼び出すと、別のキーが押されるまでブロックされます。これにより、必要に応じてキーを紛失することがなくなります。だからこのようにそれは前からkeyPress.getKey()とは少し異なります
getKey()の振る舞いを取り戻したい場合、get(lossy=True)はget()と似ていますが、押されたキーのみが返されるafterget()の呼び出し。そのため、上記の例では、get()はユーザーが 'c'を押すまでブロックし、それからもう一度呼び出すと別のキーが押されるまでブロックします。
getAsync()は少し異なります。それは多くの処理をする何かのために設計されていて、そして時々戻って来てそしてどのキーが押されたかチェックします。したがって、getAsync()は、最後にgetAsync()が呼び出された後に押されたすべてのキーのリストを、古いキーから最新のキーの順に返します。これもブロックされません。つまり、最後のgetAsync()の呼び出し以降キーが押されていない場合は、空の[]が返されます。
実際にキーのキャプチャを開始するには、上記で作成したkeysオブジェクトを使ってkeys.startCapture()を呼び出す必要があります。 startCaptureはノンブロッキングで、単にキーが押されたことを記録する1つのスレッドと、それらのキーが押されたことを処理する別のスレッドを開始するだけです。キー押下を記録するスレッドがキーを見逃さないようにするためのスレッドが2つあります。
キーのキャプチャを中止したい場合は、keys.stopCapture()を呼び出すと、キーのキャプチャが中止されます。ただし、キーの取得はブロッキング操作であるため、キーを取得するスレッドはstopCapture()を呼び出した後にもう1つキーを取得する可能性があります。
これを防ぐために、オプションのパラメータを関数のstartCapture(functionName, args)に渡すことができます。これは、キーが 'c'に等しいかどうかをチェックして終了するというようなものです。この機能が少し前に行われることが重要です。たとえば、ここでスリープすると、キーを見逃してしまいます。
ただし、この関数でstopCapture()が呼び出されると、それ以上キャプチャしようとせずにキーのキャプチャが直ちに停止され、すべてのget()の呼び出しがすぐに返されます。キーがまだ押されていない場合はNoneが返されます。
また、get()とgetAsync()は、直前に押されたキーをすべて（それらを取り出すまで）格納するので、clearGetList()とclearAsyncList()を呼び出して、以前に押されたキーを忘れることができます。
get()、getAsync()、およびイベントは独立しているため、キーが押された場合は、次のようになります。1.待機中のget()を1回呼び出すと、損失のある状態でそのキーが返されます。他の待機中の通話（ある場合）は待機を続けます。 2.そのキーはgetキーのキューに格納されるため、lossyがoffのget()は、get()によって返されたのではなく、押された最も古いキーを返します。 3.すべてのイベントは、そのキーを入力として使用して起動されます。4.そのキーはgetAsync()キーのリストに格納されます。ここで、そのlisは返され、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"
それは私が作った簡単なテストから私のためにうまく働いています、しかし私が逃した何かがあれば私は同様に他の人からのフィードバックをもらいます。
私はこれを投稿しました こちら も。
これはコンテキストマネージャのユースケースかもしれません。 Windows OSに余裕を残して、これが私の提案です。
#!/usr/bin/env python3
# file: 'readchar.py'
"""
Implementation of a way to get a single character of input
without waiting for the user to hit <Enter>.
(OS is Linux, Ubuntu 14.04)
"""
import tty, sys, termios
class ReadChar():
def __enter__(self):
self.fd = sys.stdin.fileno()
self.old_settings = termios.tcgetattr(self.fd)
tty.setraw(sys.stdin.fileno())
return sys.stdin.read(1)
def __exit__(self, type, value, traceback):
termios.tcsetattr(self.fd, termios.TCSADRAIN, self.old_settings)
def test():
while True:
with ReadChar() as rc:
char = rc
if ord(char) <= 32:
print("You entered character with ordinal {}."\
.format(ord(char)))
else:
print("You entered character '{}'."\
.format(char))
if char in "^C^D":
sys.exit()
if __== "__main__":
test()
他の答えの1つのコメントではcbreakモードについて言及しました。これはUnixの実装では重要です。一般的に、^ C（KeyboardErrorname__）をgetcharで消費したくないためです。他のほとんどの答えによって）。
もう1つの重要な詳細は、1つの文字ではなく1つのbyteを読み取る場合は、入力ストリームから4バイトを読み取る必要があることです。これは最大バイト数です。単一文字はUTF-8（Python 3+）で構成されます。 1バイトのみを読み取ると、キーパッドの矢印などのマルチバイト文字に対して予期しない結果が生じます。
これが私の変更したUnix用の実装です。
import contextlib
import os
import sys
import termios
import tty
_MAX_CHARACTER_BYTE_LENGTH = 4
@contextlib.contextmanager
def _tty_reset(file_descriptor):
"""
A context manager that saves the tty flags of a file descriptor upon
entering and restores them upon exiting.
"""
old_settings = termios.tcgetattr(file_descriptor)
try:
yield
finally:
termios.tcsetattr(file_descriptor, termios.TCSADRAIN, old_settings)
def get_character(file=sys.stdin):
"""
Read a single character from the given input stream (defaults to sys.stdin).
"""
file_descriptor = file.fileno()
with _tty_reset(file_descriptor):
tty.setcbreak(file_descriptor)
return os.read(file_descriptor, _MAX_CHARACTER_BYTE_LENGTH)
これを使用してみてください： http://home.wlu.edu/~levys/software/kbhit.py 非ブロッキングです（つまり、whileループを作成し、キーを押すことを停止せずに検出できます）。クロスプラットフォーム。
import os
# Windows
if os.name == 'nt':
import msvcrt
# Posix (Linux, OS X)
else:
import sys
import termios
import atexit
from select import select
class KBHit:
def __init__(self):
'''Creates a KBHit object that you can call to do various keyboard things.'''
if os.name == 'nt':
pass
else:
# Save the terminal settings
self.fd = sys.stdin.fileno()
self.new_term = termios.tcgetattr(self.fd)
self.old_term = termios.tcgetattr(self.fd)
# New terminal setting unbuffered
self.new_term[3] = (self.new_term[3] & ~termios.ICANON & ~termios.ECHO)
termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.new_term)
# Support normal-terminal reset at exit
atexit.register(self.set_normal_term)
def set_normal_term(self):
''' Resets to normal terminal. On Windows this is a no-op.
'''
if os.name == 'nt':
pass
else:
termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old_term)
def getch(self):
''' Returns a keyboard character after kbhit() has been called.
Should not be called in the same program as getarrow().
'''
s = ''
if os.name == 'nt':
return msvcrt.getch().decode('utf-8')
else:
return sys.stdin.read(1)
def getarrow(self):
''' Returns an arrow-key code after kbhit() has been called. Codes are
0 : up
1 : right
2 : down
3 : left
Should not be called in the same program as getch().
'''
if os.name == 'nt':
msvcrt.getch() # skip 0xE0
c = msvcrt.getch()
vals = [72, 77, 80, 75]
else:
c = sys.stdin.read(3)[2]
vals = [65, 67, 66, 68]
return vals.index(ord(c.decode('utf-8')))
def kbhit(self):
''' Returns True if keyboard character was hit, False otherwise.
'''
if os.name == 'nt':
return msvcrt.kbhit()
else:
dr,dw,de = select([sys.stdin], [], [], 0)
return dr != []
これを使用する例：
import kbhit
kb = kbhit.KBHit()
while(True):
print("Key not pressed") #Do something
if kb.kbhit(): #If a key is pressed:
k_in = kb.getch() #Detect what key was pressed
print("You pressed ", k_in, "!") #Do something
kb.set_normal_term()
または、PyPiの getchモジュールを使用できます 。しかし、これはwhileループをブロックします
これはNON-BLOCKINGで、キーを読み、それをkeypress.keyに保存します。
import Tkinter as tk
class Keypress:
def __init__(self):
self.root = tk.Tk()
self.root.geometry('300x200')
self.root.bind('<KeyPress>', self.onKeyPress)
def onKeyPress(self, event):
self.key = event.char
def __eq__(self, other):
return self.key == other
def __str__(self):
return self.key
あなたのプログラムで
keypress = Keypress()
while something:
do something
if keypress == 'c':
break
Elif keypress == 'i':
print('info')
else:
print("i dont understand %s" % keypress)
Pygameでこれを試してください。
import pygame
pygame.init() // eliminate error, pygame.error: video system not initialized
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE]:
d = "space key"
print "You pressed the", d, "."
Pythonのcursesパッケージは、ほんの数回の文で端末からの文字入力のために "raw"モードに入るために使うことができます。 Cursesの主な用途は出力用に画面を引き継ぐことですが、これはあなたが望むものではないかもしれません。このコードスニペットでは代わりにprint()ステートメントを使用しますが、これは使用可能ですが、cursesが出力に付加される行末をどのように変更するかを知っておく必要があります。
#!/usr/bin/python3
# Demo of single char terminal input in raw mode with the curses package.
import sys, curses
def run_one_char(dummy):
'Run until a carriage return is entered'
char = ' '
print('Welcome to curses', flush=True)
while ord(char) != 13:
char = one_char()
def one_char():
'Read one character from the keyboard'
print('\r? ', flush= True, end = '')
## A blocking single char read in raw mode.
char = sys.stdin.read(1)
print('You entered %s\r' % char)
return char
## Must init curses before calling any functions
curses.initscr()
## To make sure the terminal returns to its initial settings,
## and to set raw mode and guarantee cleanup on exit.
curses.wrapper(run_one_char)
print('Curses be gone!')
ActiveStateのレシピにはCtrl-Cの中断を妨げる「posix」システム用の小さなバグが含まれているようです（私はMacを使っています）。スクリプトに次のコードを追加したとします。
while(True):
print(getch())
私は決してCtrl-Cでスクリプトを終了させることはできないでしょう、そして私は逃げるために私の端末を殺さなければなりません。
私は次の行が原因であると思います、そしてそれもまた残酷過ぎます：
tty.setraw(sys.stdin.fileno())
それ以外の点では、パッケージttyは実際には必要ではなく、termiosでそれを処理できます。
以下は私のために働く改善されたコードです（Ctrl-Cは割り込むでしょう）、あなたがタイプすると同時にcharをエコーする追加のgetche関数があります：
if sys.platform == 'win32':
import msvcrt
getch = msvcrt.getch
getche = msvcrt.getche
else:
import sys
import termios
def __gen_ch_getter(echo):
def __fun():
fd = sys.stdin.fileno()
oldattr = termios.tcgetattr(fd)
newattr = oldattr[:]
try:
if echo:
# disable ctrl character printing, otherwise, backspace will be printed as "^?"
lflag = ~(termios.ICANON | termios.ECHOCTL)
else:
lflag = ~(termios.ICANON | termios.ECHO)
newattr[3] &= lflag
termios.tcsetattr(fd, termios.TCSADRAIN, newattr)
ch = sys.stdin.read(1)
if echo and ord(ch) == 127: # backspace
# emulate backspace erasing
# https://stackoverflow.com/a/47962872/404271
sys.stdout.write('\b \b')
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, oldattr)
return ch
return __fun
getch = __gen_ch_getter(False)
getche = __gen_ch_getter(True)
参考文献：
受け入れられた答えは、私にとってはうまくいきませんでした（キーを押したままにすると、何も起こりません。その後、別のキーを押すと機能します）。
cursesモジュールについて学習した後、実際に正しい方法のように見えます。また、Windowsで windows-cursors （pipで利用可能）を介して利用できるようになったため、プラットフォームに依存しない方法でプログラミングできます。これに触発された例を次に示します 素敵なチュートリアル YouTube：
import curses
def getkey(stdscr):
curses.curs_set(0)
while True:
key = stdscr.getch()
if key != -1:
break
return key
if __== "__main__":
print(curses.wrapper(getkey))
.py拡張子で保存するか、インタラクティブモードでcurses.wrapper(getkey)を実行します。
組み込みのraw_inputが役に立ちます。
for i in range(3):
print ("So much work to do!")
k = raw_input("Press any key to continue...")
print ("Ok, back to work.")
Python3のための私の解決策、どんなpipパッケージにも依存しない。
# precondition: import tty, sys
def query_yes_no(question, default=True):
"""
Ask the user a yes/no question.
Returns immediately upon reading one-char answer.
Accepts multiple language characters for yes/no.
"""
if not sys.stdin.isatty():
return default
if default:
Prompt = "[Y/n]?"
other_answers = "n"
else:
Prompt = "[y/N]?"
other_answers = "yjosiá"
print(question,Prompt,flush= True,end=" ")
oldttysettings = tty.tcgetattr(sys.stdin.fileno())
try:
tty.setraw(sys.stdin.fileno())
return not sys.stdin.read(1).lower() in other_answers
except:
return default
finally:
tty.tcsetattr(sys.stdin.fileno(), tty.TCSADRAIN , oldttysettings)
sys.stdout.write("\r\n")
tty.tcdrain(sys.stdin.fileno())
私はこれが最も優雅な解決策であると信じています。
import os
if os.name == 'nt':
import msvcrt
def getch():
return msvcrt.getch().decode()
else:
import sys, tty, termios
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
def getch():
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
そしてそれをコードの中で使います。
if getch() == chr(ESC_ASCII_VALUE):
print("ESC!")
もし私が複雑なことをしているのであれば、私は呪いを使ってキーを読みます。しかし、多くの場合、標準ライブラリを使用して矢印キーを読み取ることができる単純なPython 3スクリプトが必要なので、これを行います。
import sys, termios, tty
key_Enter = 13
key_Esc = 27
key_Up = '\033[A'
key_Dn = '\033[B'
key_Rt = '\033[C'
key_Lt = '\033[D'
fdInput = sys.stdin.fileno()
termAttr = termios.tcgetattr(0)
def getch():
tty.setraw(fdInput)
ch = sys.stdin.buffer.raw.read(4).decode(sys.stdin.encoding)
if len(ch) == 1:
if ord(ch) < 32 or ord(ch) > 126:
ch = ord(ch)
Elif ord(ch[0]) == 27:
ch = '\033' + ch[1:]
termios.tcsetattr(fdInput, termios.TCSADRAIN, termAttr)
return ch