0

I'm making a game that runs on the console in python. When I exit the game, all the keys I pressed are automatically typed. How do I stop this from happening? Also, I still want to have user input when I use the input() function. This is on Windows by the way.

If you want the code, this has the same "problem":

for _ in range(100000):
    print("Hello")

When the program finishes in the command prompt, this comes up:

C:\Users\User>awdsaawdsadwsaasdwaws

Basically, whatever keys were pressed while the code was running. This happens when other things run in the command prompt too, but I want to know how to disable it in python.

Edit: I kept digging and found that what I was looking for was flushing or clearing keyboard buffer. I marked my question as a duplicate of another which has a few answers, but this one worked best for me:

def flush_input():
    try:
        import msvcrt
        while msvcrt.kbhit():
            msvcrt.getch()
    except ImportError:
        import sys, termios    #for linux/unix
        termios.tcflush(sys.stdin, termios.TCIOFLUSH)
TeaCoast
  • 352
  • 3
  • 12
  • It would be pretty great if You could provide some code, so that we don't have to guess – Matiiss Apr 13 '21 at 22:21
  • Also this seems very unlikely unless Your program registers keys pressed and then loops over each key that was pressed and simulates it using python. But then You would know why that happens. – Matiiss Apr 13 '21 at 22:22
  • Ok so from my deduction (because You haven't yet provided code) I would say that there are print statements that print everything that was put in by user using `input()` at the end – Matiiss Apr 13 '21 at 22:24
  • @Matiiss The game in the console is snake game. When the program runs, I want there to be settings the user can alter using `input()`. That's why there is input. But aside from that, when you die, all the keys you've pressed are in the next line, like `C:\Users\User>awdsadwdasdawdasdasdsawdas` – TeaCoast Apr 13 '21 at 22:32
  • as I said You should provide code. How do You think I will be able to answer as to why that might happen if I don't know what You have put in Your code? – Matiiss Apr 13 '21 at 22:37
  • You don't really need code. When I type a key during this: `for _ in range(100000): print("Hello")` the same thing happens – TeaCoast Apr 13 '21 at 23:02
  • @Matiiss this isn't a bug in my program, it's something that happens anyway that I want to stop happening. – TeaCoast Apr 13 '21 at 23:05
  • I have no idea why it happens (You run the python on cmd?) still no idea – Matiiss Apr 13 '21 at 23:25
  • wait I just tested. It may be because python thinks You are entering a new line while it is being executed. No idea of how to get rid of that tho – Matiiss Apr 13 '21 at 23:26

1 Answers1

1

This happens because your computer registers the key strokes and on the console, those are made available on the stdin input stream.

If you save your script as test.py and run python test.py and start entering some keystrokes, like abc, those letters will be on standard input.

Your script doesn't read them, because it doesn't touch that stream, as you're not using input() or any other calls that would read that stream. So your script finishes, the characters are still on standard input, the prompt comes back and it reads those characters, with the given result:

Hello
Hello
Hello
PS C:\Users\username> abc

To avoid this, you can read / flush the input buffer at the end of your script. However, this is surprisingly hard if you need it to work across all operating systems and in different modes of running your script (directly from cmd, IDLE, in other IDEs, etc.)

The problem is there's no way to know if there's input on the standard input stream, until you try to read from it. But if you try to read from it, your script will pause until an 'end of line' or 'end of file' is received. And if the user is just hitting keys, that won't happen, so you'll end up reading until they hit something like Ctrl+Break or Ctrl+C.

Here's a way I think is relatively robust, but I recommend you test it in scenarios and environments you consider likely for use of your script:

import sys
import threading
import queue
import os
import signal

for _ in range(100000):
    print("Hello")

timeout = 0.1  # sec


def no_input():
    # stop main thread (which is probably blocked reading input) via an interrupt signal
    # only available for windows in Python version 3.2 or higher
    os.kill(os.getpid(), signal.SIGINT)
    exit()


# if a sigint is received, exit the main thread (you could call another function to do work first and then exit()
signal.signal(signal.SIGINT, exit)

# input is stored here, until it's dealt with
input_queue = queue.Queue()


# read all available input until main thread exit
def get_input():
    while True:
        try:
            # read input, not doing anything with it
            _ = input_queue.get(timeout=timeout)
        except queue.Empty:
            no_input()


reading_thread = threading.Thread(target=get_input)
reading_thread.start()

# main loop: put any available input in the queue, will wait for input if there is none
for line in sys.stdin:
    input_queue.put(line)

# wait for reading thread
reading_thread.join()

It basically reads the input from a second thread, allowing that the main thread to get the input and possibly do something with it until there's nothing left and then it just tells the main thread to exit. Note that this will result in your script exiting with an exit code of 2, which may not be what you want.

Also note that you'll still see the input on screen, but it will no longer be passed to the terminal:

Hello
Hello
Hello
abc
PS C:\Users\username>

I don't know if there's an easy way to avoid the echo, other than on Linux doing something like stty -echo. You could of course just call the system to clear the screen at the end of your script:

from subprocess import call
from os import name as os_name

call('clear' if os_name =='posix' else 'cls')
Grismar
  • 27,561
  • 4
  • 31
  • 54