How to read a single character from the user

Question

Is there a way of reading one single character from the user input  For instance  they press one key at the terminal and it is returned  sort of like getch     I know there s a function in Windows for it  but I d like something that is cross-platform

User · Answer

Try this with 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

User · Answer

Answered here  raw input in python without pressing enter  Use this code-  from tkinter import Tk  Frame   def   set key e  root               e - event with attribute  char   the released key             global key pressed     if e char          key pressed   e char         root destroy     def get key msg  Press any key       time to sleep 3               msg - set to empty string if you don t want to print anything     time to sleep - default 3 seconds             global key pressed     if msg          print msg      key pressed   None     root   Tk       root overrideredirect True      frame   Frame root  width 0  height 0      frame bind   lt KeyRelease gt    lambda f    set key f  root       frame pack       root focus set       frame focus set       frame focus force      doesn t work in a while loop without it     root after time to sleep   1000  func root destroy      root mainloop       root   None    just in case     return key pressed   def   main            c   None         while not c                  c   get key  Choose your weapon        2          print c   if   name         main           main     Reference  https   github com unfor19 mg-tools blob master mgtools get key pressed py

User · Answer

The ActiveState recipe quoted verbatim in two answers is over-engineered  It can be boiled down to this   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

User · Answer

The curses package in python can be used to enter  raw  mode for character input from the terminal with just a few statements   Curses  main use is to take over the screen for output  which may not be what you want  This code snippet uses print   statements instead  which are usable  but you must be aware of how curses changes line endings attached to output       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

User · Answer

The curses package in python can be used to enter  raw  mode for character input from the terminal with just a few statements   Curses  main use is to take over the screen for output  which may not be what you want  This code snippet uses print   statements instead  which are usable  but you must be aware of how curses changes line endings attached to output       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

User · Answer

The accepted answer didn t perform that well for me  I d hold a key  nothing would happen  then I d press another key and it would work    After learning about the curses module  it really seems like the right way to go  And it s now available for Windows through windows-cursors  available through pip   so you can program in a platform agnostic manner  Here s an example inspired by this nice tutorial on YouTube   import curses                                                                                                                                        def getkey stdscr       curses curs set 0      while True          key   stdscr getch           if key    -1              break     return key  if   name         main         print curses wrapper getkey     Save it with a  py extension  or run curses wrapper getkey  in interactive mode

User · Answer

Try using this  http   home wlu edu  levys software kbhit py It s non-blocking  that means that you can have a while loop and detect a key press without stopping it  and cross-platform   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   amp   termios ICANON  amp   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         An example to use this   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     Or you could use the getch module from PyPi  But this would block the while loop

User · Answer

Here s a link to a site that says how you can read a single character in Windows  Linux and OSX  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

User · Answer

sys stdin read 1    will basically read 1 byte from STDIN   If you must use the method which does not wait for the  n you can use this code as suggested in previous answer   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      taken from http   code activestate com recipes 134892

User · Answer

Try using this  http   home wlu edu  levys software kbhit py It s non-blocking  that means that you can have a while loop and detect a key press without stopping it  and cross-platform   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   amp   termios ICANON  amp   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         An example to use this   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     Or you could use the getch module from PyPi  But this would block the while loop

User · Answer

A comment in one of the other answers mentioned cbreak mode  which is important for Unix implementations because you generally don t want  C  KeyboardError  to be consumed by getchar  as it will when you set the terminal to raw mode  as done by most other answers    Another important detail is that if you re looking to read one character and not one byte  you should read 4 bytes from the input stream  as that s the maximum number of bytes a single character will consist of in UTF-8  Python 3    Reading only a single byte will produce unexpected results for multi-byte characters such as keypad arrows   Here s my changed implementation for 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

User · Answer

sys stdin read 1    will basically read 1 byte from STDIN   If you must use the method which does not wait for the  n you can use this code as suggested in previous answer   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      taken from http   code activestate com recipes 134892

User · Answer

The build-in raw input should help    for i in range 3       print   So much work to do    k   raw input  Press any key to continue      print   Ok  back to work

User · Answer

This is NON-BLOCKING  reads a key and and stores it in keypress key    import Tkinter as tk   class Keypress      def   init   self           self root   tk Tk           self root geometry  300x200           self root bind   lt KeyPress gt    self onKeyPress       def onKeyPress self  event           self key   event char      def   eq   self  other           return self key    other      def   str   self           return self key   in your programm  keypress   Keypress    while something     do something    if keypress     c           break    elif keypress     i           print  info      else         print  i dont understand  s    keypress

User · Answer

Also worth trying is the readchar library  which is in part based on the ActiveState recipe mentioned in other answers   Installation   pip install readchar   Usage   import readchar print  Reading a char    print repr readchar readchar     print  Reading a key    print repr readchar readkey       Tested on Windows and Linux with Python 2 7   On Windows  only keys which map to letters or ASCII control codes are supported  Backspace  Enter  Esc  Tab  Ctrl letter   On GNU Linux  depending on exact terminal  perhaps   you also get Insert  Delete  Pg Up  Pg Dn  Home  End and F n keys    but then  there s issues separating these special keys from an Esc   Caveat  Like with most  all   answers in here  signal keys like Ctrl C  Ctrl D and Ctrl Z are caught and returned  as   x03     x04  and   x1a  respectively   your program can be come difficult to abort

User · Answer

if you just want to hold the screen so you can see the result on the terminal just write  input     at the end of the code and it will hold the screen

User · Answer

A comment in one of the other answers mentioned cbreak mode  which is important for Unix implementations because you generally don t want  C  KeyboardError  to be consumed by getchar  as it will when you set the terminal to raw mode  as done by most other answers    Another important detail is that if you re looking to read one character and not one byte  you should read 4 bytes from the input stream  as that s the maximum number of bytes a single character will consist of in UTF-8  Python 3    Reading only a single byte will produce unexpected results for multi-byte characters such as keypad arrows   Here s my changed implementation for 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

User · Answer

This code  based off here  will correctly raise KeyboardInterrupt and EOFError if Ctrl C or Ctrl D are pressed   Should work on Windows and Linux  An OS X version is available from the original source   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

User · Answer

This is NON-BLOCKING  reads a key and and stores it in keypress key    import Tkinter as tk   class Keypress      def   init   self           self root   tk Tk           self root geometry  300x200           self root bind   lt KeyPress gt    self onKeyPress       def onKeyPress self  event           self key   event char      def   eq   self  other           return self key    other      def   str   self           return self key   in your programm  keypress   Keypress    while something     do something    if keypress     c           break    elif keypress     i           print  info      else         print  i dont understand  s    keypress

User · Answer

If you want to register only one single key press even if the user pressed it for more than once or kept pressing the key longer  To avoid getting multiple pressed inputs use the while loop and pass it   import keyboard  while True     if keyboard is pressed  w           s  1       while keyboard is pressed  w             pass   if keyboard is pressed  s           s- 1       while keyboard is pressed  s             pass   print s

User · Answer

If I m doing something complicated I ll use curses to read keys  But a lot of times I just want a simple Python 3 script that uses the standard library and can read arrow keys  so I do this   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   lt  32 or ord ch   gt  126              ch   ord ch      elif ord ch 0      27          ch     033    ch 1       termios tcsetattr fdInput  termios TCSADRAIN  termAttr      return ch

User · Answer

The build-in raw input should help    for i in range 3       print   So much work to do    k   raw input  Press any key to continue      print   Ok  back to work

User · Answer

The ActiveState s recipe seems to contain a little bug for  posix  systems that prevents Ctrl-C from interrupting  I m using Mac   If I put the following code in my script   while True       print getch      I will never be able to terminate the script with Ctrl-C  and I have to kill my terminal to escape   I believe the following line is the cause  and it s also too brutal   tty setraw sys stdin fileno      Asides from that  package tty is not really needed  termios is enough to handle it   Below is the improved code that works for me  Ctrl-C will interrupt   with the extra getche function that echo the char as you type   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   amp   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    References    https   pypi python org pypi getch

User · Answer

The answers here were informative  however I also wanted a way to get key presses asynchronously and fire off key presses in separate events  all in a thread-safe  cross-platform way  PyGame was also too bloated for me  So I made the following  in Python 2 7 but I suspect it s easily portable   which I figured I d share here in case it was useful for anyone else  I stored this in a file named keyPress py  class  Getch       quot  quot  quot Gets a single character from standard input   Does not echo to the screen  From http   code activestate com recipes 134892  quot  quot  quot      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       quot  quot  quot      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       quot  quot  quot      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  amp  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  quot Event  s  quot    list   repr   self                def getKey        inkey    Getch       import sys     for i in xrange sys maxint           k inkey           if k lt  gt    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  quot Keys are still being captured quot         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  quot Keys are still being captured quot               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    The idea is that you can either simply call keyPress getKey    which will read a key from the keyboard  then return it  If you want something more than that  I made a KeyCapture object  You can create one via something like keys   keyPress KeyCapture    Then there are three things you can do  addEvent functionName  takes in any function that takes in one parameter  Then every time a key is pressed  this function will be called with that key s string as it s input  These are ran in a separate thread  so you can block all you want in them and it won t mess up the functionality of the KeyCapturer nor delay the other events  get   returns a key in the same blocking way as before  It is now needed here because the keys are being captured via the KeyCapture object now  so keyPress getKey   would conflict with that behavior and both of them would miss some keys since only one key can be captured at a time  Also  say the user presses  a   then  b   you call get    the user presses  c   That get   call  will immediately return  a   then if you call it again it will return  b   then  c   If you call it again it will block until another key is pressed  This ensures that you don t miss any keys  in a blocking way if desired  So in this way it s a little different than keyPress getKey   from before If you want the behavior of getKey   back  get lossy True  is like get    except that it only returns keys pressed after the call to get    So in the above example  get   would block until the user presses  c   and then if you call it again it will block until another key is pressed  getAsync   is a little different  It s designed for something that does a lot of processing  then occasionally comes back and checks which keys were pressed  Thus getAsync   returns a list of all the keys pressed since the last call to getAsync    in order from oldest key pressed to most recent key pressed  It also doesn t block  meaning that if no keys have been pressed since the last call to getAsync    an empty     will be returned  To actually start capturing keys  you need to call keys startCapture   with your keys object made above  startCapture is non-blocking  and simply starts one thread that just records the key presses  and another thread to process those key presses  There are two threads to ensure that the thread that records key presses doesn t miss any keys  If you want to stop capturing keys  you can call keys stopCapture   and it will stop capturing keys  However  since capturing a key is a blocking operation  the thread capturing keys might capture one more key after calling stopCapture    To prevent this  you can pass in an optional parameter s  into startCapture functionName  args  of a function that just does something like checks if a key equals  c  and then exits  It s important that this function does very little before  for example  a sleep here will cause us to miss keys  However  if stopCapture   is called in this function  key captures will be stopped immediately  without trying to capture any more  and that all get   calls will be returned immediately  with None if no keys have been pressed yet  Also  since get   and getAsync   store all the previous keys pressed  until you retrieve them   you can call clearGetList   and clearAsyncList   to forget the keys previously pressed  Note that get    getAsync   and events are independent  so if a key is pressed   One call to get   that is waiting  with lossy on  will return that key  The other waiting calls  if any  will continue waiting  That key 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  All events will be fired with that key as their input That key will be stored in the list of getAsync   keys  where that lis twill be returned and set to empty list on the next call to getAsync    If all this is too much  here is an example use case  import keyPress import time import threading  def KeyPressed k  printLock       printLock acquire       print  quot Event   quot    k     printLock release       time sleep 4      printLock acquire       print  quot Event after delay   quot    k     printLock release    def GetKeyBlocking keys  printLock           while keys capturing            keyReceived   keys get           time sleep 1          printLock acquire           if not keyReceived is None              print  quot Block  quot    keyReceived         else              print  quot Block None quot          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  quot Lossy   quot    keyReceived         else              print  quot Lossy  None quot          printLock release    def CheckToClose k   keys  printLock        printLock acquire       print  quot Close   quot    k     printLock release       if k     quot c quot           keys stopCapture            printLock   threading Lock    print  quot Press a key  quot  print  quot You pressed   quot    keyPress getKey   print  quot  quot   keys   keyPress KeyCapture    keys addEvent KeyPressed  printLock     print  quot Starting capture quot               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  quot Async   quot    str keysPressed      printLock release       time sleep 1   print  quot done capturing quot   It is working well for me from the simple test I made  but I will happily take others feedback as well if there is something I missed  I posted this here as well

User · Answer

The answers here were informative  however I also wanted a way to get key presses asynchronously and fire off key presses in separate events  all in a thread-safe  cross-platform way  PyGame was also too bloated for me  So I made the following  in Python 2 7 but I suspect it s easily portable   which I figured I d share here in case it was useful for anyone else  I stored this in a file named keyPress py  class  Getch       quot  quot  quot Gets a single character from standard input   Does not echo to the screen  From http   code activestate com recipes 134892  quot  quot  quot      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       quot  quot  quot      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       quot  quot  quot      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  amp  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  quot Event  s  quot    list   repr   self                def getKey        inkey    Getch       import sys     for i in xrange sys maxint           k inkey           if k lt  gt    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  quot Keys are still being captured quot         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  quot Keys are still being captured quot               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    The idea is that you can either simply call keyPress getKey    which will read a key from the keyboard  then return it  If you want something more than that  I made a KeyCapture object  You can create one via something like keys   keyPress KeyCapture    Then there are three things you can do  addEvent functionName  takes in any function that takes in one parameter  Then every time a key is pressed  this function will be called with that key s string as it s input  These are ran in a separate thread  so you can block all you want in them and it won t mess up the functionality of the KeyCapturer nor delay the other events  get   returns a key in the same blocking way as before  It is now needed here because the keys are being captured via the KeyCapture object now  so keyPress getKey   would conflict with that behavior and both of them would miss some keys since only one key can be captured at a time  Also  say the user presses  a   then  b   you call get    the user presses  c   That get   call  will immediately return  a   then if you call it again it will return  b   then  c   If you call it again it will block until another key is pressed  This ensures that you don t miss any keys  in a blocking way if desired  So in this way it s a little different than keyPress getKey   from before If you want the behavior of getKey   back  get lossy True  is like get    except that it only returns keys pressed after the call to get    So in the above example  get   would block until the user presses  c   and then if you call it again it will block until another key is pressed  getAsync   is a little different  It s designed for something that does a lot of processing  then occasionally comes back and checks which keys were pressed  Thus getAsync   returns a list of all the keys pressed since the last call to getAsync    in order from oldest key pressed to most recent key pressed  It also doesn t block  meaning that if no keys have been pressed since the last call to getAsync    an empty     will be returned  To actually start capturing keys  you need to call keys startCapture   with your keys object made above  startCapture is non-blocking  and simply starts one thread that just records the key presses  and another thread to process those key presses  There are two threads to ensure that the thread that records key presses doesn t miss any keys  If you want to stop capturing keys  you can call keys stopCapture   and it will stop capturing keys  However  since capturing a key is a blocking operation  the thread capturing keys might capture one more key after calling stopCapture    To prevent this  you can pass in an optional parameter s  into startCapture functionName  args  of a function that just does something like checks if a key equals  c  and then exits  It s important that this function does very little before  for example  a sleep here will cause us to miss keys  However  if stopCapture   is called in this function  key captures will be stopped immediately  without trying to capture any more  and that all get   calls will be returned immediately  with None if no keys have been pressed yet  Also  since get   and getAsync   store all the previous keys pressed  until you retrieve them   you can call clearGetList   and clearAsyncList   to forget the keys previously pressed  Note that get    getAsync   and events are independent  so if a key is pressed   One call to get   that is waiting  with lossy on  will return that key  The other waiting calls  if any  will continue waiting  That key 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  All events will be fired with that key as their input That key will be stored in the list of getAsync   keys  where that lis twill be returned and set to empty list on the next call to getAsync    If all this is too much  here is an example use case  import keyPress import time import threading  def KeyPressed k  printLock       printLock acquire       print  quot Event   quot    k     printLock release       time sleep 4      printLock acquire       print  quot Event after delay   quot    k     printLock release    def GetKeyBlocking keys  printLock           while keys capturing            keyReceived   keys get           time sleep 1          printLock acquire           if not keyReceived is None              print  quot Block  quot    keyReceived         else              print  quot Block None quot          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  quot Lossy   quot    keyReceived         else              print  quot Lossy  None quot          printLock release    def CheckToClose k   keys  printLock        printLock acquire       print  quot Close   quot    k     printLock release       if k     quot c quot           keys stopCapture            printLock   threading Lock    print  quot Press a key  quot  print  quot You pressed   quot    keyPress getKey   print  quot  quot   keys   keyPress KeyCapture    keys addEvent KeyPressed  printLock     print  quot Starting capture quot               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  quot Async   quot    str keysPressed      printLock release       time sleep 1   print  quot done capturing quot   It is working well for me from the simple test I made  but I will happily take others feedback as well if there is something I missed  I posted this here as well

User · Answer

I believe that this is one the most elegant solution   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   and then use it in the code   if getch      chr ESC ASCII VALUE       print  ESC

User · Answer

I believe that this is one the most elegant solution   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   and then use it in the code   if getch      chr ESC ASCII VALUE       print  ESC

User · Answer

Here s a link to a site that says how you can read a single character in Windows  Linux and OSX  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

User · Answer

This code  based off here  will correctly raise KeyboardInterrupt and EOFError if Ctrl C or Ctrl D are pressed   Should work on Windows and Linux  An OS X version is available from the original source   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

User · Answer

The  currently  top-ranked answer  with the ActiveState code  is overly complicated  I don t see a reason to use classes when a mere function should suffice  Below are two implementations that accomplish the same thing but with more readable code   Both of these implementations    work just fine in Python 2 or Python 3 work on Windows  OSX  and Linux read just one byte  i e   they don t wait for a newline  don t depend on any external libraries are self-contained  no code outside of the function definition    Version 1  readable and simple  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  amp  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   Version 2  avoid repeated imports and exception handling    EDIT  I missed one advantage of the ActiveState code  If you plan to read characters multiple times  that code avoids the  negligible  cost of repeating the Windows import and the ImportError exception handling on Unix-like systems  While you probably should be more concerned about code readability than that negligible optimization  here is an alternative  it is similar to Louis s answer  but getChar   is self-contained  that functions the same as the ActiveState code and is more readable   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  amp  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     Example code that exercises either of the getChar   versions above   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 gt     answer   getChar   print   n   print responseStr format answer

User · Answer

Also worth trying is the readchar library  which is in part based on the ActiveState recipe mentioned in other answers   Installation   pip install readchar   Usage   import readchar print  Reading a char    print repr readchar readchar     print  Reading a key    print repr readchar readkey       Tested on Windows and Linux with Python 2 7   On Windows  only keys which map to letters or ASCII control codes are supported  Backspace  Enter  Esc  Tab  Ctrl letter   On GNU Linux  depending on exact terminal  perhaps   you also get Insert  Delete  Pg Up  Pg Dn  Home  End and F n keys    but then  there s issues separating these special keys from an Esc   Caveat  Like with most  all   answers in here  signal keys like Ctrl C  Ctrl D and Ctrl Z are caught and returned  as   x03     x04  and   x1a  respectively   your program can be come difficult to abort

User · Answer

My solution for python3  not depending on any pip packages     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

User · Answer

Here s a link to a site that says how you can read a single character in Windows  Linux and OSX  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

User · Answer

The ActiveState s recipe seems to contain a little bug for  posix  systems that prevents Ctrl-C from interrupting  I m using Mac   If I put the following code in my script   while True       print getch      I will never be able to terminate the script with Ctrl-C  and I have to kill my terminal to escape   I believe the following line is the cause  and it s also too brutal   tty setraw sys stdin fileno      Asides from that  package tty is not really needed  termios is enough to handle it   Below is the improved code that works for me  Ctrl-C will interrupt   with the extra getche function that echo the char as you type   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   amp   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    References    https   pypi python org pypi getch

User · Answer

An alternative method   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   amp   termios ICANON  amp   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   From this blog post

User · Answer

Here s a link to a site that says how you can read a single character in Windows  Linux and OSX  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

User · Answer

sys stdin read 1    will basically read 1 byte from STDIN   If you must use the method which does not wait for the  n you can use this code as suggested in previous answer   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      taken from http   code activestate com recipes 134892

User · Answer

If you want to register only one single key press even if the user pressed it for more than once or kept pressing the key longer  To avoid getting multiple pressed inputs use the while loop and pass it   import keyboard  while True     if keyboard is pressed  w           s  1       while keyboard is pressed  w             pass   if keyboard is pressed  s           s- 1       while keyboard is pressed  s             pass   print s

User · Answer

If I m doing something complicated I ll use curses to read keys  But a lot of times I just want a simple Python 3 script that uses the standard library and can read arrow keys  so I do this   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   lt  32 or ord ch   gt  126              ch   ord ch      elif ord ch 0      27          ch     033    ch 1       termios tcsetattr fdInput  termios TCSADRAIN  termAttr      return ch

User · Answer

This might be a use case for a context manager   Leaving aside allowances for Windows OS  here s my suggestion      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  lt Enter gt    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   lt   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   name         main         test

User · Answer

sys stdin read 1    will basically read 1 byte from STDIN   If you must use the method which does not wait for the  n you can use this code as suggested in previous answer   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      taken from http   code activestate com recipes 134892

User · Answer

The  currently  top-ranked answer  with the ActiveState code  is overly complicated  I don t see a reason to use classes when a mere function should suffice  Below are two implementations that accomplish the same thing but with more readable code   Both of these implementations    work just fine in Python 2 or Python 3 work on Windows  OSX  and Linux read just one byte  i e   they don t wait for a newline  don t depend on any external libraries are self-contained  no code outside of the function definition    Version 1  readable and simple  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  amp  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   Version 2  avoid repeated imports and exception handling    EDIT  I missed one advantage of the ActiveState code  If you plan to read characters multiple times  that code avoids the  negligible  cost of repeating the Windows import and the ImportError exception handling on Unix-like systems  While you probably should be more concerned about code readability than that negligible optimization  here is an alternative  it is similar to Louis s answer  but getChar   is self-contained  that functions the same as the ActiveState code and is more readable   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  amp  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     Example code that exercises either of the getChar   versions above   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 gt     answer   getChar   print   n   print responseStr format answer

User · Answer

Answered here  raw input in python without pressing enter  Use this code-  from tkinter import Tk  Frame   def   set key e  root               e - event with attribute  char   the released key             global key pressed     if e char          key pressed   e char         root destroy     def get key msg  Press any key       time to sleep 3               msg - set to empty string if you don t want to print anything     time to sleep - default 3 seconds             global key pressed     if msg          print msg      key pressed   None     root   Tk       root overrideredirect True      frame   Frame root  width 0  height 0      frame bind   lt KeyRelease gt    lambda f    set key f  root       frame pack       root focus set       frame focus set       frame focus force      doesn t work in a while loop without it     root after time to sleep   1000  func root destroy      root mainloop       root   None    just in case     return key pressed   def   main            c   None         while not c                  c   get key  Choose your weapon        2          print c   if   name         main           main     Reference  https   github com unfor19 mg-tools blob master mgtools get key pressed py

User · Answer

if you just want to hold the screen so you can see the result on the terminal just write  input     at the end of the code and it will hold the screen

User · Answer

My solution for python3  not depending on any pip packages     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

User · Answer

The ActiveState recipe quoted verbatim in two answers is over-engineered  It can be boiled down to this   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

User · Answer

Try this with 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

User · Answer

The accepted answer didn t perform that well for me  I d hold a key  nothing would happen  then I d press another key and it would work    After learning about the curses module  it really seems like the right way to go  And it s now available for Windows through windows-cursors  available through pip   so you can program in a platform agnostic manner  Here s an example inspired by this nice tutorial on YouTube   import curses                                                                                                                                        def getkey stdscr       curses curs set 0      while True          key   stdscr getch           if key    -1              break     return key  if   name         main         print curses wrapper getkey     Save it with a  py extension  or run curses wrapper getkey  in interactive mode

User · Answer

An alternative method   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   amp   termios ICANON  amp   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   From this blog post

User · Answer

This might be a use case for a context manager   Leaving aside allowances for Windows OS  here s my suggestion      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  lt Enter gt    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   lt   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   name         main         test

[python] How to read a single character from the user?

Examples related to python

Examples related to input